1 /* Intel 80386/80486-specific support for 32-bit ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
27 static reloc_howto_type *elf_i386_reloc_type_lookup
28 PARAMS ((bfd *, bfd_reloc_code_real_type));
29 static void elf_i386_info_to_howto
30 PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
31 static void elf_i386_info_to_howto_rel
32 PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
33 static boolean elf_i386_is_local_label_name PARAMS ((bfd *, const char *));
34 static struct bfd_hash_entry *elf_i386_link_hash_newfunc
35 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
36 static struct bfd_link_hash_table *elf_i386_link_hash_table_create
38 static boolean create_got_section PARAMS((bfd *, struct bfd_link_info *));
39 static boolean elf_i386_create_dynamic_sections
40 PARAMS((bfd *, struct bfd_link_info *));
41 static boolean elf_i386_check_relocs
42 PARAMS ((bfd *, struct bfd_link_info *, asection *,
43 const Elf_Internal_Rela *));
44 static asection *elf_i386_gc_mark_hook
45 PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *,
46 struct elf_link_hash_entry *, Elf_Internal_Sym *));
47 static boolean elf_i386_gc_sweep_hook
48 PARAMS ((bfd *, struct bfd_link_info *, asection *,
49 const Elf_Internal_Rela *));
50 static boolean elf_i386_adjust_dynamic_symbol
51 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
52 static boolean allocate_plt_and_got_and_discard_relocs
53 PARAMS ((struct elf_link_hash_entry *, PTR));
54 static boolean elf_i386_size_dynamic_sections
55 PARAMS ((bfd *, struct bfd_link_info *));
56 static boolean elf_i386_relocate_section
57 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
58 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
59 static boolean elf_i386_finish_dynamic_symbol
60 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
62 static boolean elf_i386_finish_dynamic_sections
63 PARAMS ((bfd *, struct bfd_link_info *));
64 static boolean elf_i386_fake_sections
65 PARAMS ((bfd *, Elf32_Internal_Shdr *, asection *));
66 static enum elf_reloc_type_class elf_i386_reloc_type_class PARAMS ((int));
67 static boolean elf_i386_grok_prstatus
68 PARAMS ((bfd *abfd, Elf_Internal_Note *note));
69 static boolean elf_i386_grok_psinfo
70 PARAMS ((bfd *abfd, Elf_Internal_Note *note));
72 #define USE_REL 1 /* 386 uses REL relocations instead of RELA */
76 static reloc_howto_type elf_howto_table[]=
78 HOWTO(R_386_NONE, 0, 0, 0, false, 0, complain_overflow_bitfield,
79 bfd_elf_generic_reloc, "R_386_NONE",
80 true, 0x00000000, 0x00000000, false),
81 HOWTO(R_386_32, 0, 2, 32, false, 0, complain_overflow_bitfield,
82 bfd_elf_generic_reloc, "R_386_32",
83 true, 0xffffffff, 0xffffffff, false),
84 HOWTO(R_386_PC32, 0, 2, 32, true, 0, complain_overflow_bitfield,
85 bfd_elf_generic_reloc, "R_386_PC32",
86 true, 0xffffffff, 0xffffffff, true),
87 HOWTO(R_386_GOT32, 0, 2, 32, false, 0, complain_overflow_bitfield,
88 bfd_elf_generic_reloc, "R_386_GOT32",
89 true, 0xffffffff, 0xffffffff, false),
90 HOWTO(R_386_PLT32, 0, 2, 32, true, 0, complain_overflow_bitfield,
91 bfd_elf_generic_reloc, "R_386_PLT32",
92 true, 0xffffffff, 0xffffffff, true),
93 HOWTO(R_386_COPY, 0, 2, 32, false, 0, complain_overflow_bitfield,
94 bfd_elf_generic_reloc, "R_386_COPY",
95 true, 0xffffffff, 0xffffffff, false),
96 HOWTO(R_386_GLOB_DAT, 0, 2, 32, false, 0, complain_overflow_bitfield,
97 bfd_elf_generic_reloc, "R_386_GLOB_DAT",
98 true, 0xffffffff, 0xffffffff, false),
99 HOWTO(R_386_JUMP_SLOT, 0, 2, 32, false, 0, complain_overflow_bitfield,
100 bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
101 true, 0xffffffff, 0xffffffff, false),
102 HOWTO(R_386_RELATIVE, 0, 2, 32, false, 0, complain_overflow_bitfield,
103 bfd_elf_generic_reloc, "R_386_RELATIVE",
104 true, 0xffffffff, 0xffffffff, false),
105 HOWTO(R_386_GOTOFF, 0, 2, 32, false, 0, complain_overflow_bitfield,
106 bfd_elf_generic_reloc, "R_386_GOTOFF",
107 true, 0xffffffff, 0xffffffff, false),
108 HOWTO(R_386_GOTPC, 0, 2, 32, true, 0, complain_overflow_bitfield,
109 bfd_elf_generic_reloc, "R_386_GOTPC",
110 true, 0xffffffff, 0xffffffff, true),
112 /* We have a gap in the reloc numbers here.
113 R_386_standard counts the number up to this point, and
114 R_386_ext_offset is the value to subtract from a reloc type of
115 R_386_16 thru R_386_PC8 to form an index into this table. */
116 #define R_386_standard ((unsigned int) R_386_GOTPC + 1)
117 #define R_386_ext_offset ((unsigned int) R_386_16 - R_386_standard)
119 /* The remaining relocs are a GNU extension. */
120 HOWTO(R_386_16, 0, 1, 16, false, 0, complain_overflow_bitfield,
121 bfd_elf_generic_reloc, "R_386_16",
122 true, 0xffff, 0xffff, false),
123 HOWTO(R_386_PC16, 0, 1, 16, true, 0, complain_overflow_bitfield,
124 bfd_elf_generic_reloc, "R_386_PC16",
125 true, 0xffff, 0xffff, true),
126 HOWTO(R_386_8, 0, 0, 8, false, 0, complain_overflow_bitfield,
127 bfd_elf_generic_reloc, "R_386_8",
128 true, 0xff, 0xff, false),
129 HOWTO(R_386_PC8, 0, 0, 8, true, 0, complain_overflow_signed,
130 bfd_elf_generic_reloc, "R_386_PC8",
131 true, 0xff, 0xff, true),
134 #define R_386_ext ((unsigned int) R_386_PC8 + 1 - R_386_ext_offset)
135 #define R_386_vt_offset ((unsigned int) R_386_GNU_VTINHERIT - R_386_ext)
137 /* GNU extension to record C++ vtable hierarchy. */
138 HOWTO (R_386_GNU_VTINHERIT, /* type */
140 2, /* size (0 = byte, 1 = short, 2 = long) */
142 false, /* pc_relative */
144 complain_overflow_dont, /* complain_on_overflow */
145 NULL, /* special_function */
146 "R_386_GNU_VTINHERIT", /* name */
147 false, /* partial_inplace */
152 /* GNU extension to record C++ vtable member usage. */
153 HOWTO (R_386_GNU_VTENTRY, /* type */
155 2, /* size (0 = byte, 1 = short, 2 = long) */
157 false, /* pc_relative */
159 complain_overflow_dont, /* complain_on_overflow */
160 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
161 "R_386_GNU_VTENTRY", /* name */
162 false, /* partial_inplace */
167 #define R_386_vt ((unsigned int) R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
171 #ifdef DEBUG_GEN_RELOC
172 #define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
177 static reloc_howto_type *
178 elf_i386_reloc_type_lookup (abfd, code)
179 bfd *abfd ATTRIBUTE_UNUSED;
180 bfd_reloc_code_real_type code;
185 TRACE ("BFD_RELOC_NONE");
186 return &elf_howto_table[(unsigned int) R_386_NONE ];
189 TRACE ("BFD_RELOC_32");
190 return &elf_howto_table[(unsigned int) R_386_32 ];
193 TRACE ("BFD_RELOC_CTOR");
194 return &elf_howto_table[(unsigned int) R_386_32 ];
196 case BFD_RELOC_32_PCREL:
197 TRACE ("BFD_RELOC_PC32");
198 return &elf_howto_table[(unsigned int) R_386_PC32 ];
200 case BFD_RELOC_386_GOT32:
201 TRACE ("BFD_RELOC_386_GOT32");
202 return &elf_howto_table[(unsigned int) R_386_GOT32 ];
204 case BFD_RELOC_386_PLT32:
205 TRACE ("BFD_RELOC_386_PLT32");
206 return &elf_howto_table[(unsigned int) R_386_PLT32 ];
208 case BFD_RELOC_386_COPY:
209 TRACE ("BFD_RELOC_386_COPY");
210 return &elf_howto_table[(unsigned int) R_386_COPY ];
212 case BFD_RELOC_386_GLOB_DAT:
213 TRACE ("BFD_RELOC_386_GLOB_DAT");
214 return &elf_howto_table[(unsigned int) R_386_GLOB_DAT ];
216 case BFD_RELOC_386_JUMP_SLOT:
217 TRACE ("BFD_RELOC_386_JUMP_SLOT");
218 return &elf_howto_table[(unsigned int) R_386_JUMP_SLOT ];
220 case BFD_RELOC_386_RELATIVE:
221 TRACE ("BFD_RELOC_386_RELATIVE");
222 return &elf_howto_table[(unsigned int) R_386_RELATIVE ];
224 case BFD_RELOC_386_GOTOFF:
225 TRACE ("BFD_RELOC_386_GOTOFF");
226 return &elf_howto_table[(unsigned int) R_386_GOTOFF ];
228 case BFD_RELOC_386_GOTPC:
229 TRACE ("BFD_RELOC_386_GOTPC");
230 return &elf_howto_table[(unsigned int) R_386_GOTPC ];
232 /* The remaining relocs are a GNU extension. */
234 TRACE ("BFD_RELOC_16");
235 return &elf_howto_table[(unsigned int) R_386_16 - R_386_ext_offset];
237 case BFD_RELOC_16_PCREL:
238 TRACE ("BFD_RELOC_16_PCREL");
239 return &elf_howto_table[(unsigned int) R_386_PC16 - R_386_ext_offset];
242 TRACE ("BFD_RELOC_8");
243 return &elf_howto_table[(unsigned int) R_386_8 - R_386_ext_offset];
245 case BFD_RELOC_8_PCREL:
246 TRACE ("BFD_RELOC_8_PCREL");
247 return &elf_howto_table[(unsigned int) R_386_PC8 - R_386_ext_offset];
249 case BFD_RELOC_VTABLE_INHERIT:
250 TRACE ("BFD_RELOC_VTABLE_INHERIT");
251 return &elf_howto_table[(unsigned int) R_386_GNU_VTINHERIT
254 case BFD_RELOC_VTABLE_ENTRY:
255 TRACE ("BFD_RELOC_VTABLE_ENTRY");
256 return &elf_howto_table[(unsigned int) R_386_GNU_VTENTRY
268 elf_i386_info_to_howto (abfd, cache_ptr, dst)
269 bfd *abfd ATTRIBUTE_UNUSED;
270 arelent *cache_ptr ATTRIBUTE_UNUSED;
271 Elf32_Internal_Rela *dst ATTRIBUTE_UNUSED;
277 elf_i386_info_to_howto_rel (abfd, cache_ptr, dst)
278 bfd *abfd ATTRIBUTE_UNUSED;
280 Elf32_Internal_Rel *dst;
282 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
285 if ((indx = r_type) >= R_386_standard
286 && ((indx = r_type - R_386_ext_offset) - R_386_standard
287 >= R_386_ext - R_386_standard)
288 && ((indx = r_type - R_386_vt_offset) - R_386_ext
289 >= R_386_vt - R_386_ext))
291 (*_bfd_error_handler) (_("%s: invalid relocation type %d"),
292 bfd_get_filename (abfd), (int) r_type);
293 indx = (unsigned int) R_386_NONE;
295 cache_ptr->howto = &elf_howto_table[indx];
298 /* Return whether a symbol name implies a local label. The UnixWare
299 2.1 cc generates temporary symbols that start with .X, so we
300 recognize them here. FIXME: do other SVR4 compilers also use .X?.
301 If so, we should move the .X recognition into
302 _bfd_elf_is_local_label_name. */
305 elf_i386_is_local_label_name (abfd, name)
309 if (name[0] == '.' && name[1] == 'X')
312 return _bfd_elf_is_local_label_name (abfd, name);
315 /* Functions for the i386 ELF linker. */
317 /* The name of the dynamic interpreter. This is put in the .interp
320 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
322 /* The size in bytes of an entry in the procedure linkage table. */
324 #define PLT_ENTRY_SIZE 16
326 /* The first entry in an absolute procedure linkage table looks like
327 this. See the SVR4 ABI i386 supplement to see how this works. */
329 static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] =
331 0xff, 0x35, /* pushl contents of address */
332 0, 0, 0, 0, /* replaced with address of .got + 4. */
333 0xff, 0x25, /* jmp indirect */
334 0, 0, 0, 0, /* replaced with address of .got + 8. */
335 0, 0, 0, 0 /* pad out to 16 bytes. */
338 /* Subsequent entries in an absolute procedure linkage table look like
341 static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
343 0xff, 0x25, /* jmp indirect */
344 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
345 0x68, /* pushl immediate */
346 0, 0, 0, 0, /* replaced with offset into relocation table. */
347 0xe9, /* jmp relative */
348 0, 0, 0, 0 /* replaced with offset to start of .plt. */
351 /* The first entry in a PIC procedure linkage table look like this. */
353 static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] =
355 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
356 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
357 0, 0, 0, 0 /* pad out to 16 bytes. */
360 /* Subsequent entries in a PIC procedure linkage table look like this. */
362 static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
364 0xff, 0xa3, /* jmp *offset(%ebx) */
365 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
366 0x68, /* pushl immediate */
367 0, 0, 0, 0, /* replaced with offset into relocation table. */
368 0xe9, /* jmp relative */
369 0, 0, 0, 0 /* replaced with offset to start of .plt. */
372 /* The i386 linker needs to keep track of the number of relocs that it
373 decides to copy as dynamic relocs in check_relocs for each symbol.
374 This is so that it can later discard them if they are found to be
375 unnecessary. We store the information in a field extending the
376 regular ELF linker hash table. */
378 struct elf_i386_dyn_relocs
381 struct elf_i386_dyn_relocs *next;
382 /* A section in dynobj. */
384 /* Number of relocs copied in this section. */
388 /* i386 ELF linker hash entry. */
390 struct elf_i386_link_hash_entry
392 struct elf_link_hash_entry root;
394 /* Number of PC relative relocs copied for this symbol. */
395 struct elf_i386_dyn_relocs *dyn_relocs;
398 /* i386 ELF linker hash table. */
400 struct elf_i386_link_hash_table
402 struct elf_link_hash_table root;
404 /* Short-cuts to get to dynamic linker sections. */
414 /* Get the i386 ELF linker hash table from a link_info structure. */
416 #define elf_i386_hash_table(p) \
417 ((struct elf_i386_link_hash_table *) ((p)->hash))
419 /* Create an entry in an i386 ELF linker hash table. */
421 static struct bfd_hash_entry *
422 elf_i386_link_hash_newfunc (entry, table, string)
423 struct bfd_hash_entry *entry;
424 struct bfd_hash_table *table;
427 struct elf_i386_link_hash_entry *ret =
428 (struct elf_i386_link_hash_entry *) entry;
430 /* Allocate the structure if it has not already been allocated by a
432 if (ret == (struct elf_i386_link_hash_entry *) NULL)
433 ret = ((struct elf_i386_link_hash_entry *)
434 bfd_hash_allocate (table,
435 sizeof (struct elf_i386_link_hash_entry)));
436 if (ret == (struct elf_i386_link_hash_entry *) NULL)
437 return (struct bfd_hash_entry *) ret;
439 /* Call the allocation method of the superclass. */
440 ret = ((struct elf_i386_link_hash_entry *)
441 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
443 if (ret != (struct elf_i386_link_hash_entry *) NULL)
445 ret->dyn_relocs = NULL;
448 return (struct bfd_hash_entry *) ret;
451 /* Create an i386 ELF linker hash table. */
453 static struct bfd_link_hash_table *
454 elf_i386_link_hash_table_create (abfd)
457 struct elf_i386_link_hash_table *ret;
458 bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
460 ret = (struct elf_i386_link_hash_table *) bfd_alloc (abfd, amt);
461 if (ret == (struct elf_i386_link_hash_table *) NULL)
464 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
465 elf_i386_link_hash_newfunc))
467 bfd_release (abfd, ret);
479 return &ret->root.root;
482 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
483 shortcuts to them in our hash table. */
486 create_got_section (dynobj, info)
488 struct bfd_link_info *info;
490 struct elf_i386_link_hash_table *htab;
492 if (! _bfd_elf_create_got_section (dynobj, info))
495 htab = elf_i386_hash_table (info);
496 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
497 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
498 if (!htab->sgot || !htab->sgotplt)
501 htab->srelgot = bfd_make_section (dynobj, ".rel.got");
502 if (htab->srelgot == NULL
503 || ! bfd_set_section_flags (dynobj, htab->srelgot,
504 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
505 | SEC_IN_MEMORY | SEC_LINKER_CREATED
507 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
512 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
513 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
517 elf_i386_create_dynamic_sections (dynobj, info)
519 struct bfd_link_info *info;
521 struct elf_i386_link_hash_table *htab;
523 htab = elf_i386_hash_table (info);
524 if (!htab->sgot && !create_got_section (dynobj, info))
527 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
530 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
531 htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
532 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
534 htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
536 if (!htab->splt || !htab->srelplt || !htab->sdynbss
537 || (!info->shared && !htab->srelbss))
543 /* Look through the relocs for a section during the first phase, and
544 allocate space in the global offset table or procedure linkage
548 elf_i386_check_relocs (abfd, info, sec, relocs)
550 struct bfd_link_info *info;
552 const Elf_Internal_Rela *relocs;
554 struct elf_i386_link_hash_table *htab;
556 Elf_Internal_Shdr *symtab_hdr;
557 struct elf_link_hash_entry **sym_hashes;
558 bfd_signed_vma *local_got_refcounts;
559 const Elf_Internal_Rela *rel;
560 const Elf_Internal_Rela *rel_end;
563 if (info->relocateable)
566 htab = elf_i386_hash_table (info);
567 dynobj = htab->root.dynobj;
568 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
569 sym_hashes = elf_sym_hashes (abfd);
570 local_got_refcounts = elf_local_got_refcounts (abfd);
574 rel_end = relocs + sec->reloc_count;
575 for (rel = relocs; rel < rel_end; rel++)
577 unsigned long r_symndx;
578 struct elf_link_hash_entry *h;
580 r_symndx = ELF32_R_SYM (rel->r_info);
582 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
584 if (abfd->my_archive)
585 (*_bfd_error_handler) (_("%s(%s): bad symbol index: %d"),
586 bfd_get_filename (abfd->my_archive),
587 bfd_get_filename (abfd),
590 (*_bfd_error_handler) (_("%s: bad symbol index: %d"),
591 bfd_get_filename (abfd),
596 if (r_symndx < symtab_hdr->sh_info)
599 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
601 /* Some relocs require a global offset table. */
602 if (htab->sgot == NULL)
604 switch (ELF32_R_TYPE (rel->r_info))
610 htab->root.dynobj = dynobj = abfd;
611 if (!create_got_section (dynobj, info))
620 switch (ELF32_R_TYPE (rel->r_info))
623 /* This symbol requires a global offset table entry. */
626 if (h->got.refcount == -1)
629 h->got.refcount += 1;
633 /* This is a global offset table entry for a local symbol. */
634 if (local_got_refcounts == NULL)
638 size = symtab_hdr->sh_info;
639 size *= sizeof (bfd_signed_vma);
640 local_got_refcounts = ((bfd_signed_vma *)
641 bfd_alloc (abfd, size));
642 if (local_got_refcounts == NULL)
644 elf_local_got_refcounts (abfd) = local_got_refcounts;
645 memset (local_got_refcounts, -1, (size_t) size);
647 if (local_got_refcounts[r_symndx] == -1)
648 local_got_refcounts[r_symndx] = 1;
650 local_got_refcounts[r_symndx] += 1;
655 /* This symbol requires a procedure linkage table entry. We
656 actually build the entry in adjust_dynamic_symbol,
657 because this might be a case of linking PIC code which is
658 never referenced by a dynamic object, in which case we
659 don't need to generate a procedure linkage table entry
662 /* If this is a local symbol, we resolve it directly without
663 creating a procedure linkage table entry. */
667 if (h->plt.refcount == -1)
669 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
673 h->plt.refcount += 1;
678 if (h != NULL && !info->shared)
680 /* If this reloc is in a read-only section, we might
681 need a copy reloc. */
682 if ((sec->flags & SEC_READONLY) != 0)
683 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
685 /* We may need a .plt entry if the function this reloc
686 refers to is in a shared lib. */
687 if (h->plt.refcount == -1)
690 h->plt.refcount += 1;
693 /* If we are creating a shared library, and this is a reloc
694 against a global symbol, or a non PC relative reloc
695 against a local symbol, then we need to copy the reloc
696 into the shared library. However, if we are linking with
697 -Bsymbolic, we do not need to copy a reloc against a
698 global symbol which is defined in an object we are
699 including in the link (i.e., DEF_REGULAR is set). At
700 this point we have not seen all the input files, so it is
701 possible that DEF_REGULAR is not set now but will be set
702 later (it is never cleared). In case of a weak definition,
703 DEF_REGULAR may be cleared later by a strong definition in
704 a shared library. We account for that possibility below by
705 storing information in the relocs_copied field of the hash
706 table entry. A similar situation occurs when creating
707 shared libraries and symbol visibility changes render the
710 If on the other hand, we are creating an executable, we
711 may need to keep relocations for symbols satisfied by a
712 dynamic library if we manage to avoid copy relocs for the
715 && (sec->flags & SEC_ALLOC) != 0
716 && (ELF32_R_TYPE (rel->r_info) != R_386_PC32
719 || h->root.type == bfd_link_hash_defweak
720 || (h->elf_link_hash_flags
721 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
723 && (sec->flags & SEC_ALLOC) != 0
725 && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
726 && (h->root.type == bfd_link_hash_defweak
727 || (h->elf_link_hash_flags
728 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
730 /* We must copy these reloc types into the output file.
731 Create a reloc section in dynobj and make room for
734 htab->root.dynobj = dynobj = abfd;
740 name = (bfd_elf_string_from_elf_section
742 elf_elfheader (abfd)->e_shstrndx,
743 elf_section_data (sec)->rel_hdr.sh_name));
747 if (strncmp (name, ".rel", 4) != 0
748 || strcmp (bfd_get_section_name (abfd, sec),
751 if (abfd->my_archive)
752 (*_bfd_error_handler) (_("%s(%s): bad relocation section name `%s\'"),
753 bfd_get_filename (abfd->my_archive),
754 bfd_get_filename (abfd),
757 (*_bfd_error_handler) (_("%s: bad relocation section name `%s\'"),
758 bfd_get_filename (abfd),
762 sreloc = bfd_get_section_by_name (dynobj, name);
767 sreloc = bfd_make_section (dynobj, name);
768 flags = (SEC_HAS_CONTENTS | SEC_READONLY
769 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
770 if ((sec->flags & SEC_ALLOC) != 0)
771 flags |= SEC_ALLOC | SEC_LOAD;
773 || ! bfd_set_section_flags (dynobj, sreloc, flags)
774 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
777 if (sec->flags & SEC_READONLY)
778 info->flags |= DF_TEXTREL;
781 sreloc->_raw_size += sizeof (Elf32_External_Rel);
783 /* If this is a global symbol, we count the number of PC
784 relative relocations we have entered for this symbol,
785 so that we can discard them later as necessary. Note
786 that this function is only called if we are using an
787 elf_i386 linker hash table, which means that h is
788 really a pointer to an elf_i386_link_hash_entry. */
791 && ELF32_R_TYPE (rel->r_info) == R_386_PC32))
793 struct elf_i386_link_hash_entry *eh;
794 struct elf_i386_dyn_relocs *p;
796 eh = (struct elf_i386_link_hash_entry *) h;
798 for (p = eh->dyn_relocs; p != NULL; p = p->next)
799 if (p->section == sreloc)
804 p = ((struct elf_i386_dyn_relocs *)
805 bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
808 p->next = eh->dyn_relocs;
820 /* This relocation describes the C++ object vtable hierarchy.
821 Reconstruct it for later use during GC. */
822 case R_386_GNU_VTINHERIT:
823 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
827 /* This relocation describes which C++ vtable entries are actually
828 used. Record for later use during GC. */
829 case R_386_GNU_VTENTRY:
830 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
842 /* Return the section that should be marked against GC for a given
846 elf_i386_gc_mark_hook (abfd, info, rel, h, sym)
848 struct bfd_link_info *info ATTRIBUTE_UNUSED;
849 Elf_Internal_Rela *rel;
850 struct elf_link_hash_entry *h;
851 Elf_Internal_Sym *sym;
855 switch (ELF32_R_TYPE (rel->r_info))
857 case R_386_GNU_VTINHERIT:
858 case R_386_GNU_VTENTRY:
862 switch (h->root.type)
864 case bfd_link_hash_defined:
865 case bfd_link_hash_defweak:
866 return h->root.u.def.section;
868 case bfd_link_hash_common:
869 return h->root.u.c.p->section;
878 if (!(elf_bad_symtab (abfd)
879 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
880 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
881 && sym->st_shndx != SHN_COMMON))
883 return bfd_section_from_elf_index (abfd, sym->st_shndx);
890 /* Update the got entry reference counts for the section being removed. */
893 elf_i386_gc_sweep_hook (abfd, info, sec, relocs)
895 struct bfd_link_info *info;
897 const Elf_Internal_Rela *relocs;
899 Elf_Internal_Shdr *symtab_hdr;
900 struct elf_link_hash_entry **sym_hashes;
901 bfd_signed_vma *local_got_refcounts;
902 const Elf_Internal_Rela *rel, *relend;
903 unsigned long r_symndx;
904 struct elf_link_hash_entry *h;
907 dynobj = elf_hash_table (info)->dynobj;
911 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
912 sym_hashes = elf_sym_hashes (abfd);
913 local_got_refcounts = elf_local_got_refcounts (abfd);
915 relend = relocs + sec->reloc_count;
916 for (rel = relocs; rel < relend; rel++)
917 switch (ELF32_R_TYPE (rel->r_info))
922 r_symndx = ELF32_R_SYM (rel->r_info);
923 if (r_symndx >= symtab_hdr->sh_info)
925 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
926 if (h->got.refcount > 0)
927 h->got.refcount -= 1;
929 else if (local_got_refcounts != NULL)
931 if (local_got_refcounts[r_symndx] > 0)
932 local_got_refcounts[r_symndx] -= 1;
943 r_symndx = ELF32_R_SYM (rel->r_info);
944 if (r_symndx >= symtab_hdr->sh_info)
946 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
947 if (h->plt.refcount > 0)
948 h->plt.refcount -= 1;
959 /* Adjust a symbol defined by a dynamic object and referenced by a
960 regular object. The current definition is in some section of the
961 dynamic object, but we're not including those sections. We have to
962 change the definition to something the rest of the link can
966 elf_i386_adjust_dynamic_symbol (info, h)
967 struct bfd_link_info *info;
968 struct elf_link_hash_entry *h;
970 struct elf_i386_link_hash_table *htab;
973 unsigned int power_of_two;
975 htab = elf_i386_hash_table (info);
976 dynobj = htab->root.dynobj;
978 /* If this is a function, put it in the procedure linkage table. We
979 will fill in the contents of the procedure linkage table later,
980 when we know the address of the .got section. */
981 if (h->type == STT_FUNC
982 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
984 if (h->plt.refcount <= 0
986 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
987 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0))
989 /* This case can occur if we saw a PLT32 reloc in an input
990 file, but the symbol was never referred to by a dynamic
991 object, or if all references were garbage collected. In
992 such a case, we don't actually need to build a procedure
993 linkage table, and we can just do a PC32 reloc instead. */
994 h->plt.refcount = (bfd_vma) -1;
995 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1001 /* It's possible that we incorrectly decided a .plt reloc was
1002 needed for an R_386_PC32 reloc to a non-function sym in
1003 check_relocs. We can't decide accurately between function and
1004 non-function syms in check-relocs; Objects loaded later in
1005 the link may change h->type. So fix it now. */
1006 h->plt.refcount = (bfd_vma) -1;
1008 /* If this is a weak symbol, and there is a real definition, the
1009 processor independent code will have arranged for us to see the
1010 real definition first, and we can just use the same value. */
1011 if (h->weakdef != NULL)
1013 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1014 || h->weakdef->root.type == bfd_link_hash_defweak);
1015 h->root.u.def.section = h->weakdef->root.u.def.section;
1016 h->root.u.def.value = h->weakdef->root.u.def.value;
1020 /* This is a reference to a symbol defined by a dynamic object which
1021 is not a function. */
1023 /* If we are creating a shared library, we must presume that the
1024 only references to the symbol are via the global offset table.
1025 For such cases we need not do anything here; the relocations will
1026 be handled correctly by relocate_section. */
1030 /* If there are no references to this symbol that do not use the
1031 GOT, we don't need to generate a copy reloc. */
1032 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
1035 /* We must allocate the symbol in our .dynbss section, which will
1036 become part of the .bss section of the executable. There will be
1037 an entry for this symbol in the .dynsym section. The dynamic
1038 object will contain position independent code, so all references
1039 from the dynamic object to this symbol will go through the global
1040 offset table. The dynamic linker will use the .dynsym entry to
1041 determine the address it must put in the global offset table, so
1042 both the dynamic object and the regular object will refer to the
1043 same memory location for the variable. */
1049 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1050 copy the initial value out of the dynamic object and into the
1051 runtime process image. We need to remember the offset into the
1052 .rel.bss section we are going to use. */
1053 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1057 srel = htab->srelbss;
1060 srel->_raw_size += sizeof (Elf32_External_Rel);
1061 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1064 /* We need to figure out the alignment required for this symbol. I
1065 have no idea how ELF linkers handle this. */
1066 power_of_two = bfd_log2 (h->size);
1067 if (power_of_two > 3)
1070 /* Apply the required alignment. */
1071 s->_raw_size = BFD_ALIGN (s->_raw_size,
1072 (bfd_size_type) (1 << power_of_two));
1073 if (power_of_two > bfd_get_section_alignment (dynobj, s))
1075 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
1079 /* Define the symbol as being at this point in the section. */
1080 h->root.u.def.section = s;
1081 h->root.u.def.value = s->_raw_size;
1083 /* Increment the section size to make room for the symbol. */
1084 s->_raw_size += h->size;
1089 /* This is the condition under which elf_i386_finish_dynamic_symbol
1090 will be called from elflink.h. If elflink.h doesn't call our
1091 finish_dynamic_symbol routine, we'll need to do something about
1092 initializing any .plt and .got entries in elf_i386_relocate_section. */
1093 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1095 && ((INFO)->shared \
1096 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1097 && ((H)->dynindx != -1 \
1098 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1100 /* Allocate space in .plt, .got and associated reloc sections for
1101 global syms. Also discards space allocated for relocs in the
1102 check_relocs function that we subsequently have found to be
1106 allocate_plt_and_got_and_discard_relocs (h, inf)
1107 struct elf_link_hash_entry *h;
1110 struct bfd_link_info *info;
1111 struct elf_i386_link_hash_table *htab;
1113 struct elf_i386_link_hash_entry *eh;
1115 if (h->root.type == bfd_link_hash_indirect
1116 || h->root.type == bfd_link_hash_warning)
1119 info = (struct bfd_link_info *) inf;
1120 htab = elf_i386_hash_table (info);
1122 if (htab->root.dynamic_sections_created
1123 && h->plt.refcount > 0)
1125 /* Make sure this symbol is output as a dynamic symbol.
1126 Undefined weak syms won't yet be marked as dynamic. */
1127 if (h->dynindx == -1
1128 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1130 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1138 /* If this is the first .plt entry, make room for the special
1140 if (s->_raw_size == 0)
1141 s->_raw_size += PLT_ENTRY_SIZE;
1143 h->plt.offset = s->_raw_size;
1145 /* If this symbol is not defined in a regular file, and we are
1146 not generating a shared library, then set the symbol to this
1147 location in the .plt. This is required to make function
1148 pointers compare as equal between the normal executable and
1149 the shared library. */
1151 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1153 h->root.u.def.section = s;
1154 h->root.u.def.value = h->plt.offset;
1157 /* Make room for this entry. */
1158 s->_raw_size += PLT_ENTRY_SIZE;
1160 /* We also need to make an entry in the .got.plt section, which
1161 will be placed in the .got section by the linker script. */
1167 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
1169 /* We also need to make an entry in the .rel.plt section. */
1173 s->_raw_size += sizeof (Elf32_External_Rel);
1178 h->plt.offset = (bfd_vma) -1;
1179 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1182 if (h->got.refcount > 0)
1186 /* Make sure this symbol is output as a dynamic symbol.
1187 Undefined weak syms won't yet be marked as dynamic. */
1188 if (h->dynindx == -1
1189 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1191 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1196 h->got.offset = s->_raw_size;
1198 dyn = htab->root.dynamic_sections_created;
1199 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
1200 htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1203 h->got.offset = (bfd_vma) -1;
1205 /* In the shared -Bsymbolic case, discard space allocated for
1206 dynamic relocs against symbols which turn out to be defined
1207 in regular objects. For the normal shared case, discard space
1208 for relocs that have become local due to symbol visibility
1209 changes. For the non-shared case, discard space for symbols
1210 which turn out to need copy relocs or are not dynamic. */
1212 eh = (struct elf_i386_link_hash_entry *) h;
1213 if (eh->dyn_relocs == NULL)
1217 && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1218 && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1219 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1220 || (htab->root.dynamic_sections_created
1221 && (h->root.type == bfd_link_hash_undefweak
1222 || h->root.type == bfd_link_hash_undefined))))
1224 /* Make sure this symbol is output as a dynamic symbol.
1225 Undefined weak syms won't yet be marked as dynamic. */
1226 if (h->dynindx == -1
1227 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1229 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1233 /* If that succeeded, we know we'll be keeping all the relocs. */
1234 if (h->dynindx != -1)
1239 || ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1240 && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1241 || info->symbolic)))
1243 struct elf_i386_dyn_relocs *c;
1245 for (c = eh->dyn_relocs; c != NULL; c = c->next)
1246 c->section->_raw_size -= c->count * sizeof (Elf32_External_Rel);
1252 /* Set the sizes of the dynamic sections. */
1255 elf_i386_size_dynamic_sections (output_bfd, info)
1256 bfd *output_bfd ATTRIBUTE_UNUSED;
1257 struct bfd_link_info *info;
1259 struct elf_i386_link_hash_table *htab;
1265 htab = elf_i386_hash_table (info);
1266 dynobj = htab->root.dynobj;
1270 if (htab->root.dynamic_sections_created)
1272 /* Set the contents of the .interp section to the interpreter. */
1275 s = bfd_get_section_by_name (dynobj, ".interp");
1278 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1279 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1283 /* Set up .got offsets for local syms. */
1284 for (i = info->input_bfds; i; i = i->link_next)
1286 bfd_signed_vma *local_got;
1287 bfd_signed_vma *end_local_got;
1288 bfd_size_type locsymcount;
1289 Elf_Internal_Shdr *symtab_hdr;
1292 if (bfd_get_flavour (i) != bfd_target_elf_flavour)
1295 local_got = elf_local_got_refcounts (i);
1299 symtab_hdr = &elf_tdata (i)->symtab_hdr;
1300 locsymcount = symtab_hdr->sh_info;
1301 end_local_got = local_got + locsymcount;
1303 srel = htab->srelgot;
1304 for (; local_got < end_local_got; ++local_got)
1308 *local_got = s->_raw_size;
1311 srel->_raw_size += sizeof (Elf32_External_Rel);
1314 *local_got = (bfd_vma) -1;
1318 /* Allocate global sym .plt and .got entries. Also discard all
1320 elf_link_hash_traverse (&htab->root,
1321 allocate_plt_and_got_and_discard_relocs,
1324 /* We now have determined the sizes of the various dynamic sections.
1325 Allocate memory for them. */
1327 for (s = dynobj->sections; s != NULL; s = s->next)
1329 if ((s->flags & SEC_LINKER_CREATED) == 0)
1334 || s == htab->sgotplt)
1336 /* Strip this section if we don't need it; see the
1339 else if (strncmp (bfd_get_section_name (dynobj, s), ".rel", 4) == 0)
1341 if (s->_raw_size == 0)
1343 /* If we don't need this section, strip it from the
1344 output file. This is mostly to handle .rel.bss and
1345 .rel.plt. We must create both sections in
1346 create_dynamic_sections, because they must be created
1347 before the linker maps input sections to output
1348 sections. The linker does that before
1349 adjust_dynamic_symbol is called, and it is that
1350 function which decides whether anything needs to go
1351 into these sections. */
1355 if (s != htab->srelplt)
1358 /* We use the reloc_count field as a counter if we need
1359 to copy relocs into the output file. */
1365 /* It's not one of our sections, so don't allocate space. */
1369 if (s->_raw_size == 0)
1371 _bfd_strip_section_from_output (info, s);
1375 /* Allocate memory for the section contents. We use bfd_zalloc
1376 here in case unused entries are not reclaimed before the
1377 section's contents are written out. This should not happen,
1378 but this way if it does, we get a R_386_NONE reloc instead
1380 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1381 if (s->contents == NULL)
1385 if (htab->root.dynamic_sections_created)
1387 /* Add some entries to the .dynamic section. We fill in the
1388 values later, in elf_i386_finish_dynamic_sections, but we
1389 must add the entries now so that we get the correct size for
1390 the .dynamic section. The DT_DEBUG entry is filled in by the
1391 dynamic linker and used by the debugger. */
1392 #define add_dynamic_entry(TAG, VAL) \
1393 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1397 if (!add_dynamic_entry (DT_DEBUG, 0))
1401 if (htab->splt->_raw_size != 0)
1403 if (!add_dynamic_entry (DT_PLTGOT, 0)
1404 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1405 || !add_dynamic_entry (DT_PLTREL, DT_REL)
1406 || !add_dynamic_entry (DT_JMPREL, 0))
1412 if (!add_dynamic_entry (DT_REL, 0)
1413 || !add_dynamic_entry (DT_RELSZ, 0)
1414 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
1418 if ((info->flags & DF_TEXTREL) != 0)
1420 if (!add_dynamic_entry (DT_TEXTREL, 0))
1424 #undef add_dynamic_entry
1429 /* Relocate an i386 ELF section. */
1432 elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
1433 contents, relocs, local_syms, local_sections)
1435 struct bfd_link_info *info;
1437 asection *input_section;
1439 Elf_Internal_Rela *relocs;
1440 Elf_Internal_Sym *local_syms;
1441 asection **local_sections;
1443 struct elf_i386_link_hash_table *htab;
1445 Elf_Internal_Shdr *symtab_hdr;
1446 struct elf_link_hash_entry **sym_hashes;
1447 bfd_vma *local_got_offsets;
1449 Elf_Internal_Rela *rel;
1450 Elf_Internal_Rela *relend;
1452 htab = elf_i386_hash_table (info);
1453 dynobj = htab->root.dynobj;
1454 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1455 sym_hashes = elf_sym_hashes (input_bfd);
1456 local_got_offsets = elf_local_got_offsets (input_bfd);
1460 relend = relocs + input_section->reloc_count;
1461 for (; rel < relend; rel++)
1464 reloc_howto_type *howto;
1465 unsigned long r_symndx;
1466 struct elf_link_hash_entry *h;
1467 Elf_Internal_Sym *sym;
1471 boolean unresolved_reloc;
1472 bfd_reloc_status_type r;
1475 r_type = ELF32_R_TYPE (rel->r_info);
1476 if (r_type == (int) R_386_GNU_VTINHERIT
1477 || r_type == (int) R_386_GNU_VTENTRY)
1480 if ((indx = (unsigned) r_type) >= R_386_standard
1481 && ((indx = (unsigned) r_type - R_386_ext_offset) - R_386_standard
1482 >= R_386_ext - R_386_standard))
1484 bfd_set_error (bfd_error_bad_value);
1487 howto = elf_howto_table + indx;
1489 r_symndx = ELF32_R_SYM (rel->r_info);
1491 if (info->relocateable)
1493 /* This is a relocateable link. We don't have to change
1494 anything, unless the reloc is against a section symbol,
1495 in which case we have to adjust according to where the
1496 section symbol winds up in the output section. */
1497 if (r_symndx < symtab_hdr->sh_info)
1499 sym = local_syms + r_symndx;
1500 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1504 sec = local_sections[r_symndx];
1505 val = bfd_get_32 (input_bfd, contents + rel->r_offset);
1506 val += sec->output_offset + sym->st_value;
1507 bfd_put_32 (input_bfd, val, contents + rel->r_offset);
1514 /* This is a final link. */
1518 unresolved_reloc = false;
1519 if (r_symndx < symtab_hdr->sh_info)
1521 sym = local_syms + r_symndx;
1522 sec = local_sections[r_symndx];
1523 relocation = (sec->output_section->vma
1524 + sec->output_offset
1529 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1530 while (h->root.type == bfd_link_hash_indirect
1531 || h->root.type == bfd_link_hash_warning)
1532 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1535 if (h->root.type == bfd_link_hash_defined
1536 || h->root.type == bfd_link_hash_defweak)
1538 sec = h->root.u.def.section;
1539 if (sec->output_section == NULL)
1540 /* Set a flag that will be cleared later if we find a
1541 relocation value for this symbol. output_section
1542 is typically NULL for symbols satisfied by a shared
1544 unresolved_reloc = true;
1546 relocation = (h->root.u.def.value
1547 + sec->output_section->vma
1548 + sec->output_offset);
1550 else if (h->root.type == bfd_link_hash_undefweak)
1552 else if (info->shared && !info->symbolic
1553 && !info->no_undefined
1554 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1558 if (! ((*info->callbacks->undefined_symbol)
1559 (info, h->root.root.string, input_bfd,
1560 input_section, rel->r_offset,
1561 (!info->shared || info->no_undefined
1562 || ELF_ST_VISIBILITY (h->other)))))
1570 /* Relocation is to the entry for this symbol in the global
1572 if (htab->sgot == NULL)
1579 off = h->got.offset;
1580 dyn = htab->root.dynamic_sections_created;
1581 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
1585 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
1586 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1588 /* This is actually a static link, or it is a
1589 -Bsymbolic link and the symbol is defined
1590 locally, or the symbol was forced to be local
1591 because of a version file. We must initialize
1592 this entry in the global offset table. Since the
1593 offset must always be a multiple of 4, we use the
1594 least significant bit to record whether we have
1595 initialized it already.
1597 When doing a dynamic link, we create a .rel.got
1598 relocation entry to initialize the value. This
1599 is done in the finish_dynamic_symbol routine. */
1604 bfd_put_32 (output_bfd, relocation,
1605 htab->sgot->contents + off);
1610 unresolved_reloc = false;
1614 if (local_got_offsets == NULL)
1617 off = local_got_offsets[r_symndx];
1619 /* The offset must always be a multiple of 4. We use
1620 the least significant bit to record whether we have
1621 already generated the necessary reloc. */
1626 bfd_put_32 (output_bfd, relocation,
1627 htab->sgot->contents + off);
1632 Elf_Internal_Rel outrel;
1634 srelgot = htab->srelgot;
1635 if (srelgot == NULL)
1638 outrel.r_offset = (htab->sgot->output_section->vma
1639 + htab->sgot->output_offset
1641 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1642 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1643 (((Elf32_External_Rel *)
1645 + srelgot->reloc_count));
1646 ++srelgot->reloc_count;
1649 local_got_offsets[r_symndx] |= 1;
1653 if (off >= (bfd_vma) -2)
1656 relocation = htab->sgot->output_offset + off;
1660 /* Relocation is relative to the start of the global offset
1663 /* Note that sgot->output_offset is not involved in this
1664 calculation. We always want the start of .got. If we
1665 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1666 permitted by the ABI, we might have to change this
1668 relocation -= htab->sgot->output_section->vma;
1672 /* Use global offset table as symbol value. */
1673 relocation = htab->sgot->output_section->vma;
1674 unresolved_reloc = false;
1678 /* Relocation is to the entry for this symbol in the
1679 procedure linkage table. */
1681 /* Resolve a PLT32 reloc against a local symbol directly,
1682 without using the procedure linkage table. */
1686 if (h->plt.offset == (bfd_vma) -1
1687 || htab->splt == NULL)
1689 /* We didn't make a PLT entry for this symbol. This
1690 happens when statically linking PIC code, or when
1691 using -Bsymbolic. */
1695 relocation = (htab->splt->output_section->vma
1696 + htab->splt->output_offset
1698 unresolved_reloc = false;
1704 && (input_section->flags & SEC_ALLOC) != 0
1705 && (r_type != R_386_PC32
1708 && (! info->symbolic
1709 || (h->elf_link_hash_flags
1710 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1712 && (input_section->flags & SEC_ALLOC) != 0
1715 && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1716 && (((h->elf_link_hash_flags
1717 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1718 && (h->elf_link_hash_flags
1719 & ELF_LINK_HASH_DEF_REGULAR) == 0)
1720 || h->root.type == bfd_link_hash_undefweak
1721 || h->root.type == bfd_link_hash_undefined)))
1723 Elf_Internal_Rel outrel;
1724 boolean skip, relocate;
1726 /* When generating a shared object, these relocations
1727 are copied into the output file to be resolved at run
1734 name = (bfd_elf_string_from_elf_section
1736 elf_elfheader (input_bfd)->e_shstrndx,
1737 elf_section_data (input_section)->rel_hdr.sh_name));
1741 if (strncmp (name, ".rel", 4) != 0
1742 || strcmp (bfd_get_section_name (input_bfd,
1746 if (input_bfd->my_archive)
1747 (*_bfd_error_handler)\
1748 (_("%s(%s): bad relocation section name `%s\'"),
1749 bfd_get_filename (input_bfd->my_archive),
1750 bfd_get_filename (input_bfd),
1753 (*_bfd_error_handler)
1754 (_("%s: bad relocation section name `%s\'"),
1755 bfd_get_filename (input_bfd),
1760 sreloc = bfd_get_section_by_name (dynobj, name);
1767 if (elf_section_data (input_section)->stab_info == NULL)
1768 outrel.r_offset = rel->r_offset;
1771 off = (_bfd_stab_section_offset
1772 (output_bfd, htab->root.stab_info, input_section,
1773 &elf_section_data (input_section)->stab_info,
1775 if (off == (bfd_vma) -1)
1777 outrel.r_offset = off;
1780 outrel.r_offset += (input_section->output_section->vma
1781 + input_section->output_offset);
1785 memset (&outrel, 0, sizeof outrel);
1790 && (r_type == R_386_PC32
1793 || (h->elf_link_hash_flags
1794 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1798 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1802 /* This symbol is local, or marked to become local. */
1804 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1807 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1808 (((Elf32_External_Rel *)
1810 + sreloc->reloc_count));
1811 ++sreloc->reloc_count;
1813 /* If this reloc is against an external symbol, we do
1814 not want to fiddle with the addend. Otherwise, we
1815 need to include the symbol value so that it becomes
1816 an addend for the dynamic reloc. */
1827 /* FIXME: Why do we allow debugging sections to escape this error?
1828 More importantly, why do we not emit dynamic relocs for
1829 R_386_32 above in debugging sections (which are ! SEC_ALLOC)?
1830 If we had emitted the dynamic reloc, we could remove the
1832 if (unresolved_reloc
1834 && (input_section->flags & SEC_DEBUGGING) != 0
1835 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
1836 (*_bfd_error_handler)
1837 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
1838 bfd_get_filename (input_bfd),
1839 bfd_get_section_name (input_bfd, input_section),
1840 (long) rel->r_offset,
1841 h->root.root.string);
1843 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1844 contents, rel->r_offset,
1845 relocation, (bfd_vma) 0);
1852 case bfd_reloc_overflow:
1857 name = h->root.root.string;
1860 name = bfd_elf_string_from_elf_section (input_bfd,
1861 symtab_hdr->sh_link,
1866 name = bfd_section_name (input_bfd, sec);
1868 if (! ((*info->callbacks->reloc_overflow)
1869 (info, name, howto->name, (bfd_vma) 0,
1870 input_bfd, input_section, rel->r_offset)))
1876 case bfd_reloc_outofrange:
1885 /* Finish up dynamic symbol handling. We set the contents of various
1886 dynamic sections here. */
1889 elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
1891 struct bfd_link_info *info;
1892 struct elf_link_hash_entry *h;
1893 Elf_Internal_Sym *sym;
1895 struct elf_i386_link_hash_table *htab;
1898 htab = elf_i386_hash_table (info);
1899 dynobj = htab->root.dynobj;
1901 if (h->plt.offset != (bfd_vma) -1)
1905 Elf_Internal_Rel rel;
1907 /* This symbol has an entry in the procedure linkage table. Set
1910 if (h->dynindx == -1
1911 || htab->splt == NULL
1912 || htab->sgotplt == NULL
1913 || htab->srelplt == NULL)
1916 /* Get the index in the procedure linkage table which
1917 corresponds to this symbol. This is the index of this symbol
1918 in all the symbols for which we are making plt entries. The
1919 first entry in the procedure linkage table is reserved. */
1920 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1922 /* Get the offset into the .got table of the entry that
1923 corresponds to this function. Each .got entry is 4 bytes.
1924 The first three are reserved. */
1925 got_offset = (plt_index + 3) * 4;
1927 /* Fill in the entry in the procedure linkage table. */
1930 memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
1932 bfd_put_32 (output_bfd,
1933 (htab->sgotplt->output_section->vma
1934 + htab->sgotplt->output_offset
1936 htab->splt->contents + h->plt.offset + 2);
1940 memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
1942 bfd_put_32 (output_bfd, got_offset,
1943 htab->splt->contents + h->plt.offset + 2);
1946 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
1947 htab->splt->contents + h->plt.offset + 7);
1948 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
1949 htab->splt->contents + h->plt.offset + 12);
1951 /* Fill in the entry in the global offset table. */
1952 bfd_put_32 (output_bfd,
1953 (htab->splt->output_section->vma
1954 + htab->splt->output_offset
1957 htab->sgotplt->contents + got_offset);
1959 /* Fill in the entry in the .rel.plt section. */
1960 rel.r_offset = (htab->sgotplt->output_section->vma
1961 + htab->sgotplt->output_offset
1963 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
1964 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1965 ((Elf32_External_Rel *) htab->srelplt->contents
1968 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1970 /* Mark the symbol as undefined, rather than as defined in
1971 the .plt section. Leave the value alone. */
1972 sym->st_shndx = SHN_UNDEF;
1976 if (h->got.offset != (bfd_vma) -1)
1978 Elf_Internal_Rel rel;
1980 /* This symbol has an entry in the global offset table. Set it
1983 if (htab->sgot == NULL || htab->srelgot == NULL)
1986 rel.r_offset = (htab->sgot->output_section->vma
1987 + htab->sgot->output_offset
1988 + (h->got.offset & ~(bfd_vma) 1));
1990 /* If this is a static link, or it is a -Bsymbolic link and the
1991 symbol is defined locally or was forced to be local because
1992 of a version file, we just want to emit a RELATIVE reloc.
1993 The entry in the global offset table will already have been
1994 initialized in the relocate_section function. */
1998 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
1999 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
2001 BFD_ASSERT((h->got.offset & 1) != 0);
2002 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2006 BFD_ASSERT((h->got.offset & 1) == 0);
2007 bfd_put_32 (output_bfd, (bfd_vma) 0,
2008 htab->sgot->contents + h->got.offset);
2009 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
2012 bfd_elf32_swap_reloc_out (output_bfd, &rel,
2013 ((Elf32_External_Rel *) htab->srelgot->contents
2014 + htab->srelgot->reloc_count));
2015 ++htab->srelgot->reloc_count;
2018 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2020 Elf_Internal_Rel rel;
2022 /* This symbol needs a copy reloc. Set it up. */
2024 if (h->dynindx == -1
2025 || (h->root.type != bfd_link_hash_defined
2026 && h->root.type != bfd_link_hash_defweak)
2027 || htab->srelbss == NULL)
2030 rel.r_offset = (h->root.u.def.value
2031 + h->root.u.def.section->output_section->vma
2032 + h->root.u.def.section->output_offset);
2033 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
2034 bfd_elf32_swap_reloc_out (output_bfd, &rel,
2035 ((Elf32_External_Rel *) htab->srelbss->contents
2036 + htab->srelbss->reloc_count));
2037 ++htab->srelbss->reloc_count;
2040 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2041 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2042 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2043 sym->st_shndx = SHN_ABS;
2048 /* Finish up the dynamic sections. */
2051 elf_i386_finish_dynamic_sections (output_bfd, info)
2053 struct bfd_link_info *info;
2055 struct elf_i386_link_hash_table *htab;
2059 htab = elf_i386_hash_table (info);
2060 dynobj = htab->root.dynobj;
2061 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2063 if (htab->root.dynamic_sections_created)
2065 Elf32_External_Dyn *dyncon, *dynconend;
2067 if (sdyn == NULL || htab->sgot == NULL)
2070 dyncon = (Elf32_External_Dyn *) sdyn->contents;
2071 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2072 for (; dyncon < dynconend; dyncon++)
2074 Elf_Internal_Dyn dyn;
2076 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2084 dyn.d_un.d_ptr = htab->sgot->output_section->vma;
2085 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2089 dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
2090 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2094 if (htab->srelplt->output_section->_cooked_size != 0)
2095 dyn.d_un.d_val = htab->srelplt->output_section->_cooked_size;
2097 dyn.d_un.d_val = htab->srelplt->output_section->_raw_size;
2098 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2102 /* My reading of the SVR4 ABI indicates that the
2103 procedure linkage table relocs (DT_JMPREL) should be
2104 included in the overall relocs (DT_REL). This is
2105 what Solaris does. However, UnixWare can not handle
2106 that case. Therefore, we override the DT_RELSZ entry
2107 here to make it not include the JMPREL relocs. Since
2108 the linker script arranges for .rel.plt to follow all
2109 other relocation sections, we don't have to worry
2110 about changing the DT_REL entry. */
2111 if (htab->srelplt != NULL)
2113 if (htab->srelplt->output_section->_cooked_size != 0)
2114 dyn.d_un.d_val -= htab->srelplt->output_section->_cooked_size;
2116 dyn.d_un.d_val -= htab->srelplt->output_section->_raw_size;
2118 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2123 /* Fill in the first entry in the procedure linkage table. */
2124 if (htab->splt && htab->splt->_raw_size > 0)
2127 memcpy (htab->splt->contents,
2128 elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
2131 memcpy (htab->splt->contents,
2132 elf_i386_plt0_entry, PLT_ENTRY_SIZE);
2133 bfd_put_32 (output_bfd,
2134 (htab->sgotplt->output_section->vma
2135 + htab->sgotplt->output_offset
2137 htab->splt->contents + 2);
2138 bfd_put_32 (output_bfd,
2139 (htab->sgotplt->output_section->vma
2140 + htab->sgotplt->output_offset
2142 htab->splt->contents + 8);
2145 /* UnixWare sets the entsize of .plt to 4, although that doesn't
2146 really seem like the right value. */
2147 elf_section_data (htab->splt->output_section)
2148 ->this_hdr.sh_entsize = 4;
2154 /* Fill in the first three entries in the global offset table. */
2155 if (htab->sgotplt->_raw_size > 0)
2157 bfd_put_32 (output_bfd,
2158 (sdyn == NULL ? (bfd_vma) 0
2159 : sdyn->output_section->vma + sdyn->output_offset),
2160 htab->sgotplt->contents);
2161 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 4);
2162 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8);
2165 elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
2170 /* Set the correct type for an x86 ELF section. We do this by the
2171 section name, which is a hack, but ought to work. */
2174 elf_i386_fake_sections (abfd, hdr, sec)
2175 bfd *abfd ATTRIBUTE_UNUSED;
2176 Elf32_Internal_Shdr *hdr;
2179 register const char *name;
2181 name = bfd_get_section_name (abfd, sec);
2183 if (strcmp (name, ".reloc") == 0)
2185 * This is an ugly, but unfortunately necessary hack that is
2186 * needed when producing EFI binaries on x86. It tells
2187 * elf.c:elf_fake_sections() not to consider ".reloc" as a section
2188 * containing ELF relocation info. We need this hack in order to
2189 * be able to generate ELF binaries that can be translated into
2190 * EFI applications (which are essentially COFF objects). Those
2191 * files contain a COFF ".reloc" section inside an ELFNN object,
2192 * which would normally cause BFD to segfault because it would
2193 * attempt to interpret this section as containing relocation
2194 * entries for section "oc". With this hack enabled, ".reloc"
2195 * will be treated as a normal data section, which will avoid the
2196 * segfault. However, you won't be able to create an ELFNN binary
2197 * with a section named "oc" that needs relocations, but that's
2198 * the kind of ugly side-effects you get when detecting section
2199 * types based on their names... In practice, this limitation is
2202 hdr->sh_type = SHT_PROGBITS;
2207 static enum elf_reloc_type_class
2208 elf_i386_reloc_type_class (type)
2213 case R_386_RELATIVE:
2214 return reloc_class_relative;
2215 case R_386_JUMP_SLOT:
2216 return reloc_class_plt;
2218 return reloc_class_copy;
2220 return reloc_class_normal;
2224 /* Support for core dump NOTE sections */
2226 elf_i386_grok_prstatus (abfd, note)
2228 Elf_Internal_Note *note;
2233 switch (note->descsz)
2238 case 144: /* Linux/i386 */
2240 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
2243 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
2252 /* Make a ".reg/999" section. */
2253 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2254 raw_size, note->descpos + offset);
2258 elf_i386_grok_psinfo (abfd, note)
2260 Elf_Internal_Note *note;
2262 switch (note->descsz)
2267 case 128: /* Linux/MIPS elf_prpsinfo */
2268 elf_tdata (abfd)->core_program
2269 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
2270 elf_tdata (abfd)->core_command
2271 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
2274 /* Note that for some reason, a spurious space is tacked
2275 onto the end of the args in some (at least one anyway)
2276 implementations, so strip it off if it exists. */
2279 char *command = elf_tdata (abfd)->core_command;
2280 int n = strlen (command);
2282 if (0 < n && command[n - 1] == ' ')
2283 command[n - 1] = '\0';
2289 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
2290 #define TARGET_LITTLE_NAME "elf32-i386"
2291 #define ELF_ARCH bfd_arch_i386
2292 #define ELF_MACHINE_CODE EM_386
2293 #define ELF_MAXPAGESIZE 0x1000
2295 #define elf_backend_can_gc_sections 1
2296 #define elf_backend_want_got_plt 1
2297 #define elf_backend_plt_readonly 1
2298 #define elf_backend_want_plt_sym 0
2299 #define elf_backend_got_header_size 12
2300 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
2302 #define elf_info_to_howto elf_i386_info_to_howto
2303 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
2305 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
2306 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
2307 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
2309 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
2310 #define elf_backend_check_relocs elf_i386_check_relocs
2311 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
2312 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
2313 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
2314 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
2315 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
2316 #define elf_backend_relocate_section elf_i386_relocate_section
2317 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
2318 #define elf_backend_fake_sections elf_i386_fake_sections
2319 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
2320 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
2321 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
2323 #include "elf32-target.h"