projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add parens like the comment says.
[deliverable/binutils-gdb.git] / bfd / elf32-i386.c
CommitLineData
252b5132 1/* Intel 80386/80486-specific support for 32-bit ELF
638632bd
AM		 2 Copyright 1993, 94, 95, 96, 97, 98, 99, 2000
3 Free Software Foundation, Inc.
252b5132
RH		 4
5This file is part of BFD, the Binary File Descriptor library.
6
7This program is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2 of the License, or
10(at your option) any later version.
11
12This program is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with this program; if not, write to the Free Software
19Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21#include "bfd.h"
22#include "sysdep.h"
23#include "bfdlink.h"
24#include "libbfd.h"
25#include "elf-bfd.h"
26
27static reloc_howto_type *elf_i386_reloc_type_lookup
28 PARAMS ((bfd *, bfd_reloc_code_real_type));
29static void elf_i386_info_to_howto
30 PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
31static void elf_i386_info_to_howto_rel
32 PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
33static boolean elf_i386_is_local_label_name PARAMS ((bfd *, const char *));
34static struct bfd_hash_entry *elf_i386_link_hash_newfunc
35 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
36static struct bfd_link_hash_table *elf_i386_link_hash_table_create
37 PARAMS ((bfd *));
38static boolean elf_i386_check_relocs
39 PARAMS ((bfd *, struct bfd_link_info *, asection *,
40 const Elf_Internal_Rela *));
41static boolean elf_i386_adjust_dynamic_symbol
42 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
43static boolean elf_i386_size_dynamic_sections
44 PARAMS ((bfd *, struct bfd_link_info *));
45static boolean elf_i386_relocate_section
46 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
47 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
48static boolean elf_i386_finish_dynamic_symbol
49 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
50 Elf_Internal_Sym *));
51static boolean elf_i386_finish_dynamic_sections
52 PARAMS ((bfd *, struct bfd_link_info *));
53
54#define USE_REL 1 /* 386 uses REL relocations instead of RELA */
55
56#include "elf/i386.h"
57
58static reloc_howto_type elf_howto_table[]=
59{
1b452ec6
AM		 60 HOWTO(R_386_NONE, 0, 0, 0, false, 0, complain_overflow_bitfield,
61 bfd_elf_generic_reloc, "R_386_NONE",
62 true, 0x00000000, 0x00000000, false),
63 HOWTO(R_386_32, 0, 2, 32, false, 0, complain_overflow_bitfield,
64 bfd_elf_generic_reloc, "R_386_32",
65 true, 0xffffffff, 0xffffffff, false),
66 HOWTO(R_386_PC32, 0, 2, 32, true, 0, complain_overflow_bitfield,
67 bfd_elf_generic_reloc, "R_386_PC32",
68 true, 0xffffffff, 0xffffffff, true),
69 HOWTO(R_386_GOT32, 0, 2, 32, false, 0, complain_overflow_bitfield,
70 bfd_elf_generic_reloc, "R_386_GOT32",
71 true, 0xffffffff, 0xffffffff, false),
72 HOWTO(R_386_PLT32, 0, 2, 32, true, 0, complain_overflow_bitfield,
73 bfd_elf_generic_reloc, "R_386_PLT32",
74 true, 0xffffffff, 0xffffffff, true),
75 HOWTO(R_386_COPY, 0, 2, 32, false, 0, complain_overflow_bitfield,
76 bfd_elf_generic_reloc, "R_386_COPY",
77 true, 0xffffffff, 0xffffffff, false),
78 HOWTO(R_386_GLOB_DAT, 0, 2, 32, false, 0, complain_overflow_bitfield,
79 bfd_elf_generic_reloc, "R_386_GLOB_DAT",
80 true, 0xffffffff, 0xffffffff, false),
81 HOWTO(R_386_JUMP_SLOT, 0, 2, 32, false, 0, complain_overflow_bitfield,
82 bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
83 true, 0xffffffff, 0xffffffff, false),
84 HOWTO(R_386_RELATIVE, 0, 2, 32, false, 0, complain_overflow_bitfield,
85 bfd_elf_generic_reloc, "R_386_RELATIVE",
86 true, 0xffffffff, 0xffffffff, false),
87 HOWTO(R_386_GOTOFF, 0, 2, 32, false, 0, complain_overflow_bitfield,
88 bfd_elf_generic_reloc, "R_386_GOTOFF",
89 true, 0xffffffff, 0xffffffff, false),
90 HOWTO(R_386_GOTPC, 0, 2, 32, true, 0, complain_overflow_bitfield,
91 bfd_elf_generic_reloc, "R_386_GOTPC",
92 true, 0xffffffff, 0xffffffff, true),
93
dc47f327
AM		 94 /* We have a gap in the reloc numbers here.
95 R_386_standard counts the number up to this point, and
96 R_386_ext_offset is the value to subtract from a reloc type of
97 R_386_16 thru R_386_PC8 to form an index into this table. */
1b452ec6
AM		 98#define R_386_standard ((unsigned int) R_386_GOTPC + 1)
99#define R_386_ext_offset ((unsigned int) R_386_16 - R_386_standard)
100
252b5132 101 /* The remaining relocs are a GNU extension. */
1b452ec6
AM		 102 HOWTO(R_386_16, 0, 1, 16, false, 0, complain_overflow_bitfield,
103 bfd_elf_generic_reloc, "R_386_16",
104 true, 0xffff, 0xffff, false),
105 HOWTO(R_386_PC16, 0, 1, 16, true, 0, complain_overflow_bitfield,
106 bfd_elf_generic_reloc, "R_386_PC16",
107 true, 0xffff, 0xffff, true),
108 HOWTO(R_386_8, 0, 0, 8, false, 0, complain_overflow_bitfield,
109 bfd_elf_generic_reloc, "R_386_8",
110 true, 0xff, 0xff, false),
111 HOWTO(R_386_PC8, 0, 0, 8, true, 0, complain_overflow_signed,
112 bfd_elf_generic_reloc, "R_386_PC8",
dc47f327
AM		 113 true, 0xff, 0xff, true),
114
115 /* Another gap. */
116#define R_386_ext ((unsigned int) R_386_PC8 + 1 - R_386_ext_offset)
117#define R_386_vt_offset ((unsigned int) R_386_GNU_VTINHERIT - R_386_ext)
252b5132
RH		 118
119/* GNU extension to record C++ vtable hierarchy. */
252b5132
RH		 120 HOWTO (R_386_GNU_VTINHERIT, /* type */
121 0, /* rightshift */
122 2, /* size (0 = byte, 1 = short, 2 = long) */
123 0, /* bitsize */
124 false, /* pc_relative */
125 0, /* bitpos */
126 complain_overflow_dont, /* complain_on_overflow */
127 NULL, /* special_function */
128 "R_386_GNU_VTINHERIT", /* name */
129 false, /* partial_inplace */
130 0, /* src_mask */
131 0, /* dst_mask */
dc47f327 132 false),
252b5132
RH		 133
134/* GNU extension to record C++ vtable member usage. */
252b5132
RH		 135 HOWTO (R_386_GNU_VTENTRY, /* type */
136 0, /* rightshift */
137 2, /* size (0 = byte, 1 = short, 2 = long) */
138 0, /* bitsize */
139 false, /* pc_relative */
140 0, /* bitpos */
141 complain_overflow_dont, /* complain_on_overflow */
142 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
143 "R_386_GNU_VTENTRY", /* name */
144 false, /* partial_inplace */
145 0, /* src_mask */
146 0, /* dst_mask */
dc47f327
AM		 147 false)
148
149#define R_386_vt ((unsigned int) R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
150
151};
152
252b5132
RH		 153#ifdef DEBUG_GEN_RELOC
154#define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
155#else
156#define TRACE(str)
157#endif
158
159static reloc_howto_type *
160elf_i386_reloc_type_lookup (abfd, code)
7442e600 161 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 162 bfd_reloc_code_real_type code;
163{
164 switch (code)
165 {
166 case BFD_RELOC_NONE:
167 TRACE ("BFD_RELOC_NONE");
1b452ec6 168 return &elf_howto_table[(unsigned int) R_386_NONE ];
252b5132
RH		 169
170 case BFD_RELOC_32:
171 TRACE ("BFD_RELOC_32");
1b452ec6 172 return &elf_howto_table[(unsigned int) R_386_32 ];
252b5132
RH		 173
174 case BFD_RELOC_CTOR:
175 TRACE ("BFD_RELOC_CTOR");
1b452ec6 176 return &elf_howto_table[(unsigned int) R_386_32 ];
252b5132
RH		 177
178 case BFD_RELOC_32_PCREL:
179 TRACE ("BFD_RELOC_PC32");
1b452ec6 180 return &elf_howto_table[(unsigned int) R_386_PC32 ];
252b5132
RH		 181
182 case BFD_RELOC_386_GOT32:
183 TRACE ("BFD_RELOC_386_GOT32");
1b452ec6 184 return &elf_howto_table[(unsigned int) R_386_GOT32 ];
252b5132
RH		 185
186 case BFD_RELOC_386_PLT32:
187 TRACE ("BFD_RELOC_386_PLT32");
1b452ec6 188 return &elf_howto_table[(unsigned int) R_386_PLT32 ];
252b5132
RH		 189
190 case BFD_RELOC_386_COPY:
191 TRACE ("BFD_RELOC_386_COPY");
1b452ec6 192 return &elf_howto_table[(unsigned int) R_386_COPY ];
252b5132
RH		 193
194 case BFD_RELOC_386_GLOB_DAT:
195 TRACE ("BFD_RELOC_386_GLOB_DAT");
1b452ec6 196 return &elf_howto_table[(unsigned int) R_386_GLOB_DAT ];
252b5132
RH		 197
198 case BFD_RELOC_386_JUMP_SLOT:
199 TRACE ("BFD_RELOC_386_JUMP_SLOT");
1b452ec6 200 return &elf_howto_table[(unsigned int) R_386_JUMP_SLOT ];
252b5132
RH		 201
202 case BFD_RELOC_386_RELATIVE:
203 TRACE ("BFD_RELOC_386_RELATIVE");
1b452ec6 204 return &elf_howto_table[(unsigned int) R_386_RELATIVE ];
252b5132
RH		 205
206 case BFD_RELOC_386_GOTOFF:
207 TRACE ("BFD_RELOC_386_GOTOFF");
1b452ec6 208 return &elf_howto_table[(unsigned int) R_386_GOTOFF ];
252b5132
RH		 209
210 case BFD_RELOC_386_GOTPC:
211 TRACE ("BFD_RELOC_386_GOTPC");
1b452ec6 212 return &elf_howto_table[(unsigned int) R_386_GOTPC ];
252b5132
RH		 213
214 /* The remaining relocs are a GNU extension. */
215 case BFD_RELOC_16:
216 TRACE ("BFD_RELOC_16");
1b452ec6 217 return &elf_howto_table[(unsigned int) R_386_16 - R_386_ext_offset];
252b5132
RH		 218
219 case BFD_RELOC_16_PCREL:
220 TRACE ("BFD_RELOC_16_PCREL");
1b452ec6 221 return &elf_howto_table[(unsigned int) R_386_PC16 - R_386_ext_offset];
252b5132
RH		 222
223 case BFD_RELOC_8:
224 TRACE ("BFD_RELOC_8");
1b452ec6 225 return &elf_howto_table[(unsigned int) R_386_8 - R_386_ext_offset];
252b5132
RH		 226
227 case BFD_RELOC_8_PCREL:
228 TRACE ("BFD_RELOC_8_PCREL");
1b452ec6 229 return &elf_howto_table[(unsigned int) R_386_PC8 - R_386_ext_offset];
252b5132
RH		 230
231 case BFD_RELOC_VTABLE_INHERIT:
232 TRACE ("BFD_RELOC_VTABLE_INHERIT");
dc47f327
AM		 233 return &elf_howto_table[(unsigned int) R_386_GNU_VTINHERIT
234 - R_386_vt_offset];
252b5132
RH		 235
236 case BFD_RELOC_VTABLE_ENTRY:
237 TRACE ("BFD_RELOC_VTABLE_ENTRY");
dc47f327
AM		 238 return &elf_howto_table[(unsigned int) R_386_GNU_VTENTRY
239 - R_386_vt_offset];
252b5132
RH		 240
241 default:
242 break;
243 }
244
245 TRACE ("Unknown");
246 return 0;
247}
248
249static void
250elf_i386_info_to_howto (abfd, cache_ptr, dst)
7442e600
ILT		 251 bfd *abfd ATTRIBUTE_UNUSED;
252 arelent *cache_ptr ATTRIBUTE_UNUSED;
253 Elf32_Internal_Rela *dst ATTRIBUTE_UNUSED;
252b5132
RH		 254{
255 abort ();
256}
257
258static void
259elf_i386_info_to_howto_rel (abfd, cache_ptr, dst)
7442e600 260 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 261 arelent *cache_ptr;
262 Elf32_Internal_Rel *dst;
263{
dc47f327
AM		 264 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
265 unsigned int indx;
266
267 if ((indx = r_type) >= R_386_standard
268 && ((indx = r_type - R_386_ext_offset) - R_386_standard
269 >= R_386_ext - R_386_standard)
270 && ((indx = r_type - R_386_vt_offset) - R_386_ext
271 >= R_386_vt - R_386_ext))
252b5132 272 {
dc47f327
AM		 273 (*_bfd_error_handler) (_("%s: invalid relocation type %d"),
274 bfd_get_filename (abfd), (int) r_type);
275 indx = (unsigned int) R_386_NONE;
252b5132 276 }
dc47f327 277 cache_ptr->howto = &elf_howto_table[indx];
252b5132
RH		 278}
279
280/* Return whether a symbol name implies a local label. The UnixWare
281 2.1 cc generates temporary symbols that start with .X, so we
282 recognize them here. FIXME: do other SVR4 compilers also use .X?.
283 If so, we should move the .X recognition into
284 _bfd_elf_is_local_label_name. */
285
286static boolean
287elf_i386_is_local_label_name (abfd, name)
288 bfd *abfd;
289 const char *name;
290{
291 if (name[0] == '.' && name[1] == 'X')
292 return true;
293
294 return _bfd_elf_is_local_label_name (abfd, name);
295}
296\f
297/* Functions for the i386 ELF linker. */
298
299/* The name of the dynamic interpreter. This is put in the .interp
300 section. */
301
302#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
303
304/* The size in bytes of an entry in the procedure linkage table. */
305
306#define PLT_ENTRY_SIZE 16
307
308/* The first entry in an absolute procedure linkage table looks like
309 this. See the SVR4 ABI i386 supplement to see how this works. */
310
311static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] =
312{
313 0xff, 0x35, /* pushl contents of address */
314 0, 0, 0, 0, /* replaced with address of .got + 4. */
315 0xff, 0x25, /* jmp indirect */
316 0, 0, 0, 0, /* replaced with address of .got + 8. */
317 0, 0, 0, 0 /* pad out to 16 bytes. */
318};
319
320/* Subsequent entries in an absolute procedure linkage table look like
321 this. */
322
323static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
324{
325 0xff, 0x25, /* jmp indirect */
326 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
327 0x68, /* pushl immediate */
328 0, 0, 0, 0, /* replaced with offset into relocation table. */
329 0xe9, /* jmp relative */
330 0, 0, 0, 0 /* replaced with offset to start of .plt. */
331};
332
333/* The first entry in a PIC procedure linkage table look like this. */
334
335static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] =
336{
337 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
338 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
339 0, 0, 0, 0 /* pad out to 16 bytes. */
340};
341
342/* Subsequent entries in a PIC procedure linkage table look like this. */
343
344static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
345{
346 0xff, 0xa3, /* jmp *offset(%ebx) */
347 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
348 0x68, /* pushl immediate */
349 0, 0, 0, 0, /* replaced with offset into relocation table. */
350 0xe9, /* jmp relative */
351 0, 0, 0, 0 /* replaced with offset to start of .plt. */
352};
353
354/* The i386 linker needs to keep track of the number of relocs that it
355 decides to copy in check_relocs for each symbol. This is so that
356 it can discard PC relative relocs if it doesn't need them when
357 linking with -Bsymbolic. We store the information in a field
358 extending the regular ELF linker hash table. */
359
360/* This structure keeps track of the number of PC relative relocs we
361 have copied for a given symbol. */
362
363struct elf_i386_pcrel_relocs_copied
364{
365 /* Next section. */
366 struct elf_i386_pcrel_relocs_copied *next;
367 /* A section in dynobj. */
368 asection *section;
369 /* Number of relocs copied in this section. */
370 bfd_size_type count;
371};
372
373/* i386 ELF linker hash entry. */
374
375struct elf_i386_link_hash_entry
376{
377 struct elf_link_hash_entry root;
378
379 /* Number of PC relative relocs copied for this symbol. */
380 struct elf_i386_pcrel_relocs_copied *pcrel_relocs_copied;
381};
382
383/* i386 ELF linker hash table. */
384
385struct elf_i386_link_hash_table
386{
387 struct elf_link_hash_table root;
388};
389
390/* Declare this now that the above structures are defined. */
391
392static boolean elf_i386_discard_copies
393 PARAMS ((struct elf_i386_link_hash_entry *, PTR));
394
395/* Traverse an i386 ELF linker hash table. */
396
397#define elf_i386_link_hash_traverse(table, func, info) \
398 (elf_link_hash_traverse \
399 (&(table)->root, \
400 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
401 (info)))
402
403/* Get the i386 ELF linker hash table from a link_info structure. */
404
405#define elf_i386_hash_table(p) \
406 ((struct elf_i386_link_hash_table *) ((p)->hash))
407
408/* Create an entry in an i386 ELF linker hash table. */
409
410static struct bfd_hash_entry *
411elf_i386_link_hash_newfunc (entry, table, string)
412 struct bfd_hash_entry *entry;
413 struct bfd_hash_table *table;
414 const char *string;
415{
416 struct elf_i386_link_hash_entry *ret =
417 (struct elf_i386_link_hash_entry *) entry;
418
419 /* Allocate the structure if it has not already been allocated by a
420 subclass. */
421 if (ret == (struct elf_i386_link_hash_entry *) NULL)
422 ret = ((struct elf_i386_link_hash_entry *)
423 bfd_hash_allocate (table,
424 sizeof (struct elf_i386_link_hash_entry)));
425 if (ret == (struct elf_i386_link_hash_entry *) NULL)
426 return (struct bfd_hash_entry *) ret;
427
428 /* Call the allocation method of the superclass. */
429 ret = ((struct elf_i386_link_hash_entry *)
430 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
431 table, string));
432 if (ret != (struct elf_i386_link_hash_entry *) NULL)
433 {
434 ret->pcrel_relocs_copied = NULL;
435 }
436
437 return (struct bfd_hash_entry *) ret;
438}
439
440/* Create an i386 ELF linker hash table. */
441
442static struct bfd_link_hash_table *
443elf_i386_link_hash_table_create (abfd)
444 bfd *abfd;
445{
446 struct elf_i386_link_hash_table *ret;
447
448 ret = ((struct elf_i386_link_hash_table *)
449 bfd_alloc (abfd, sizeof (struct elf_i386_link_hash_table)));
450 if (ret == (struct elf_i386_link_hash_table *) NULL)
451 return NULL;
452
453 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
454 elf_i386_link_hash_newfunc))
455 {
456 bfd_release (abfd, ret);
457 return NULL;
458 }
459
460 return &ret->root.root;
461}
462
463/* Look through the relocs for a section during the first phase, and
464 allocate space in the global offset table or procedure linkage
465 table. */
466
467static boolean
468elf_i386_check_relocs (abfd, info, sec, relocs)
469 bfd *abfd;
470 struct bfd_link_info *info;
471 asection *sec;
472 const Elf_Internal_Rela *relocs;
473{
474 bfd *dynobj;
475 Elf_Internal_Shdr *symtab_hdr;
476 struct elf_link_hash_entry **sym_hashes;
dd5724d5 477 bfd_signed_vma *local_got_refcounts;
252b5132
RH		 478 const Elf_Internal_Rela *rel;
479 const Elf_Internal_Rela *rel_end;
480 asection *sgot;
481 asection *srelgot;
482 asection *sreloc;
483
484 if (info->relocateable)
485 return true;
486
487 dynobj = elf_hash_table (info)->dynobj;
488 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
489 sym_hashes = elf_sym_hashes (abfd);
dd5724d5 490 local_got_refcounts = elf_local_got_refcounts (abfd);
252b5132
RH		 491
492 sgot = NULL;
493 srelgot = NULL;
494 sreloc = NULL;
495
496 rel_end = relocs + sec->reloc_count;
497 for (rel = relocs; rel < rel_end; rel++)
498 {
499 unsigned long r_symndx;
500 struct elf_link_hash_entry *h;
501
502 r_symndx = ELF32_R_SYM (rel->r_info);
503
504 if (r_symndx < symtab_hdr->sh_info)
505 h = NULL;
506 else
507 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
508
509 /* Some relocs require a global offset table. */
510 if (dynobj == NULL)
511 {
512 switch (ELF32_R_TYPE (rel->r_info))
513 {
514 case R_386_GOT32:
515 case R_386_GOTOFF:
516 case R_386_GOTPC:
517 elf_hash_table (info)->dynobj = dynobj = abfd;
518 if (! _bfd_elf_create_got_section (dynobj, info))
519 return false;
520 break;
521
522 default:
523 break;
524 }
525 }
526
527 switch (ELF32_R_TYPE (rel->r_info))
528 {
529 case R_386_GOT32:
530 /* This symbol requires a global offset table entry. */
531
532 if (sgot == NULL)
533 {
534 sgot = bfd_get_section_by_name (dynobj, ".got");
535 BFD_ASSERT (sgot != NULL);
536 }
537
538 if (srelgot == NULL
539 && (h != NULL || info->shared))
540 {
541 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
542 if (srelgot == NULL)
543 {
544 srelgot = bfd_make_section (dynobj, ".rel.got");
545 if (srelgot == NULL
546 || ! bfd_set_section_flags (dynobj, srelgot,
547 (SEC_ALLOC
548 | SEC_LOAD
549 | SEC_HAS_CONTENTS
550 | SEC_IN_MEMORY
551 | SEC_LINKER_CREATED
552 | SEC_READONLY))
553 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
554 return false;
555 }
556 }
557
558 if (h != NULL)
559 {
dd5724d5 560 if (h->got.refcount == -1)
252b5132 561 {
dd5724d5 562 h->got.refcount = 1;
252b5132 563
dd5724d5
AM		 564 /* Make sure this symbol is output as a dynamic symbol. */
565 if (h->dynindx == -1)
566 {
567 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
568 return false;
569 }
252b5132 570
dd5724d5
AM		 571 sgot->_raw_size += 4;
572 srelgot->_raw_size += sizeof (Elf32_External_Rel);
573 }
574 else
575 h->got.refcount += 1;
252b5132
RH		 576 }
577 else
578 {
dd5724d5
AM		 579 /* This is a global offset table entry for a local symbol. */
580 if (local_got_refcounts == NULL)
252b5132
RH		 581 {
582 size_t size;
252b5132 583
dd5724d5
AM		 584 size = symtab_hdr->sh_info * sizeof (bfd_signed_vma);
585 local_got_refcounts = ((bfd_signed_vma *)
586 bfd_alloc (abfd, size));
587 if (local_got_refcounts == NULL)
252b5132 588 return false;
dd5724d5
AM		 589 elf_local_got_refcounts (abfd) = local_got_refcounts;
590 memset (local_got_refcounts, -1, size);
252b5132 591 }
dd5724d5 592 if (local_got_refcounts[r_symndx] == -1)
252b5132 593 {
dd5724d5 594 local_got_refcounts[r_symndx] = 1;
252b5132 595
dd5724d5
AM		 596 sgot->_raw_size += 4;
597 if (info->shared)
598 {
599 /* If we are generating a shared object, we need to
600 output a R_386_RELATIVE reloc so that the dynamic
601 linker can adjust this GOT entry. */
602 srelgot->_raw_size += sizeof (Elf32_External_Rel);
603 }
252b5132 604 }
dd5724d5
AM		 605 else
606 local_got_refcounts[r_symndx] += 1;
252b5132 607 }
252b5132
RH		 608 break;
609
610 case R_386_PLT32:
611 /* This symbol requires a procedure linkage table entry. We
612 actually build the entry in adjust_dynamic_symbol,
613 because this might be a case of linking PIC code which is
614 never referenced by a dynamic object, in which case we
615 don't need to generate a procedure linkage table entry
616 after all. */
617
618 /* If this is a local symbol, we resolve it directly without
619 creating a procedure linkage table entry. */
620 if (h == NULL)
621 continue;
622
dd5724d5
AM		 623 if (h->plt.refcount == -1)
624 {
625 h->plt.refcount = 1;
626 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
627 }
628 else
629 h->plt.refcount += 1;
252b5132
RH		 630 break;
631
632 case R_386_32:
633 case R_386_PC32:
7843f00e
ILT		 634 if (h != NULL)
635 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
636
252b5132 637 /* If we are creating a shared library, and this is a reloc
f69da49f
AM		 638 against a global symbol, or a non PC relative reloc
639 against a local symbol, then we need to copy the reloc
640 into the shared library. However, if we are linking with
641 -Bsymbolic, we do not need to copy a reloc against a
642 global symbol which is defined in an object we are
643 including in the link (i.e., DEF_REGULAR is set). At
644 this point we have not seen all the input files, so it is
645 possible that DEF_REGULAR is not set now but will be set
646 later (it is never cleared). We account for that
647 possibility below by storing information in the
648 pcrel_relocs_copied field of the hash table entry.
649 A similar situation occurs when creating shared libraries
650 and symbol visibility changes render the symbol local. */
252b5132
RH		 651 if (info->shared
652 && (sec->flags & SEC_ALLOC) != 0
653 && (ELF32_R_TYPE (rel->r_info) != R_386_PC32
654 || (h != NULL
655 && (! info->symbolic
656 || (h->elf_link_hash_flags
657 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
658 {
659 /* When creating a shared object, we must copy these
f69da49f
AM		 660 reloc types into the output file. We create a reloc
661 section in dynobj and make room for this reloc. */
252b5132
RH		 662 if (sreloc == NULL)
663 {
664 const char *name;
665
666 name = (bfd_elf_string_from_elf_section
667 (abfd,
668 elf_elfheader (abfd)->e_shstrndx,
669 elf_section_data (sec)->rel_hdr.sh_name));
670 if (name == NULL)
671 return false;
672
673 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
674 && strcmp (bfd_get_section_name (abfd, sec),
675 name + 4) == 0);
676
677 sreloc = bfd_get_section_by_name (dynobj, name);
678 if (sreloc == NULL)
679 {
680 flagword flags;
681
682 sreloc = bfd_make_section (dynobj, name);
683 flags = (SEC_HAS_CONTENTS | SEC_READONLY
684 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
685 if ((sec->flags & SEC_ALLOC) != 0)
686 flags |= SEC_ALLOC | SEC_LOAD;
687 if (sreloc == NULL
688 || ! bfd_set_section_flags (dynobj, sreloc, flags)
689 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
690 return false;
691 }
692 }
693
694 sreloc->_raw_size += sizeof (Elf32_External_Rel);
695
f69da49f
AM		 696 /* If this is a global symbol, we count the number of PC
697 relative relocations we have entered for this symbol,
698 so that we can discard them later as necessary. Note
699 that this function is only called if we are using an
700 elf_i386 linker hash table, which means that h is
701 really a pointer to an elf_i386_link_hash_entry. */
702 if (h != NULL
252b5132
RH		 703 && ELF32_R_TYPE (rel->r_info) == R_386_PC32)
704 {
705 struct elf_i386_link_hash_entry *eh;
706 struct elf_i386_pcrel_relocs_copied *p;
707
708 eh = (struct elf_i386_link_hash_entry *) h;
709
710 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
711 if (p->section == sreloc)
712 break;
713
714 if (p == NULL)
715 {
716 p = ((struct elf_i386_pcrel_relocs_copied *)
717 bfd_alloc (dynobj, sizeof *p));
718 if (p == NULL)
719 return false;
720 p->next = eh->pcrel_relocs_copied;
721 eh->pcrel_relocs_copied = p;
722 p->section = sreloc;
723 p->count = 0;
724 }
725
726 ++p->count;
727 }
728 }
729
730 break;
731
732 /* This relocation describes the C++ object vtable hierarchy.
733 Reconstruct it for later use during GC. */
734 case R_386_GNU_VTINHERIT:
735 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
736 return false;
737 break;
738
739 /* This relocation describes which C++ vtable entries are actually
740 used. Record for later use during GC. */
741 case R_386_GNU_VTENTRY:
742 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
743 return false;
744 break;
745
746 default:
747 break;
748 }
749 }
750
751 return true;
752}
753
754/* Return the section that should be marked against GC for a given
755 relocation. */
756
757static asection *
758elf_i386_gc_mark_hook (abfd, info, rel, h, sym)
759 bfd *abfd;
7442e600 760 struct bfd_link_info *info ATTRIBUTE_UNUSED;
252b5132
RH		 761 Elf_Internal_Rela *rel;
762 struct elf_link_hash_entry *h;
763 Elf_Internal_Sym *sym;
764{
765 if (h != NULL)
766 {
767 switch (ELF32_R_TYPE (rel->r_info))
768 {
769 case R_386_GNU_VTINHERIT:
770 case R_386_GNU_VTENTRY:
771 break;
772
773 default:
774 switch (h->root.type)
775 {
776 case bfd_link_hash_defined:
777 case bfd_link_hash_defweak:
778 return h->root.u.def.section;
779
780 case bfd_link_hash_common:
781 return h->root.u.c.p->section;
782
783 default:
784 break;
785 }
786 }
787 }
788 else
789 {
790 if (!(elf_bad_symtab (abfd)
791 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
792 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
793 && sym->st_shndx != SHN_COMMON))
794 {
795 return bfd_section_from_elf_index (abfd, sym->st_shndx);
796 }
797 }
798
799 return NULL;
800}
801
802/* Update the got entry reference counts for the section being removed. */
803
804static boolean
805elf_i386_gc_sweep_hook (abfd, info, sec, relocs)
dd5724d5 806 bfd *abfd;
7442e600 807 struct bfd_link_info *info ATTRIBUTE_UNUSED;
dd5724d5
AM		 808 asection *sec;
809 const Elf_Internal_Rela *relocs;
252b5132 810{
dd5724d5
AM		 811 Elf_Internal_Shdr *symtab_hdr;
812 struct elf_link_hash_entry **sym_hashes;
813 bfd_signed_vma *local_got_refcounts;
814 const Elf_Internal_Rela *rel, *relend;
815 unsigned long r_symndx;
816 struct elf_link_hash_entry *h;
817 bfd *dynobj;
818 asection *sgot;
819 asection *srelgot;
820
821 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
822 sym_hashes = elf_sym_hashes (abfd);
823 local_got_refcounts = elf_local_got_refcounts (abfd);
824
825 dynobj = elf_hash_table (info)->dynobj;
826 if (dynobj == NULL)
827 return true;
828
829 sgot = bfd_get_section_by_name (dynobj, ".got");
830 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
831
832 relend = relocs + sec->reloc_count;
833 for (rel = relocs; rel < relend; rel++)
834 switch (ELF32_R_TYPE (rel->r_info))
835 {
836 case R_386_GOT32:
837 case R_386_GOTOFF:
838 case R_386_GOTPC:
839 r_symndx = ELF32_R_SYM (rel->r_info);
840 if (r_symndx >= symtab_hdr->sh_info)
841 {
842 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
843 if (h->got.refcount > 0)
844 {
845 h->got.refcount -= 1;
846 if (h->got.refcount == 0)
847 {
848 sgot->_raw_size -= 4;
849 srelgot->_raw_size -= sizeof (Elf32_External_Rel);
850 }
851 }
852 }
853 else if (local_got_refcounts != NULL)
854 {
855 if (local_got_refcounts[r_symndx] > 0)
856 {
857 local_got_refcounts[r_symndx] -= 1;
858 if (local_got_refcounts[r_symndx] == 0)
859 {
860 sgot->_raw_size -= 4;
861 if (info->shared)
862 srelgot->_raw_size -= sizeof (Elf32_External_Rel);
863 }
864 }
865 }
866 break;
867
868 case R_386_PLT32:
869 r_symndx = ELF32_R_SYM (rel->r_info);
870 if (r_symndx >= symtab_hdr->sh_info)
871 {
872 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
873 if (h->plt.refcount > 0)
874 h->plt.refcount -= 1;
875 }
876 break;
877
878 default:
879 break;
880 }
252b5132
RH		 881
882 return true;
883}
884
885/* Adjust a symbol defined by a dynamic object and referenced by a
886 regular object. The current definition is in some section of the
887 dynamic object, but we're not including those sections. We have to
888 change the definition to something the rest of the link can
889 understand. */
890
891static boolean
892elf_i386_adjust_dynamic_symbol (info, h)
893 struct bfd_link_info *info;
894 struct elf_link_hash_entry *h;
895{
896 bfd *dynobj;
897 asection *s;
898 unsigned int power_of_two;
899
900 dynobj = elf_hash_table (info)->dynobj;
901
902 /* Make sure we know what is going on here. */
903 BFD_ASSERT (dynobj != NULL
904 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
905 || h->weakdef != NULL
906 || ((h->elf_link_hash_flags
907 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
908 && (h->elf_link_hash_flags
909 & ELF_LINK_HASH_REF_REGULAR) != 0
910 && (h->elf_link_hash_flags
911 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
912
913 /* If this is a function, put it in the procedure linkage table. We
914 will fill in the contents of the procedure linkage table later,
915 when we know the address of the .got section. */
916 if (h->type == STT_FUNC
917 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
918 {
dd5724d5
AM		 919 if ((! info->shared
920 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
921 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
922 || (info->shared && h->plt.refcount <= 0))
252b5132
RH		 923 {
924 /* This case can occur if we saw a PLT32 reloc in an input
dd5724d5
AM		 925 file, but the symbol was never referred to by a dynamic
926 object, or if all references were garbage collected. In
927 such a case, we don't actually need to build a procedure
928 linkage table, and we can just do a PC32 reloc instead. */
929 h->plt.offset = (bfd_vma) -1;
930 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
252b5132
RH		 931 return true;
932 }
933
934 /* Make sure this symbol is output as a dynamic symbol. */
935 if (h->dynindx == -1)
936 {
937 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
938 return false;
939 }
940
941 s = bfd_get_section_by_name (dynobj, ".plt");
942 BFD_ASSERT (s != NULL);
943
944 /* If this is the first .plt entry, make room for the special
945 first entry. */
946 if (s->_raw_size == 0)
947 s->_raw_size += PLT_ENTRY_SIZE;
948
949 /* If this symbol is not defined in a regular file, and we are
950 not generating a shared library, then set the symbol to this
951 location in the .plt. This is required to make function
952 pointers compare as equal between the normal executable and
953 the shared library. */
954 if (! info->shared
955 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
956 {
957 h->root.u.def.section = s;
958 h->root.u.def.value = s->_raw_size;
959 }
960
961 h->plt.offset = s->_raw_size;
962
963 /* Make room for this entry. */
964 s->_raw_size += PLT_ENTRY_SIZE;
965
966 /* We also need to make an entry in the .got.plt section, which
967 will be placed in the .got section by the linker script. */
252b5132
RH		 968 s = bfd_get_section_by_name (dynobj, ".got.plt");
969 BFD_ASSERT (s != NULL);
970 s->_raw_size += 4;
971
972 /* We also need to make an entry in the .rel.plt section. */
252b5132
RH		 973 s = bfd_get_section_by_name (dynobj, ".rel.plt");
974 BFD_ASSERT (s != NULL);
975 s->_raw_size += sizeof (Elf32_External_Rel);
976
977 return true;
978 }
979
980 /* If this is a weak symbol, and there is a real definition, the
981 processor independent code will have arranged for us to see the
982 real definition first, and we can just use the same value. */
983 if (h->weakdef != NULL)
984 {
985 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
986 || h->weakdef->root.type == bfd_link_hash_defweak);
987 h->root.u.def.section = h->weakdef->root.u.def.section;
988 h->root.u.def.value = h->weakdef->root.u.def.value;
989 return true;
990 }
991
992 /* This is a reference to a symbol defined by a dynamic object which
993 is not a function. */
994
995 /* If we are creating a shared library, we must presume that the
996 only references to the symbol are via the global offset table.
997 For such cases we need not do anything here; the relocations will
998 be handled correctly by relocate_section. */
999 if (info->shared)
1000 return true;
1001
7843f00e
ILT		 1002 /* If there are no references to this symbol that do not use the
1003 GOT, we don't need to generate a copy reloc. */
1004 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
1005 return true;
1006
252b5132
RH		 1007 /* We must allocate the symbol in our .dynbss section, which will
1008 become part of the .bss section of the executable. There will be
1009 an entry for this symbol in the .dynsym section. The dynamic
1010 object will contain position independent code, so all references
1011 from the dynamic object to this symbol will go through the global
1012 offset table. The dynamic linker will use the .dynsym entry to
1013 determine the address it must put in the global offset table, so
1014 both the dynamic object and the regular object will refer to the
1015 same memory location for the variable. */
1016
1017 s = bfd_get_section_by_name (dynobj, ".dynbss");
1018 BFD_ASSERT (s != NULL);
1019
1020 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1021 copy the initial value out of the dynamic object and into the
1022 runtime process image. We need to remember the offset into the
1023 .rel.bss section we are going to use. */
1024 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1025 {
1026 asection *srel;
1027
1028 srel = bfd_get_section_by_name (dynobj, ".rel.bss");
1029 BFD_ASSERT (srel != NULL);
1030 srel->_raw_size += sizeof (Elf32_External_Rel);
1031 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1032 }
1033
1034 /* We need to figure out the alignment required for this symbol. I
1035 have no idea how ELF linkers handle this. */
1036 power_of_two = bfd_log2 (h->size);
1037 if (power_of_two > 3)
1038 power_of_two = 3;
1039
1040 /* Apply the required alignment. */
1041 s->_raw_size = BFD_ALIGN (s->_raw_size,
1042 (bfd_size_type) (1 << power_of_two));
1043 if (power_of_two > bfd_get_section_alignment (dynobj, s))
1044 {
1045 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
1046 return false;
1047 }
1048
1049 /* Define the symbol as being at this point in the section. */
1050 h->root.u.def.section = s;
1051 h->root.u.def.value = s->_raw_size;
1052
1053 /* Increment the section size to make room for the symbol. */
1054 s->_raw_size += h->size;
1055
1056 return true;
1057}
1058
1059/* Set the sizes of the dynamic sections. */
1060
1061static boolean
1062elf_i386_size_dynamic_sections (output_bfd, info)
1063 bfd *output_bfd;
1064 struct bfd_link_info *info;
1065{
1066 bfd *dynobj;
1067 asection *s;
1068 boolean plt;
1069 boolean relocs;
1070 boolean reltext;
1071
1072 dynobj = elf_hash_table (info)->dynobj;
1073 BFD_ASSERT (dynobj != NULL);
1074
1075 if (elf_hash_table (info)->dynamic_sections_created)
1076 {
1077 /* Set the contents of the .interp section to the interpreter. */
1078 if (! info->shared)
1079 {
1080 s = bfd_get_section_by_name (dynobj, ".interp");
1081 BFD_ASSERT (s != NULL);
1082 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1083 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1084 }
1085 }
1086 else
1087 {
1088 /* We may have created entries in the .rel.got section.
1089 However, if we are not creating the dynamic sections, we will
1090 not actually use these entries. Reset the size of .rel.got,
1091 which will cause it to get stripped from the output file
1092 below. */
1093 s = bfd_get_section_by_name (dynobj, ".rel.got");
1094 if (s != NULL)
1095 s->_raw_size = 0;
1096 }
1097
1098 /* If this is a -Bsymbolic shared link, then we need to discard all
1099 PC relative relocs against symbols defined in a regular object.
1100 We allocated space for them in the check_relocs routine, but we
1101 will not fill them in in the relocate_section routine. */
f69da49f 1102 if (info->shared)
252b5132
RH		 1103 elf_i386_link_hash_traverse (elf_i386_hash_table (info),
1104 elf_i386_discard_copies,
f69da49f 1105 (PTR) info);
252b5132
RH		 1106
1107 /* The check_relocs and adjust_dynamic_symbol entry points have
1108 determined the sizes of the various dynamic sections. Allocate
1109 memory for them. */
1110 plt = false;
1111 relocs = false;
1112 reltext = false;
1113 for (s = dynobj->sections; s != NULL; s = s->next)
1114 {
1115 const char *name;
1116 boolean strip;
1117
1118 if ((s->flags & SEC_LINKER_CREATED) == 0)
1119 continue;
1120
1121 /* It's OK to base decisions on the section name, because none
1122 of the dynobj section names depend upon the input files. */
1123 name = bfd_get_section_name (dynobj, s);
1124
1125 strip = false;
1126
1127 if (strcmp (name, ".plt") == 0)
1128 {
1129 if (s->_raw_size == 0)
1130 {
1131 /* Strip this section if we don't need it; see the
1132 comment below. */
1133 strip = true;
1134 }
1135 else
1136 {
1137 /* Remember whether there is a PLT. */
1138 plt = true;
1139 }
1140 }
1141 else if (strncmp (name, ".rel", 4) == 0)
1142 {
1143 if (s->_raw_size == 0)
1144 {
1145 /* If we don't need this section, strip it from the
1146 output file. This is mostly to handle .rel.bss and
1147 .rel.plt. We must create both sections in
1148 create_dynamic_sections, because they must be created
1149 before the linker maps input sections to output
1150 sections. The linker does that before
1151 adjust_dynamic_symbol is called, and it is that
1152 function which decides whether anything needs to go
1153 into these sections. */
1154 strip = true;
1155 }
1156 else
1157 {
1158 asection *target;
1159
1160 /* Remember whether there are any reloc sections other
1161 than .rel.plt. */
1162 if (strcmp (name, ".rel.plt") != 0)
1163 {
1164 const char *outname;
1165
1166 relocs = true;
1167
1168 /* If this relocation section applies to a read only
1169 section, then we probably need a DT_TEXTREL
1170 entry. The entries in the .rel.plt section
1171 really apply to the .got section, which we
1172 created ourselves and so know is not readonly. */
1173 outname = bfd_get_section_name (output_bfd,
1174 s->output_section);
1175 target = bfd_get_section_by_name (output_bfd, outname + 4);
1176 if (target != NULL
1177 && (target->flags & SEC_READONLY) != 0
1178 && (target->flags & SEC_ALLOC) != 0)
1179 reltext = true;
1180 }
1181
1182 /* We use the reloc_count field as a counter if we need
1183 to copy relocs into the output file. */
1184 s->reloc_count = 0;
1185 }
1186 }
1187 else if (strncmp (name, ".got", 4) != 0)
1188 {
1189 /* It's not one of our sections, so don't allocate space. */
1190 continue;
1191 }
1192
1193 if (strip)
1194 {
7f8d5fc9 1195 _bfd_strip_section_from_output (info, s);
252b5132
RH		 1196 continue;
1197 }
1198
f69da49f
AM		 1199 /* Allocate memory for the section contents. We use bfd_zalloc
1200 here in case unused entries are not reclaimed before the
1201 section's contents are written out. This should not happen,
1202 but this way if it does, we get a R_386_NONE reloc instead
1203 of garbage. */
7a9af8c4 1204 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
252b5132
RH		 1205 if (s->contents == NULL && s->_raw_size != 0)
1206 return false;
1207 }
1208
1209 if (elf_hash_table (info)->dynamic_sections_created)
1210 {
1211 /* Add some entries to the .dynamic section. We fill in the
1212 values later, in elf_i386_finish_dynamic_sections, but we
1213 must add the entries now so that we get the correct size for
1214 the .dynamic section. The DT_DEBUG entry is filled in by the
1215 dynamic linker and used by the debugger. */
1216 if (! info->shared)
1217 {
1218 if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
1219 return false;
1220 }
1221
1222 if (plt)
1223 {
1224 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
1225 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
1226 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL)
1227 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
1228 return false;
1229 }
1230
1231 if (relocs)
1232 {
1233 if (! bfd_elf32_add_dynamic_entry (info, DT_REL, 0)
1234 || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0)
1235 || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
1236 sizeof (Elf32_External_Rel)))
1237 return false;
1238 }
1239
1240 if (reltext)
1241 {
1242 if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
1243 return false;
d6cf2879 1244 info->flags |= DF_TEXTREL;
252b5132
RH		 1245 }
1246 }
1247
1248 return true;
1249}
1250
1251/* This function is called via elf_i386_link_hash_traverse if we are
f69da49f
AM		 1252 creating a shared object. In the -Bsymbolic case, it discards the
1253 space allocated to copy PC relative relocs against symbols which
1254 are defined in regular objects. For the normal non-symbolic case,
1255 we also discard space for relocs that have become local due to
6609fa74 1256 symbol visibility changes. We allocated space for them in the
252b5132
RH		 1257 check_relocs routine, but we won't fill them in in the
1258 relocate_section routine. */
1259
252b5132 1260static boolean
f69da49f 1261elf_i386_discard_copies (h, inf)
252b5132 1262 struct elf_i386_link_hash_entry *h;
f69da49f 1263 PTR inf;
252b5132
RH		 1264{
1265 struct elf_i386_pcrel_relocs_copied *s;
f69da49f
AM		 1266 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1267
1268 /* If a symbol has been forced local or we have found a regular
1269 definition for the symbolic link case, then we won't be needing
1270 any relocs. */
1271 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1272 && ((h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1273 || info->symbolic))
1274 {
1275 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
1276 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
1277 }
252b5132
RH		 1278
1279 return true;
1280}
1281
1282/* Relocate an i386 ELF section. */
1283
1284static boolean
1285elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
1286 contents, relocs, local_syms, local_sections)
1287 bfd *output_bfd;
1288 struct bfd_link_info *info;
1289 bfd *input_bfd;
1290 asection *input_section;
1291 bfd_byte *contents;
1292 Elf_Internal_Rela *relocs;
1293 Elf_Internal_Sym *local_syms;
1294 asection **local_sections;
1295{
1296 bfd *dynobj;
1297 Elf_Internal_Shdr *symtab_hdr;
1298 struct elf_link_hash_entry **sym_hashes;
1299 bfd_vma *local_got_offsets;
1300 asection *sgot;
1301 asection *splt;
1302 asection *sreloc;
1303 Elf_Internal_Rela *rel;
1304 Elf_Internal_Rela *relend;
1305
1306 dynobj = elf_hash_table (info)->dynobj;
1307 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1308 sym_hashes = elf_sym_hashes (input_bfd);
1309 local_got_offsets = elf_local_got_offsets (input_bfd);
1310
252b5132 1311 sreloc = NULL;
dd5724d5
AM		 1312 splt = NULL;
1313 sgot = NULL;
1314 if (dynobj != NULL)
1315 {
1316 splt = bfd_get_section_by_name (dynobj, ".plt");
1317 sgot = bfd_get_section_by_name (dynobj, ".got");
1318 }
252b5132
RH		 1319
1320 rel = relocs;
1321 relend = relocs + input_section->reloc_count;
1322 for (; rel < relend; rel++)
1323 {
1324 int r_type;
1325 reloc_howto_type *howto;
1326 unsigned long r_symndx;
1327 struct elf_link_hash_entry *h;
1328 Elf_Internal_Sym *sym;
1329 asection *sec;
1330 bfd_vma relocation;
1331 bfd_reloc_status_type r;
1b452ec6 1332 unsigned int indx;
252b5132
RH		 1333
1334 r_type = ELF32_R_TYPE (rel->r_info);
dc47f327
AM		 1335 if (r_type == (int) R_386_GNU_VTINHERIT
1336 || r_type == (int) R_386_GNU_VTENTRY)
252b5132 1337 continue;
dc47f327 1338
1b452ec6 1339 if ((indx = (unsigned) r_type) >= R_386_standard
dc47f327
AM		 1340 && ((indx = (unsigned) r_type - R_386_ext_offset) - R_386_standard
1341 >= R_386_ext - R_386_standard))
252b5132
RH		 1342 {
1343 bfd_set_error (bfd_error_bad_value);
1344 return false;
1345 }
1b452ec6 1346 howto = elf_howto_table + indx;
252b5132
RH		 1347
1348 r_symndx = ELF32_R_SYM (rel->r_info);
1349
1350 if (info->relocateable)
1351 {
1352 /* This is a relocateable link. We don't have to change
1353 anything, unless the reloc is against a section symbol,
1354 in which case we have to adjust according to where the
1355 section symbol winds up in the output section. */
1356 if (r_symndx < symtab_hdr->sh_info)
1357 {
1358 sym = local_syms + r_symndx;
1359 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1360 {
1361 bfd_vma val;
1362
1363 sec = local_sections[r_symndx];
1364 val = bfd_get_32 (input_bfd, contents + rel->r_offset);
1365 val += sec->output_offset + sym->st_value;
1366 bfd_put_32 (input_bfd, val, contents + rel->r_offset);
1367 }
1368 }
1369
1370 continue;
1371 }
1372
1373 /* This is a final link. */
1374 h = NULL;
1375 sym = NULL;
1376 sec = NULL;
1377 if (r_symndx < symtab_hdr->sh_info)
1378 {
1379 sym = local_syms + r_symndx;
1380 sec = local_sections[r_symndx];
1381 relocation = (sec->output_section->vma
1382 + sec->output_offset
1383 + sym->st_value);
1384 }
1385 else
1386 {
1387 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1388 while (h->root.type == bfd_link_hash_indirect
1389 || h->root.type == bfd_link_hash_warning)
1390 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1391 if (h->root.type == bfd_link_hash_defined
1392 || h->root.type == bfd_link_hash_defweak)
1393 {
1394 sec = h->root.u.def.section;
1395 if (r_type == R_386_GOTPC
1396 || (r_type == R_386_PLT32
dd5724d5 1397 && splt != NULL
252b5132
RH		 1398 && h->plt.offset != (bfd_vma) -1)
1399 || (r_type == R_386_GOT32
1400 && elf_hash_table (info)->dynamic_sections_created
1401 && (! info->shared
1402 || (! info->symbolic && h->dynindx != -1)
1403 || (h->elf_link_hash_flags
1404 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1405 || (info->shared
1406 && ((! info->symbolic && h->dynindx != -1)
1407 || (h->elf_link_hash_flags
1408 & ELF_LINK_HASH_DEF_REGULAR) == 0)
1409 && (r_type == R_386_32
1410 || r_type == R_386_PC32)
1411 && ((input_section->flags & SEC_ALLOC) != 0
1412 /* DWARF will emit R_386_32 relocations in its
1413 sections against symbols defined externally
1414 in shared libraries. We can't do anything
1415 with them here. */
1319985e
AM		 1416 || ((input_section->flags & SEC_DEBUGGING) != 0
1417 && (h->elf_link_hash_flags
1418 & ELF_LINK_HASH_DEF_DYNAMIC) != 0))))
252b5132
RH		 1419 {
1420 /* In these cases, we don't need the relocation
1421 value. We check specially because in some
1422 obscure cases sec->output_section will be NULL. */
1423 relocation = 0;
1424 }
1425 else if (sec->output_section == NULL)
1426 {
1427 (*_bfd_error_handler)
1428 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1429 bfd_get_filename (input_bfd), h->root.root.string,
1430 bfd_get_section_name (input_bfd, input_section));
1431 relocation = 0;
1432 }
1433 else
1434 relocation = (h->root.u.def.value
1435 + sec->output_section->vma
1436 + sec->output_offset);
1437 }
1438 else if (h->root.type == bfd_link_hash_undefweak)
1439 relocation = 0;
3a27a730
L		 1440 else if (info->shared && !info->symbolic
1441 && !info->no_undefined
1442 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
252b5132
RH		 1443 relocation = 0;
1444 else
1445 {
1446 if (! ((*info->callbacks->undefined_symbol)
1447 (info, h->root.root.string, input_bfd,
5cc7c785 1448 input_section, rel->r_offset,
3a27a730
L		 1449 (!info->shared || info->no_undefined
1450 || ELF_ST_VISIBILITY (h->other)))))
252b5132
RH		 1451 return false;
1452 relocation = 0;
1453 }
1454 }
1455
1456 switch (r_type)
1457 {
1458 case R_386_GOT32:
1459 /* Relocation is to the entry for this symbol in the global
1460 offset table. */
dd5724d5 1461 BFD_ASSERT (sgot != NULL);
252b5132
RH		 1462
1463 if (h != NULL)
1464 {
1465 bfd_vma off;
1466
1467 off = h->got.offset;
1468 BFD_ASSERT (off != (bfd_vma) -1);
1469
1470 if (! elf_hash_table (info)->dynamic_sections_created
1471 || (info->shared
1472 && (info->symbolic || h->dynindx == -1)
1473 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1474 {
1475 /* This is actually a static link, or it is a
1476 -Bsymbolic link and the symbol is defined
1477 locally, or the symbol was forced to be local
1478 because of a version file. We must initialize
1479 this entry in the global offset table. Since the
1480 offset must always be a multiple of 4, we use the
1481 least significant bit to record whether we have
1482 initialized it already.
1483
1484 When doing a dynamic link, we create a .rel.got
1485 relocation entry to initialize the value. This
1486 is done in the finish_dynamic_symbol routine. */
1487 if ((off & 1) != 0)
1488 off &= ~1;
1489 else
1490 {
1491 bfd_put_32 (output_bfd, relocation,
1492 sgot->contents + off);
1493 h->got.offset |= 1;
1494 }
1495 }
1496
1497 relocation = sgot->output_offset + off;
1498 }
1499 else
1500 {
1501 bfd_vma off;
1502
1503 BFD_ASSERT (local_got_offsets != NULL
1504 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1505
1506 off = local_got_offsets[r_symndx];
1507
1508 /* The offset must always be a multiple of 4. We use
1509 the least significant bit to record whether we have
1510 already generated the necessary reloc. */
1511 if ((off & 1) != 0)
1512 off &= ~1;
1513 else
1514 {
1515 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1516
1517 if (info->shared)
1518 {
1519 asection *srelgot;
1520 Elf_Internal_Rel outrel;
1521
1522 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
1523 BFD_ASSERT (srelgot != NULL);
1524
1525 outrel.r_offset = (sgot->output_section->vma
1526 + sgot->output_offset
1527 + off);
1528 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1529 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1530 (((Elf32_External_Rel *)
1531 srelgot->contents)
1532 + srelgot->reloc_count));
1533 ++srelgot->reloc_count;
1534 }
1535
1536 local_got_offsets[r_symndx] |= 1;
1537 }
1538
1539 relocation = sgot->output_offset + off;
1540 }
1541
1542 break;
1543
1544 case R_386_GOTOFF:
1545 /* Relocation is relative to the start of the global offset
1546 table. */
1547
1548 if (sgot == NULL)
1549 {
1550 sgot = bfd_get_section_by_name (dynobj, ".got");
1551 BFD_ASSERT (sgot != NULL);
1552 }
1553
1554 /* Note that sgot->output_offset is not involved in this
1555 calculation. We always want the start of .got. If we
1556 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1557 permitted by the ABI, we might have to change this
1558 calculation. */
1559 relocation -= sgot->output_section->vma;
1560
1561 break;
1562
1563 case R_386_GOTPC:
1564 /* Use global offset table as symbol value. */
1565
1566 if (sgot == NULL)
1567 {
1568 sgot = bfd_get_section_by_name (dynobj, ".got");
1569 BFD_ASSERT (sgot != NULL);
1570 }
1571
1572 relocation = sgot->output_section->vma;
1573
1574 break;
1575
1576 case R_386_PLT32:
1577 /* Relocation is to the entry for this symbol in the
1578 procedure linkage table. */
1579
dd5724d5 1580 /* Resolve a PLT32 reloc against a local symbol directly,
252b5132
RH		 1581 without using the procedure linkage table. */
1582 if (h == NULL)
1583 break;
1584
dd5724d5
AM		 1585 if (h->plt.offset == (bfd_vma) -1
1586 || splt == NULL)
252b5132
RH		 1587 {
1588 /* We didn't make a PLT entry for this symbol. This
1589 happens when statically linking PIC code, or when
1590 using -Bsymbolic. */
1591 break;
1592 }
1593
252b5132
RH		 1594 relocation = (splt->output_section->vma
1595 + splt->output_offset
1596 + h->plt.offset);
1597
1598 break;
1599
1600 case R_386_32:
1601 case R_386_PC32:
1602 if (info->shared
1603 && (input_section->flags & SEC_ALLOC) != 0
1604 && (r_type != R_386_PC32
1605 || (h != NULL
1606 && h->dynindx != -1
1607 && (! info->symbolic
1608 || (h->elf_link_hash_flags
1609 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1610 {
1611 Elf_Internal_Rel outrel;
1612 boolean skip, relocate;
1613
1614 /* When generating a shared object, these relocations
1615 are copied into the output file to be resolved at run
1616 time. */
1617
1618 if (sreloc == NULL)
1619 {
1620 const char *name;
1621
1622 name = (bfd_elf_string_from_elf_section
1623 (input_bfd,
1624 elf_elfheader (input_bfd)->e_shstrndx,
1625 elf_section_data (input_section)->rel_hdr.sh_name));
1626 if (name == NULL)
1627 return false;
1628
1629 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
1630 && strcmp (bfd_get_section_name (input_bfd,
1631 input_section),
1632 name + 4) == 0);
1633
1634 sreloc = bfd_get_section_by_name (dynobj, name);
1635 BFD_ASSERT (sreloc != NULL);
1636 }
1637
1638 skip = false;
1639
1640 if (elf_section_data (input_section)->stab_info == NULL)
1641 outrel.r_offset = rel->r_offset;
1642 else
1643 {
1644 bfd_vma off;
1645
1646 off = (_bfd_stab_section_offset
1647 (output_bfd, &elf_hash_table (info)->stab_info,
1648 input_section,
1649 &elf_section_data (input_section)->stab_info,
1650 rel->r_offset));
1651 if (off == (bfd_vma) -1)
1652 skip = true;
1653 outrel.r_offset = off;
1654 }
1655
1656 outrel.r_offset += (input_section->output_section->vma
1657 + input_section->output_offset);
1658
1659 if (skip)
1660 {
1661 memset (&outrel, 0, sizeof outrel);
1662 relocate = false;
1663 }
1664 else if (r_type == R_386_PC32)
1665 {
1666 BFD_ASSERT (h != NULL && h->dynindx != -1);
1667 relocate = false;
1668 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_PC32);
1669 }
1670 else
1671 {
1672 /* h->dynindx may be -1 if this symbol was marked to
1673 become local. */
1674 if (h == NULL
1675 || ((info->symbolic || h->dynindx == -1)
1676 && (h->elf_link_hash_flags
1677 & ELF_LINK_HASH_DEF_REGULAR) != 0))
1678 {
1679 relocate = true;
1680 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1681 }
1682 else
1683 {
1684 BFD_ASSERT (h->dynindx != -1);
1685 relocate = false;
1686 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_32);
1687 }
1688 }
1689
1690 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1691 (((Elf32_External_Rel *)
1692 sreloc->contents)
1693 + sreloc->reloc_count));
1694 ++sreloc->reloc_count;
1695
1696 /* If this reloc is against an external symbol, we do
1697 not want to fiddle with the addend. Otherwise, we
1698 need to include the symbol value so that it becomes
1699 an addend for the dynamic reloc. */
1700 if (! relocate)
1701 continue;
1702 }
1703
1704 break;
1705
1706 default:
1707 break;
1708 }
1709
1710 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1711 contents, rel->r_offset,
1712 relocation, (bfd_vma) 0);
1713
1714 if (r != bfd_reloc_ok)
1715 {
1716 switch (r)
1717 {
1718 default:
1719 case bfd_reloc_outofrange:
1720 abort ();
1721 case bfd_reloc_overflow:
1722 {
1723 const char *name;
1724
1725 if (h != NULL)
1726 name = h->root.root.string;
1727 else
1728 {
1729 name = bfd_elf_string_from_elf_section (input_bfd,
1730 symtab_hdr->sh_link,
1731 sym->st_name);
1732 if (name == NULL)
1733 return false;
1734 if (*name == '\0')
1735 name = bfd_section_name (input_bfd, sec);
1736 }
1737 if (! ((*info->callbacks->reloc_overflow)
1738 (info, name, howto->name, (bfd_vma) 0,
1739 input_bfd, input_section, rel->r_offset)))
1740 return false;
1741 }
1742 break;
1743 }
1744 }
1745 }
1746
1747 return true;
1748}
1749
1750/* Finish up dynamic symbol handling. We set the contents of various
1751 dynamic sections here. */
1752
1753static boolean
1754elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
1755 bfd *output_bfd;
1756 struct bfd_link_info *info;
1757 struct elf_link_hash_entry *h;
1758 Elf_Internal_Sym *sym;
1759{
1760 bfd *dynobj;
1761
1762 dynobj = elf_hash_table (info)->dynobj;
1763
1764 if (h->plt.offset != (bfd_vma) -1)
1765 {
1766 asection *splt;
1767 asection *sgot;
1768 asection *srel;
1769 bfd_vma plt_index;
1770 bfd_vma got_offset;
1771 Elf_Internal_Rel rel;
1772
1773 /* This symbol has an entry in the procedure linkage table. Set
1774 it up. */
1775
1776 BFD_ASSERT (h->dynindx != -1);
1777
1778 splt = bfd_get_section_by_name (dynobj, ".plt");
1779 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1780 srel = bfd_get_section_by_name (dynobj, ".rel.plt");
1781 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
1782
1783 /* Get the index in the procedure linkage table which
1784 corresponds to this symbol. This is the index of this symbol
1785 in all the symbols for which we are making plt entries. The
1786 first entry in the procedure linkage table is reserved. */
1787 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1788
1789 /* Get the offset into the .got table of the entry that
1790 corresponds to this function. Each .got entry is 4 bytes.
1791 The first three are reserved. */
1792 got_offset = (plt_index + 3) * 4;
1793
1794 /* Fill in the entry in the procedure linkage table. */
1795 if (! info->shared)
1796 {
1797 memcpy (splt->contents + h->plt.offset, elf_i386_plt_entry,
1798 PLT_ENTRY_SIZE);
1799 bfd_put_32 (output_bfd,
1800 (sgot->output_section->vma
1801 + sgot->output_offset
1802 + got_offset),
1803 splt->contents + h->plt.offset + 2);
1804 }
1805 else
1806 {
1807 memcpy (splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
1808 PLT_ENTRY_SIZE);
1809 bfd_put_32 (output_bfd, got_offset,
1810 splt->contents + h->plt.offset + 2);
1811 }
1812
1813 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
1814 splt->contents + h->plt.offset + 7);
1815 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
1816 splt->contents + h->plt.offset + 12);
1817
1818 /* Fill in the entry in the global offset table. */
1819 bfd_put_32 (output_bfd,
1820 (splt->output_section->vma
1821 + splt->output_offset
1822 + h->plt.offset
1823 + 6),
1824 sgot->contents + got_offset);
1825
1826 /* Fill in the entry in the .rel.plt section. */
1827 rel.r_offset = (sgot->output_section->vma
1828 + sgot->output_offset
1829 + got_offset);
1830 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
1831 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1832 ((Elf32_External_Rel *) srel->contents
1833 + plt_index));
1834
1835 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1836 {
1837 /* Mark the symbol as undefined, rather than as defined in
1838 the .plt section. Leave the value alone. */
1839 sym->st_shndx = SHN_UNDEF;
1840 }
1841 }
1842
1843 if (h->got.offset != (bfd_vma) -1)
1844 {
1845 asection *sgot;
1846 asection *srel;
1847 Elf_Internal_Rel rel;
1848
1849 /* This symbol has an entry in the global offset table. Set it
1850 up. */
1851
1852 sgot = bfd_get_section_by_name (dynobj, ".got");
1853 srel = bfd_get_section_by_name (dynobj, ".rel.got");
1854 BFD_ASSERT (sgot != NULL && srel != NULL);
1855
1856 rel.r_offset = (sgot->output_section->vma
1857 + sgot->output_offset
1858 + (h->got.offset &~ 1));
1859
dd5724d5
AM		 1860 /* If this is a static link, or it is a -Bsymbolic link and the
1861 symbol is defined locally or was forced to be local because
1862 of a version file, we just want to emit a RELATIVE reloc.
252b5132
RH		 1863 The entry in the global offset table will already have been
1864 initialized in the relocate_section function. */
dd5724d5
AM		 1865 if (! elf_hash_table (info)->dynamic_sections_created
1866 || (info->shared
1867 && (info->symbolic || h->dynindx == -1)
1868 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1869 {
1870 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1871 }
252b5132
RH		 1872 else
1873 {
dd5724d5 1874 BFD_ASSERT((h->got.offset & 1) == 0);
252b5132
RH		 1875 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1876 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
1877 }
1878
1879 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1880 ((Elf32_External_Rel *) srel->contents
1881 + srel->reloc_count));
1882 ++srel->reloc_count;
1883 }
1884
791987af 1885 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
252b5132
RH		 1886 {
1887 asection *s;
1888 Elf_Internal_Rel rel;
1889
1890 /* This symbol needs a copy reloc. Set it up. */
1891
1892 BFD_ASSERT (h->dynindx != -1
1893 && (h->root.type == bfd_link_hash_defined
1894 || h->root.type == bfd_link_hash_defweak));
1895
1896 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1897 ".rel.bss");
1898 BFD_ASSERT (s != NULL);
1899
1900 rel.r_offset = (h->root.u.def.value
1901 + h->root.u.def.section->output_section->vma
1902 + h->root.u.def.section->output_offset);
1903 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
1904 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1905 ((Elf32_External_Rel *) s->contents
1906 + s->reloc_count));
1907 ++s->reloc_count;
1908 }
1909
1910 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1911 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1912 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1913 sym->st_shndx = SHN_ABS;
1914
1915 return true;
1916}
1917
1918/* Finish up the dynamic sections. */
1919
1920static boolean
1921elf_i386_finish_dynamic_sections (output_bfd, info)
1922 bfd *output_bfd;
1923 struct bfd_link_info *info;
1924{
1925 bfd *dynobj;
1926 asection *sgot;
1927 asection *sdyn;
1928
1929 dynobj = elf_hash_table (info)->dynobj;
1930
1931 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1932 BFD_ASSERT (sgot != NULL);
1933 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1934
1935 if (elf_hash_table (info)->dynamic_sections_created)
1936 {
1937 asection *splt;
1938 Elf32_External_Dyn *dyncon, *dynconend;
1939
1940 BFD_ASSERT (sdyn != NULL);
1941
1942 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1943 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1944 for (; dyncon < dynconend; dyncon++)
1945 {
1946 Elf_Internal_Dyn dyn;
1947 const char *name;
1948 asection *s;
1949
1950 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1951
1952 switch (dyn.d_tag)
1953 {
1954 default:
1955 break;
1956
1957 case DT_PLTGOT:
1958 name = ".got";
1959 goto get_vma;
1960 case DT_JMPREL:
1961 name = ".rel.plt";
1962 get_vma:
1963 s = bfd_get_section_by_name (output_bfd, name);
1964 BFD_ASSERT (s != NULL);
1965 dyn.d_un.d_ptr = s->vma;
1966 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1967 break;
1968
1969 case DT_PLTRELSZ:
1970 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
1971 BFD_ASSERT (s != NULL);
1972 if (s->_cooked_size != 0)
1973 dyn.d_un.d_val = s->_cooked_size;
1974 else
1975 dyn.d_un.d_val = s->_raw_size;
1976 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1977 break;
1978
1979 case DT_RELSZ:
1980 /* My reading of the SVR4 ABI indicates that the
1981 procedure linkage table relocs (DT_JMPREL) should be
1982 included in the overall relocs (DT_REL). This is
1983 what Solaris does. However, UnixWare can not handle
1984 that case. Therefore, we override the DT_RELSZ entry
1985 here to make it not include the JMPREL relocs. Since
1986 the linker script arranges for .rel.plt to follow all
1987 other relocation sections, we don't have to worry
1988 about changing the DT_REL entry. */
1989 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
1990 if (s != NULL)
1991 {
1992 if (s->_cooked_size != 0)
1993 dyn.d_un.d_val -= s->_cooked_size;
1994 else
1995 dyn.d_un.d_val -= s->_raw_size;
1996 }
1997 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1998 break;
1999 }
2000 }
2001
2002 /* Fill in the first entry in the procedure linkage table. */
2003 splt = bfd_get_section_by_name (dynobj, ".plt");
2004 if (splt && splt->_raw_size > 0)
2005 {
2006 if (info->shared)
2007 memcpy (splt->contents, elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
2008 else
2009 {
2010 memcpy (splt->contents, elf_i386_plt0_entry, PLT_ENTRY_SIZE);
2011 bfd_put_32 (output_bfd,
2012 sgot->output_section->vma + sgot->output_offset + 4,
2013 splt->contents + 2);
2014 bfd_put_32 (output_bfd,
2015 sgot->output_section->vma + sgot->output_offset + 8,
2016 splt->contents + 8);
2017 }
2018
2019 /* UnixWare sets the entsize of .plt to 4, although that doesn't
2020 really seem like the right value. */
2021 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
2022 }
2023 }
2024
2025 /* Fill in the first three entries in the global offset table. */
2026 if (sgot->_raw_size > 0)
2027 {
2028 if (sdyn == NULL)
2029 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2030 else
2031 bfd_put_32 (output_bfd,
2032 sdyn->output_section->vma + sdyn->output_offset,
2033 sgot->contents);
2034 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
2035 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
2036 }
2037
2038 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2039
2040 return true;
2041}
2042
2043#define TARGET_LITTLE_SYM bfd_elf32_i386_vec
2044#define TARGET_LITTLE_NAME "elf32-i386"
2045#define ELF_ARCH bfd_arch_i386
2046#define ELF_MACHINE_CODE EM_386
2047#define ELF_MAXPAGESIZE 0x1000
252b5132
RH		 2048
2049#define elf_backend_can_gc_sections 1
2050#define elf_backend_want_got_plt 1
2051#define elf_backend_plt_readonly 1
2052#define elf_backend_want_plt_sym 0
2053#define elf_backend_got_header_size 12
2054#define elf_backend_plt_header_size PLT_ENTRY_SIZE
2055
dd5724d5
AM		 2056#define elf_info_to_howto elf_i386_info_to_howto
2057#define elf_info_to_howto_rel elf_i386_info_to_howto_rel
2058
2059#define bfd_elf32_bfd_final_link _bfd_elf32_gc_common_final_link
2060#define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
2061#define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
2062#define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
2063
2064#define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
2065#define elf_backend_check_relocs elf_i386_check_relocs
2066#define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
2067#define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
2068#define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
2069#define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
2070#define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
2071#define elf_backend_relocate_section elf_i386_relocate_section
2072#define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
2073
252b5132 2074#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.155219 seconds and 4 git commands to generate.