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 boolean elf_i386_adjust_dynamic_symbol
45 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
46 static boolean allocate_plt_and_got_and_discard_relocs
47 PARAMS ((struct elf_link_hash_entry *, PTR));
48 static boolean elf_i386_size_dynamic_sections
49 PARAMS ((bfd *, struct bfd_link_info *));
50 static boolean elf_i386_relocate_section
51 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
52 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
53 static boolean elf_i386_finish_dynamic_symbol
54 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
56 static boolean elf_i386_finish_dynamic_sections
57 PARAMS ((bfd *, struct bfd_link_info *));
59 #define USE_REL 1 /* 386 uses REL relocations instead of RELA */
63 static reloc_howto_type elf_howto_table[]=
65 HOWTO(R_386_NONE, 0, 0, 0, false, 0, complain_overflow_bitfield,
66 bfd_elf_generic_reloc, "R_386_NONE",
67 true, 0x00000000, 0x00000000, false),
68 HOWTO(R_386_32, 0, 2, 32, false, 0, complain_overflow_bitfield,
69 bfd_elf_generic_reloc, "R_386_32",
70 true, 0xffffffff, 0xffffffff, false),
71 HOWTO(R_386_PC32, 0, 2, 32, true, 0, complain_overflow_bitfield,
72 bfd_elf_generic_reloc, "R_386_PC32",
73 true, 0xffffffff, 0xffffffff, true),
74 HOWTO(R_386_GOT32, 0, 2, 32, false, 0, complain_overflow_bitfield,
75 bfd_elf_generic_reloc, "R_386_GOT32",
76 true, 0xffffffff, 0xffffffff, false),
77 HOWTO(R_386_PLT32, 0, 2, 32, true, 0, complain_overflow_bitfield,
78 bfd_elf_generic_reloc, "R_386_PLT32",
79 true, 0xffffffff, 0xffffffff, true),
80 HOWTO(R_386_COPY, 0, 2, 32, false, 0, complain_overflow_bitfield,
81 bfd_elf_generic_reloc, "R_386_COPY",
82 true, 0xffffffff, 0xffffffff, false),
83 HOWTO(R_386_GLOB_DAT, 0, 2, 32, false, 0, complain_overflow_bitfield,
84 bfd_elf_generic_reloc, "R_386_GLOB_DAT",
85 true, 0xffffffff, 0xffffffff, false),
86 HOWTO(R_386_JUMP_SLOT, 0, 2, 32, false, 0, complain_overflow_bitfield,
87 bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
88 true, 0xffffffff, 0xffffffff, false),
89 HOWTO(R_386_RELATIVE, 0, 2, 32, false, 0, complain_overflow_bitfield,
90 bfd_elf_generic_reloc, "R_386_RELATIVE",
91 true, 0xffffffff, 0xffffffff, false),
92 HOWTO(R_386_GOTOFF, 0, 2, 32, false, 0, complain_overflow_bitfield,
93 bfd_elf_generic_reloc, "R_386_GOTOFF",
94 true, 0xffffffff, 0xffffffff, false),
95 HOWTO(R_386_GOTPC, 0, 2, 32, true, 0, complain_overflow_bitfield,
96 bfd_elf_generic_reloc, "R_386_GOTPC",
97 true, 0xffffffff, 0xffffffff, true),
99 /* We have a gap in the reloc numbers here.
100 R_386_standard counts the number up to this point, and
101 R_386_ext_offset is the value to subtract from a reloc type of
102 R_386_16 thru R_386_PC8 to form an index into this table. */
103 #define R_386_standard ((unsigned int) R_386_GOTPC + 1)
104 #define R_386_ext_offset ((unsigned int) R_386_16 - R_386_standard)
106 /* The remaining relocs are a GNU extension. */
107 HOWTO(R_386_16, 0, 1, 16, false, 0, complain_overflow_bitfield,
108 bfd_elf_generic_reloc, "R_386_16",
109 true, 0xffff, 0xffff, false),
110 HOWTO(R_386_PC16, 0, 1, 16, true, 0, complain_overflow_bitfield,
111 bfd_elf_generic_reloc, "R_386_PC16",
112 true, 0xffff, 0xffff, true),
113 HOWTO(R_386_8, 0, 0, 8, false, 0, complain_overflow_bitfield,
114 bfd_elf_generic_reloc, "R_386_8",
115 true, 0xff, 0xff, false),
116 HOWTO(R_386_PC8, 0, 0, 8, true, 0, complain_overflow_signed,
117 bfd_elf_generic_reloc, "R_386_PC8",
118 true, 0xff, 0xff, true),
121 #define R_386_ext ((unsigned int) R_386_PC8 + 1 - R_386_ext_offset)
122 #define R_386_vt_offset ((unsigned int) R_386_GNU_VTINHERIT - R_386_ext)
124 /* GNU extension to record C++ vtable hierarchy. */
125 HOWTO (R_386_GNU_VTINHERIT, /* type */
127 2, /* size (0 = byte, 1 = short, 2 = long) */
129 false, /* pc_relative */
131 complain_overflow_dont, /* complain_on_overflow */
132 NULL, /* special_function */
133 "R_386_GNU_VTINHERIT", /* name */
134 false, /* partial_inplace */
139 /* GNU extension to record C++ vtable member usage. */
140 HOWTO (R_386_GNU_VTENTRY, /* type */
142 2, /* size (0 = byte, 1 = short, 2 = long) */
144 false, /* pc_relative */
146 complain_overflow_dont, /* complain_on_overflow */
147 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
148 "R_386_GNU_VTENTRY", /* name */
149 false, /* partial_inplace */
154 #define R_386_vt ((unsigned int) R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
158 #ifdef DEBUG_GEN_RELOC
159 #define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
164 static reloc_howto_type *
165 elf_i386_reloc_type_lookup (abfd, code)
166 bfd *abfd ATTRIBUTE_UNUSED;
167 bfd_reloc_code_real_type code;
172 TRACE ("BFD_RELOC_NONE");
173 return &elf_howto_table[(unsigned int) R_386_NONE ];
176 TRACE ("BFD_RELOC_32");
177 return &elf_howto_table[(unsigned int) R_386_32 ];
180 TRACE ("BFD_RELOC_CTOR");
181 return &elf_howto_table[(unsigned int) R_386_32 ];
183 case BFD_RELOC_32_PCREL:
184 TRACE ("BFD_RELOC_PC32");
185 return &elf_howto_table[(unsigned int) R_386_PC32 ];
187 case BFD_RELOC_386_GOT32:
188 TRACE ("BFD_RELOC_386_GOT32");
189 return &elf_howto_table[(unsigned int) R_386_GOT32 ];
191 case BFD_RELOC_386_PLT32:
192 TRACE ("BFD_RELOC_386_PLT32");
193 return &elf_howto_table[(unsigned int) R_386_PLT32 ];
195 case BFD_RELOC_386_COPY:
196 TRACE ("BFD_RELOC_386_COPY");
197 return &elf_howto_table[(unsigned int) R_386_COPY ];
199 case BFD_RELOC_386_GLOB_DAT:
200 TRACE ("BFD_RELOC_386_GLOB_DAT");
201 return &elf_howto_table[(unsigned int) R_386_GLOB_DAT ];
203 case BFD_RELOC_386_JUMP_SLOT:
204 TRACE ("BFD_RELOC_386_JUMP_SLOT");
205 return &elf_howto_table[(unsigned int) R_386_JUMP_SLOT ];
207 case BFD_RELOC_386_RELATIVE:
208 TRACE ("BFD_RELOC_386_RELATIVE");
209 return &elf_howto_table[(unsigned int) R_386_RELATIVE ];
211 case BFD_RELOC_386_GOTOFF:
212 TRACE ("BFD_RELOC_386_GOTOFF");
213 return &elf_howto_table[(unsigned int) R_386_GOTOFF ];
215 case BFD_RELOC_386_GOTPC:
216 TRACE ("BFD_RELOC_386_GOTPC");
217 return &elf_howto_table[(unsigned int) R_386_GOTPC ];
219 /* The remaining relocs are a GNU extension. */
221 TRACE ("BFD_RELOC_16");
222 return &elf_howto_table[(unsigned int) R_386_16 - R_386_ext_offset];
224 case BFD_RELOC_16_PCREL:
225 TRACE ("BFD_RELOC_16_PCREL");
226 return &elf_howto_table[(unsigned int) R_386_PC16 - R_386_ext_offset];
229 TRACE ("BFD_RELOC_8");
230 return &elf_howto_table[(unsigned int) R_386_8 - R_386_ext_offset];
232 case BFD_RELOC_8_PCREL:
233 TRACE ("BFD_RELOC_8_PCREL");
234 return &elf_howto_table[(unsigned int) R_386_PC8 - R_386_ext_offset];
236 case BFD_RELOC_VTABLE_INHERIT:
237 TRACE ("BFD_RELOC_VTABLE_INHERIT");
238 return &elf_howto_table[(unsigned int) R_386_GNU_VTINHERIT
241 case BFD_RELOC_VTABLE_ENTRY:
242 TRACE ("BFD_RELOC_VTABLE_ENTRY");
243 return &elf_howto_table[(unsigned int) R_386_GNU_VTENTRY
255 elf_i386_info_to_howto (abfd, cache_ptr, dst)
256 bfd *abfd ATTRIBUTE_UNUSED;
257 arelent *cache_ptr ATTRIBUTE_UNUSED;
258 Elf32_Internal_Rela *dst ATTRIBUTE_UNUSED;
264 elf_i386_info_to_howto_rel (abfd, cache_ptr, dst)
265 bfd *abfd ATTRIBUTE_UNUSED;
267 Elf32_Internal_Rel *dst;
269 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
272 if ((indx = r_type) >= R_386_standard
273 && ((indx = r_type - R_386_ext_offset) - R_386_standard
274 >= R_386_ext - R_386_standard)
275 && ((indx = r_type - R_386_vt_offset) - R_386_ext
276 >= R_386_vt - R_386_ext))
278 (*_bfd_error_handler) (_("%s: invalid relocation type %d"),
279 bfd_get_filename (abfd), (int) r_type);
280 indx = (unsigned int) R_386_NONE;
282 cache_ptr->howto = &elf_howto_table[indx];
285 /* Return whether a symbol name implies a local label. The UnixWare
286 2.1 cc generates temporary symbols that start with .X, so we
287 recognize them here. FIXME: do other SVR4 compilers also use .X?.
288 If so, we should move the .X recognition into
289 _bfd_elf_is_local_label_name. */
292 elf_i386_is_local_label_name (abfd, name)
296 if (name[0] == '.' && name[1] == 'X')
299 return _bfd_elf_is_local_label_name (abfd, name);
302 /* Functions for the i386 ELF linker. */
304 /* The name of the dynamic interpreter. This is put in the .interp
307 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
309 /* The size in bytes of an entry in the procedure linkage table. */
311 #define PLT_ENTRY_SIZE 16
313 /* The first entry in an absolute procedure linkage table looks like
314 this. See the SVR4 ABI i386 supplement to see how this works. */
316 static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] =
318 0xff, 0x35, /* pushl contents of address */
319 0, 0, 0, 0, /* replaced with address of .got + 4. */
320 0xff, 0x25, /* jmp indirect */
321 0, 0, 0, 0, /* replaced with address of .got + 8. */
322 0, 0, 0, 0 /* pad out to 16 bytes. */
325 /* Subsequent entries in an absolute procedure linkage table look like
328 static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
330 0xff, 0x25, /* jmp indirect */
331 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
332 0x68, /* pushl immediate */
333 0, 0, 0, 0, /* replaced with offset into relocation table. */
334 0xe9, /* jmp relative */
335 0, 0, 0, 0 /* replaced with offset to start of .plt. */
338 /* The first entry in a PIC procedure linkage table look like this. */
340 static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] =
342 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
343 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
344 0, 0, 0, 0 /* pad out to 16 bytes. */
347 /* Subsequent entries in a PIC procedure linkage table look like this. */
349 static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
351 0xff, 0xa3, /* jmp *offset(%ebx) */
352 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
353 0x68, /* pushl immediate */
354 0, 0, 0, 0, /* replaced with offset into relocation table. */
355 0xe9, /* jmp relative */
356 0, 0, 0, 0 /* replaced with offset to start of .plt. */
359 /* The i386 linker needs to keep track of the number of relocs that it
360 decides to copy as dynamic relocs in check_relocs for each symbol.
361 This is so that it can later discard them if they are found to be
362 unnecessary. We store the information in a field extending the
363 regular ELF linker hash table. */
365 struct elf_i386_dyn_relocs
368 struct elf_i386_dyn_relocs *next;
369 /* A section in dynobj. */
371 /* Number of relocs copied in this section. */
375 /* i386 ELF linker hash entry. */
377 struct elf_i386_link_hash_entry
379 struct elf_link_hash_entry root;
381 /* Number of PC relative relocs copied for this symbol. */
382 struct elf_i386_dyn_relocs *dyn_relocs;
385 /* i386 ELF linker hash table. */
387 struct elf_i386_link_hash_table
389 struct elf_link_hash_table root;
391 /* Short-cuts to get to dynamic linker sections. */
401 /* Get the i386 ELF linker hash table from a link_info structure. */
403 #define elf_i386_hash_table(p) \
404 ((struct elf_i386_link_hash_table *) ((p)->hash))
406 /* Create an entry in an i386 ELF linker hash table. */
408 static struct bfd_hash_entry *
409 elf_i386_link_hash_newfunc (entry, table, string)
410 struct bfd_hash_entry *entry;
411 struct bfd_hash_table *table;
414 struct elf_i386_link_hash_entry *ret =
415 (struct elf_i386_link_hash_entry *) entry;
417 /* Allocate the structure if it has not already been allocated by a
419 if (ret == (struct elf_i386_link_hash_entry *) NULL)
420 ret = ((struct elf_i386_link_hash_entry *)
421 bfd_hash_allocate (table,
422 sizeof (struct elf_i386_link_hash_entry)));
423 if (ret == (struct elf_i386_link_hash_entry *) NULL)
424 return (struct bfd_hash_entry *) ret;
426 /* Call the allocation method of the superclass. */
427 ret = ((struct elf_i386_link_hash_entry *)
428 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
430 if (ret != (struct elf_i386_link_hash_entry *) NULL)
432 ret->dyn_relocs = NULL;
435 return (struct bfd_hash_entry *) ret;
438 /* Create an i386 ELF linker hash table. */
440 static struct bfd_link_hash_table *
441 elf_i386_link_hash_table_create (abfd)
444 struct elf_i386_link_hash_table *ret;
446 ret = ((struct elf_i386_link_hash_table *)
447 bfd_alloc (abfd, sizeof (struct elf_i386_link_hash_table)));
448 if (ret == (struct elf_i386_link_hash_table *) NULL)
451 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
452 elf_i386_link_hash_newfunc))
454 bfd_release (abfd, ret);
466 return &ret->root.root;
469 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
470 shortcuts to them in our hash table. */
473 create_got_section (dynobj, info)
475 struct bfd_link_info *info;
477 struct elf_i386_link_hash_table *htab;
479 if (! _bfd_elf_create_got_section (dynobj, info))
482 htab = elf_i386_hash_table (info);
483 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
484 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
485 if (!htab->sgot || !htab->sgotplt)
488 htab->srelgot = bfd_make_section (dynobj, ".rel.got");
489 if (htab->srelgot == NULL
490 || ! bfd_set_section_flags (dynobj, htab->srelgot,
491 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
492 | SEC_IN_MEMORY | SEC_LINKER_CREATED
494 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
499 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
500 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
504 elf_i386_create_dynamic_sections (dynobj, info)
506 struct bfd_link_info *info;
508 struct elf_i386_link_hash_table *htab;
510 htab = elf_i386_hash_table (info);
511 if (!htab->sgot && !create_got_section (dynobj, info))
514 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
517 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
518 htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
519 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
521 htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
523 if (!htab->splt || !htab->srelplt || !htab->sdynbss
524 || (!info->shared && !htab->srelbss))
530 /* Look through the relocs for a section during the first phase, and
531 allocate space in the global offset table or procedure linkage
535 elf_i386_check_relocs (abfd, info, sec, relocs)
537 struct bfd_link_info *info;
539 const Elf_Internal_Rela *relocs;
541 struct elf_i386_link_hash_table *htab;
543 Elf_Internal_Shdr *symtab_hdr;
544 struct elf_link_hash_entry **sym_hashes;
545 bfd_signed_vma *local_got_refcounts;
546 const Elf_Internal_Rela *rel;
547 const Elf_Internal_Rela *rel_end;
550 if (info->relocateable)
553 htab = elf_i386_hash_table (info);
554 dynobj = htab->root.dynobj;
555 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
556 sym_hashes = elf_sym_hashes (abfd);
557 local_got_refcounts = elf_local_got_refcounts (abfd);
561 rel_end = relocs + sec->reloc_count;
562 for (rel = relocs; rel < rel_end; rel++)
564 unsigned long r_symndx;
565 struct elf_link_hash_entry *h;
567 r_symndx = ELF32_R_SYM (rel->r_info);
569 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
571 if (abfd->my_archive)
572 (*_bfd_error_handler) (_("%s(%s): bad symbol index: %d"),
573 bfd_get_filename (abfd->my_archive),
574 bfd_get_filename (abfd),
577 (*_bfd_error_handler) (_("%s: bad symbol index: %d"),
578 bfd_get_filename (abfd),
583 if (r_symndx < symtab_hdr->sh_info)
586 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
588 /* Some relocs require a global offset table. */
589 if (htab->sgot == NULL)
591 switch (ELF32_R_TYPE (rel->r_info))
597 htab->root.dynobj = dynobj = abfd;
598 if (!create_got_section (dynobj, info))
607 switch (ELF32_R_TYPE (rel->r_info))
610 /* This symbol requires a global offset table entry. */
613 if (h->got.refcount == -1)
615 /* Make sure this symbol is output as a dynamic symbol. */
616 if (h->dynindx == -1)
618 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
624 h->got.refcount += 1;
628 /* This is a global offset table entry for a local symbol. */
629 if (local_got_refcounts == NULL)
633 size = symtab_hdr->sh_info * sizeof (bfd_signed_vma);
634 local_got_refcounts = ((bfd_signed_vma *)
635 bfd_alloc (abfd, size));
636 if (local_got_refcounts == NULL)
638 elf_local_got_refcounts (abfd) = local_got_refcounts;
639 memset (local_got_refcounts, -1, size);
641 if (local_got_refcounts[r_symndx] == -1)
642 local_got_refcounts[r_symndx] = 1;
644 local_got_refcounts[r_symndx] += 1;
649 /* This symbol requires a procedure linkage table entry. We
650 actually build the entry in adjust_dynamic_symbol,
651 because this might be a case of linking PIC code which is
652 never referenced by a dynamic object, in which case we
653 don't need to generate a procedure linkage table entry
656 /* If this is a local symbol, we resolve it directly without
657 creating a procedure linkage table entry. */
661 if (h->plt.refcount == -1)
663 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
667 h->plt.refcount += 1;
672 if (h != NULL && !info->shared)
674 /* If this reloc is in a read-only section, we might
675 need a copy reloc. */
676 if ((sec->flags & SEC_READONLY) != 0)
677 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
679 /* We may need a .plt entry if the function this reloc
680 refers to is in a shared lib. */
681 if (h->plt.refcount == -1)
684 h->plt.refcount += 1;
687 /* If we are creating a shared library, and this is a reloc
688 against a global symbol, or a non PC relative reloc
689 against a local symbol, then we need to copy the reloc
690 into the shared library. However, if we are linking with
691 -Bsymbolic, we do not need to copy a reloc against a
692 global symbol which is defined in an object we are
693 including in the link (i.e., DEF_REGULAR is set). At
694 this point we have not seen all the input files, so it is
695 possible that DEF_REGULAR is not set now but will be set
696 later (it is never cleared). In case of a weak definition,
697 DEF_REGULAR may be cleared later by a strong definition in
698 a shared library. We account for that possibility below by
699 storing information in the relocs_copied field of the hash
700 table entry. A similar situation occurs when creating
701 shared libraries and symbol visibility changes render the
703 If on the other hand, we are creating an executable, we
704 may need to keep relocations for symbols satisfied by a
705 dynamic library if we manage to avoid copy relocs for the
708 && (sec->flags & SEC_ALLOC) != 0
709 && (ELF32_R_TYPE (rel->r_info) != R_386_PC32
712 || h->root.type == bfd_link_hash_defweak
713 || (h->elf_link_hash_flags
714 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
716 && (sec->flags & SEC_ALLOC) != 0
718 && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
719 && (h->root.type == bfd_link_hash_defweak
720 || (h->elf_link_hash_flags
721 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
723 /* We must copy these reloc types into the output file.
724 Create a reloc section in dynobj and make room for
727 htab->root.dynobj = dynobj = abfd;
732 name = (bfd_elf_string_from_elf_section
734 elf_elfheader (abfd)->e_shstrndx,
735 elf_section_data (sec)->rel_hdr.sh_name));
739 if (strncmp (name, ".rel", 4) != 0
740 || strcmp (bfd_get_section_name (abfd, sec),
743 if (abfd->my_archive)
744 (*_bfd_error_handler) (_("%s(%s): bad relocation section name `%s\'"),
745 bfd_get_filename (abfd->my_archive),
746 bfd_get_filename (abfd),
749 (*_bfd_error_handler) (_("%s: bad relocation section name `%s\'"),
750 bfd_get_filename (abfd),
754 sreloc = bfd_get_section_by_name (dynobj, name);
759 sreloc = bfd_make_section (dynobj, name);
760 flags = (SEC_HAS_CONTENTS | SEC_READONLY
761 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
762 if ((sec->flags & SEC_ALLOC) != 0)
763 flags |= SEC_ALLOC | SEC_LOAD;
765 || ! bfd_set_section_flags (dynobj, sreloc, flags)
766 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
771 sreloc->_raw_size += sizeof (Elf32_External_Rel);
773 /* If this is a global symbol, we count the number of PC
774 relative relocations we have entered for this symbol,
775 so that we can discard them later as necessary. Note
776 that this function is only called if we are using an
777 elf_i386 linker hash table, which means that h is
778 really a pointer to an elf_i386_link_hash_entry. */
781 && ELF32_R_TYPE (rel->r_info) == R_386_PC32))
783 struct elf_i386_link_hash_entry *eh;
784 struct elf_i386_dyn_relocs *p;
786 eh = (struct elf_i386_link_hash_entry *) h;
788 for (p = eh->dyn_relocs; p != NULL; p = p->next)
789 if (p->section == sreloc)
794 p = ((struct elf_i386_dyn_relocs *)
795 bfd_alloc (dynobj, sizeof *p));
798 p->next = eh->dyn_relocs;
810 /* This relocation describes the C++ object vtable hierarchy.
811 Reconstruct it for later use during GC. */
812 case R_386_GNU_VTINHERIT:
813 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
817 /* This relocation describes which C++ vtable entries are actually
818 used. Record for later use during GC. */
819 case R_386_GNU_VTENTRY:
820 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
832 /* Return the section that should be marked against GC for a given
836 elf_i386_gc_mark_hook (abfd, info, rel, h, sym)
838 struct bfd_link_info *info ATTRIBUTE_UNUSED;
839 Elf_Internal_Rela *rel;
840 struct elf_link_hash_entry *h;
841 Elf_Internal_Sym *sym;
845 switch (ELF32_R_TYPE (rel->r_info))
847 case R_386_GNU_VTINHERIT:
848 case R_386_GNU_VTENTRY:
852 switch (h->root.type)
854 case bfd_link_hash_defined:
855 case bfd_link_hash_defweak:
856 return h->root.u.def.section;
858 case bfd_link_hash_common:
859 return h->root.u.c.p->section;
868 if (!(elf_bad_symtab (abfd)
869 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
870 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
871 && sym->st_shndx != SHN_COMMON))
873 return bfd_section_from_elf_index (abfd, sym->st_shndx);
880 /* Update the got entry reference counts for the section being removed. */
883 elf_i386_gc_sweep_hook (abfd, info, sec, relocs)
885 struct bfd_link_info *info;
887 const Elf_Internal_Rela *relocs;
889 Elf_Internal_Shdr *symtab_hdr;
890 struct elf_link_hash_entry **sym_hashes;
891 bfd_signed_vma *local_got_refcounts;
892 const Elf_Internal_Rela *rel, *relend;
893 unsigned long r_symndx;
894 struct elf_link_hash_entry *h;
897 dynobj = elf_hash_table (info)->dynobj;
901 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
902 sym_hashes = elf_sym_hashes (abfd);
903 local_got_refcounts = elf_local_got_refcounts (abfd);
905 relend = relocs + sec->reloc_count;
906 for (rel = relocs; rel < relend; rel++)
907 switch (ELF32_R_TYPE (rel->r_info))
912 r_symndx = ELF32_R_SYM (rel->r_info);
913 if (r_symndx >= symtab_hdr->sh_info)
915 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
916 if (h->got.refcount > 0)
917 h->got.refcount -= 1;
919 else if (local_got_refcounts != NULL)
921 if (local_got_refcounts[r_symndx] > 0)
922 local_got_refcounts[r_symndx] -= 1;
933 r_symndx = ELF32_R_SYM (rel->r_info);
934 if (r_symndx >= symtab_hdr->sh_info)
936 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
937 if (h->plt.refcount > 0)
938 h->plt.refcount -= 1;
949 /* Adjust a symbol defined by a dynamic object and referenced by a
950 regular object. The current definition is in some section of the
951 dynamic object, but we're not including those sections. We have to
952 change the definition to something the rest of the link can
956 elf_i386_adjust_dynamic_symbol (info, h)
957 struct bfd_link_info *info;
958 struct elf_link_hash_entry *h;
960 struct elf_i386_link_hash_table *htab;
963 unsigned int power_of_two;
965 htab = elf_i386_hash_table (info);
966 dynobj = htab->root.dynobj;
968 /* If this is a function, put it in the procedure linkage table. We
969 will fill in the contents of the procedure linkage table later,
970 when we know the address of the .got section. */
971 if (h->type == STT_FUNC
972 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
974 if (h->plt.refcount <= 0
976 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
977 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0))
979 /* This case can occur if we saw a PLT32 reloc in an input
980 file, but the symbol was never referred to by a dynamic
981 object, or if all references were garbage collected. In
982 such a case, we don't actually need to build a procedure
983 linkage table, and we can just do a PC32 reloc instead. */
984 h->plt.refcount = (bfd_vma) -1;
985 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
989 /* Make sure this symbol is output as a dynamic symbol. */
990 if (h->dynindx == -1)
992 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
999 /* It's possible that we incorrectly decided a .plt reloc was
1000 needed for an R_386_PC32 reloc to a non-function sym in
1001 check_relocs. We can't decide accurately between function and
1002 non-function syms in check-relocs; Objects loaded later in
1003 the link may change h->type. So fix it now. */
1004 h->plt.refcount = (bfd_vma) -1;
1006 /* If this is a weak symbol, and there is a real definition, the
1007 processor independent code will have arranged for us to see the
1008 real definition first, and we can just use the same value. */
1009 if (h->weakdef != NULL)
1011 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1012 || h->weakdef->root.type == bfd_link_hash_defweak);
1013 h->root.u.def.section = h->weakdef->root.u.def.section;
1014 h->root.u.def.value = h->weakdef->root.u.def.value;
1018 /* This is a reference to a symbol defined by a dynamic object which
1019 is not a function. */
1021 /* If we are creating a shared library, we must presume that the
1022 only references to the symbol are via the global offset table.
1023 For such cases we need not do anything here; the relocations will
1024 be handled correctly by relocate_section. */
1028 /* If there are no references to this symbol that do not use the
1029 GOT, we don't need to generate a copy reloc. */
1030 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
1033 /* We must allocate the symbol in our .dynbss section, which will
1034 become part of the .bss section of the executable. There will be
1035 an entry for this symbol in the .dynsym section. The dynamic
1036 object will contain position independent code, so all references
1037 from the dynamic object to this symbol will go through the global
1038 offset table. The dynamic linker will use the .dynsym entry to
1039 determine the address it must put in the global offset table, so
1040 both the dynamic object and the regular object will refer to the
1041 same memory location for the variable. */
1047 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1048 copy the initial value out of the dynamic object and into the
1049 runtime process image. We need to remember the offset into the
1050 .rel.bss section we are going to use. */
1051 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1055 srel = htab->srelbss;
1058 srel->_raw_size += sizeof (Elf32_External_Rel);
1059 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1062 /* We need to figure out the alignment required for this symbol. I
1063 have no idea how ELF linkers handle this. */
1064 power_of_two = bfd_log2 (h->size);
1065 if (power_of_two > 3)
1068 /* Apply the required alignment. */
1069 s->_raw_size = BFD_ALIGN (s->_raw_size,
1070 (bfd_size_type) (1 << power_of_two));
1071 if (power_of_two > bfd_get_section_alignment (dynobj, s))
1073 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
1077 /* Define the symbol as being at this point in the section. */
1078 h->root.u.def.section = s;
1079 h->root.u.def.value = s->_raw_size;
1081 /* Increment the section size to make room for the symbol. */
1082 s->_raw_size += h->size;
1087 /* This is the condition under which elf_i386_finish_dynamic_symbol
1088 will be called from elflink.h. If elflink.h doesn't call our
1089 finish_dynamic_symbol routine, we'll need to do something about
1090 initializing any .plt and .got entries in elf_i386_relocate_section. */
1091 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1093 && ((INFO)->shared \
1094 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1095 && ((H)->dynindx != -1 \
1096 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1098 /* Allocate space in .plt, .got and associated reloc sections for
1099 global syms. Also discards space allocated for relocs in the
1100 check_relocs function that we subsequently have found to be
1104 allocate_plt_and_got_and_discard_relocs (h, inf)
1105 struct elf_link_hash_entry *h;
1108 struct bfd_link_info *info;
1109 struct elf_i386_link_hash_table *htab;
1112 if (h->root.type == bfd_link_hash_indirect
1113 || h->root.type == bfd_link_hash_warning)
1116 info = (struct bfd_link_info *) inf;
1117 htab = elf_i386_hash_table (info);
1119 if (htab->root.dynamic_sections_created
1120 && h->plt.refcount > 0)
1126 /* If this is the first .plt entry, make room for the special
1128 if (s->_raw_size == 0)
1129 s->_raw_size += PLT_ENTRY_SIZE;
1131 h->plt.offset = s->_raw_size;
1133 /* If this symbol is not defined in a regular file, and we are
1134 not generating a shared library, then set the symbol to this
1135 location in the .plt. This is required to make function
1136 pointers compare as equal between the normal executable and
1137 the shared library. */
1139 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1141 h->root.u.def.section = s;
1142 h->root.u.def.value = h->plt.offset;
1145 /* Make room for this entry. */
1146 s->_raw_size += PLT_ENTRY_SIZE;
1148 /* We also need to make an entry in the .got.plt section, which
1149 will be placed in the .got section by the linker script. */
1155 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
1157 /* We also need to make an entry in the .rel.plt section. */
1161 s->_raw_size += sizeof (Elf32_External_Rel);
1166 h->plt.offset = (bfd_vma) -1;
1167 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1170 if (h->got.refcount > 0)
1175 h->got.offset = s->_raw_size;
1177 dyn = htab->root.dynamic_sections_created;
1178 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
1179 htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1182 h->got.offset = (bfd_vma) -1;
1184 /* In the shared -Bsymbolic case, discard space allocated to copy
1185 PC relative relocs against symbols which turn out to be defined
1186 in regular objects. For the normal shared case, discard space
1187 for relocs that have become local due to symbol visibility
1188 changes. For the non-shared case, discard space for symbols
1189 which turn out to need copy relocs or are not dynamic. */
1192 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1193 && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1196 && (h->dynindx == -1
1197 || (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) != 0
1198 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0)))
1200 struct elf_i386_link_hash_entry *eh;
1201 struct elf_i386_dyn_relocs *c;
1203 eh = (struct elf_i386_link_hash_entry *) h;
1204 for (c = eh->dyn_relocs; c != NULL; c = c->next)
1205 c->section->_raw_size -= c->count * sizeof (Elf32_External_Rel);
1211 /* Set the sizes of the dynamic sections. */
1214 elf_i386_size_dynamic_sections (output_bfd, info)
1216 struct bfd_link_info *info;
1218 struct elf_i386_link_hash_table *htab;
1225 htab = elf_i386_hash_table (info);
1226 dynobj = htab->root.dynobj;
1230 if (htab->root.dynamic_sections_created)
1232 /* Set the contents of the .interp section to the interpreter. */
1235 s = bfd_get_section_by_name (dynobj, ".interp");
1238 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1239 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1243 /* Set up .got offsets for local syms. */
1244 for (i = info->input_bfds; i; i = i->link_next)
1246 bfd_signed_vma *local_got;
1247 bfd_signed_vma *end_local_got;
1248 bfd_size_type locsymcount;
1249 Elf_Internal_Shdr *symtab_hdr;
1252 if (bfd_get_flavour (i) != bfd_target_elf_flavour)
1255 local_got = elf_local_got_refcounts (i);
1259 symtab_hdr = &elf_tdata (i)->symtab_hdr;
1260 locsymcount = symtab_hdr->sh_info;
1261 end_local_got = local_got + locsymcount;
1263 srel = htab->srelgot;
1264 for (; local_got < end_local_got; ++local_got)
1268 *local_got = s->_raw_size;
1271 srel->_raw_size += sizeof (Elf32_External_Rel);
1274 *local_got = (bfd_vma) -1;
1278 /* Allocate global sym .plt and .got entries. Also discard all
1280 elf_link_hash_traverse (&htab->root,
1281 allocate_plt_and_got_and_discard_relocs,
1284 /* The check_relocs and adjust_dynamic_symbol entry points have
1285 determined the sizes of the various dynamic sections. Allocate
1289 for (s = dynobj->sections; s != NULL; s = s->next)
1291 if ((s->flags & SEC_LINKER_CREATED) == 0)
1296 || s == htab->sgotplt)
1298 /* Strip this section if we don't need it; see the
1301 else if (strncmp (bfd_get_section_name (dynobj, s), ".rel", 4) == 0)
1303 if (s->_raw_size == 0)
1305 /* If we don't need this section, strip it from the
1306 output file. This is mostly to handle .rel.bss and
1307 .rel.plt. We must create both sections in
1308 create_dynamic_sections, because they must be created
1309 before the linker maps input sections to output
1310 sections. The linker does that before
1311 adjust_dynamic_symbol is called, and it is that
1312 function which decides whether anything needs to go
1313 into these sections. */
1319 /* Remember whether there are any reloc sections other
1321 if (s != htab->srelplt)
1323 const char *outname;
1327 /* If this relocation section applies to a read only
1328 section, then we probably need a DT_TEXTREL
1329 entry. The entries in the .rel.plt section
1330 really apply to the .got section, which we
1331 created ourselves and so know is not readonly. */
1332 outname = bfd_get_section_name (output_bfd,
1334 target = bfd_get_section_by_name (output_bfd, outname + 4);
1336 && (target->flags & SEC_READONLY) != 0
1337 && (target->flags & SEC_ALLOC) != 0)
1341 /* We use the reloc_count field as a counter if we need
1342 to copy relocs into the output file. */
1348 /* It's not one of our sections, so don't allocate space. */
1352 if (s->_raw_size == 0)
1354 _bfd_strip_section_from_output (info, s);
1358 /* Allocate memory for the section contents. We use bfd_zalloc
1359 here in case unused entries are not reclaimed before the
1360 section's contents are written out. This should not happen,
1361 but this way if it does, we get a R_386_NONE reloc instead
1363 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1364 if (s->contents == NULL)
1368 if (htab->root.dynamic_sections_created)
1370 /* Add some entries to the .dynamic section. We fill in the
1371 values later, in elf_i386_finish_dynamic_sections, but we
1372 must add the entries now so that we get the correct size for
1373 the .dynamic section. The DT_DEBUG entry is filled in by the
1374 dynamic linker and used by the debugger. */
1377 if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
1381 if (htab->splt->_raw_size != 0)
1383 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
1384 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
1385 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL)
1386 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
1392 if (! bfd_elf32_add_dynamic_entry (info, DT_REL, 0)
1393 || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0)
1394 || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
1395 sizeof (Elf32_External_Rel)))
1401 if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
1403 info->flags |= DF_TEXTREL;
1410 /* Relocate an i386 ELF section. */
1413 elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
1414 contents, relocs, local_syms, local_sections)
1416 struct bfd_link_info *info;
1418 asection *input_section;
1420 Elf_Internal_Rela *relocs;
1421 Elf_Internal_Sym *local_syms;
1422 asection **local_sections;
1424 struct elf_i386_link_hash_table *htab;
1426 Elf_Internal_Shdr *symtab_hdr;
1427 struct elf_link_hash_entry **sym_hashes;
1428 bfd_vma *local_got_offsets;
1430 Elf_Internal_Rela *rel;
1431 Elf_Internal_Rela *relend;
1433 htab = elf_i386_hash_table (info);
1434 dynobj = htab->root.dynobj;
1435 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1436 sym_hashes = elf_sym_hashes (input_bfd);
1437 local_got_offsets = elf_local_got_offsets (input_bfd);
1441 relend = relocs + input_section->reloc_count;
1442 for (; rel < relend; rel++)
1445 reloc_howto_type *howto;
1446 unsigned long r_symndx;
1447 struct elf_link_hash_entry *h;
1448 Elf_Internal_Sym *sym;
1452 boolean unresolved_reloc;
1453 bfd_reloc_status_type r;
1456 r_type = ELF32_R_TYPE (rel->r_info);
1457 if (r_type == (int) R_386_GNU_VTINHERIT
1458 || r_type == (int) R_386_GNU_VTENTRY)
1461 if ((indx = (unsigned) r_type) >= R_386_standard
1462 && ((indx = (unsigned) r_type - R_386_ext_offset) - R_386_standard
1463 >= R_386_ext - R_386_standard))
1465 bfd_set_error (bfd_error_bad_value);
1468 howto = elf_howto_table + indx;
1470 r_symndx = ELF32_R_SYM (rel->r_info);
1472 if (info->relocateable)
1474 /* This is a relocateable link. We don't have to change
1475 anything, unless the reloc is against a section symbol,
1476 in which case we have to adjust according to where the
1477 section symbol winds up in the output section. */
1478 if (r_symndx < symtab_hdr->sh_info)
1480 sym = local_syms + r_symndx;
1481 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1485 sec = local_sections[r_symndx];
1486 val = bfd_get_32 (input_bfd, contents + rel->r_offset);
1487 val += sec->output_offset + sym->st_value;
1488 bfd_put_32 (input_bfd, val, contents + rel->r_offset);
1495 /* This is a final link. */
1499 unresolved_reloc = false;
1500 if (r_symndx < symtab_hdr->sh_info)
1502 sym = local_syms + r_symndx;
1503 sec = local_sections[r_symndx];
1504 relocation = (sec->output_section->vma
1505 + sec->output_offset
1510 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1511 while (h->root.type == bfd_link_hash_indirect
1512 || h->root.type == bfd_link_hash_warning)
1513 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1516 if (h->root.type == bfd_link_hash_defined
1517 || h->root.type == bfd_link_hash_defweak)
1519 sec = h->root.u.def.section;
1520 if (sec->output_section == NULL)
1521 /* Set a flag that will be cleared later if we find a
1522 relocation value for this symbol. output_section
1523 is typically NULL for symbols satisfied by a shared
1525 unresolved_reloc = true;
1527 relocation = (h->root.u.def.value
1528 + sec->output_section->vma
1529 + sec->output_offset);
1531 else if (h->root.type == bfd_link_hash_undefweak)
1533 else if (info->shared && !info->symbolic
1534 && !info->no_undefined
1535 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1539 if (! ((*info->callbacks->undefined_symbol)
1540 (info, h->root.root.string, input_bfd,
1541 input_section, rel->r_offset,
1542 (!info->shared || info->no_undefined
1543 || ELF_ST_VISIBILITY (h->other)))))
1551 /* Relocation is to the entry for this symbol in the global
1553 if (htab->sgot == NULL)
1560 off = h->got.offset;
1561 dyn = htab->root.dynamic_sections_created;
1562 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
1566 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
1567 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1569 /* This is actually a static link, or it is a
1570 -Bsymbolic link and the symbol is defined
1571 locally, or the symbol was forced to be local
1572 because of a version file. We must initialize
1573 this entry in the global offset table. Since the
1574 offset must always be a multiple of 4, we use the
1575 least significant bit to record whether we have
1576 initialized it already.
1578 When doing a dynamic link, we create a .rel.got
1579 relocation entry to initialize the value. This
1580 is done in the finish_dynamic_symbol routine. */
1585 bfd_put_32 (output_bfd, relocation,
1586 htab->sgot->contents + off);
1591 unresolved_reloc = false;
1595 if (local_got_offsets == NULL)
1598 off = local_got_offsets[r_symndx];
1600 /* The offset must always be a multiple of 4. We use
1601 the least significant bit to record whether we have
1602 already generated the necessary reloc. */
1607 bfd_put_32 (output_bfd, relocation,
1608 htab->sgot->contents + off);
1613 Elf_Internal_Rel outrel;
1615 srelgot = htab->srelgot;
1616 if (srelgot == NULL)
1619 outrel.r_offset = (htab->sgot->output_section->vma
1620 + htab->sgot->output_offset
1622 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1623 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1624 (((Elf32_External_Rel *)
1626 + srelgot->reloc_count));
1627 ++srelgot->reloc_count;
1630 local_got_offsets[r_symndx] |= 1;
1634 if (off >= (bfd_vma) -2)
1637 relocation = htab->sgot->output_offset + off;
1641 /* Relocation is relative to the start of the global offset
1644 /* Note that sgot->output_offset is not involved in this
1645 calculation. We always want the start of .got. If we
1646 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1647 permitted by the ABI, we might have to change this
1649 relocation -= htab->sgot->output_section->vma;
1653 /* Use global offset table as symbol value. */
1654 relocation = htab->sgot->output_section->vma;
1655 unresolved_reloc = false;
1659 /* Relocation is to the entry for this symbol in the
1660 procedure linkage table. */
1662 /* Resolve a PLT32 reloc against a local symbol directly,
1663 without using the procedure linkage table. */
1667 if (h->plt.offset == (bfd_vma) -1
1668 || htab->splt == NULL)
1670 /* We didn't make a PLT entry for this symbol. This
1671 happens when statically linking PIC code, or when
1672 using -Bsymbolic. */
1676 relocation = (htab->splt->output_section->vma
1677 + htab->splt->output_offset
1679 unresolved_reloc = false;
1685 && (input_section->flags & SEC_ALLOC) != 0
1686 && (r_type != R_386_PC32
1689 && (! info->symbolic
1690 || (h->elf_link_hash_flags
1691 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1693 && (input_section->flags & SEC_ALLOC) != 0
1696 && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1697 && (h->elf_link_hash_flags
1698 & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
1700 Elf_Internal_Rel outrel;
1701 boolean skip, relocate;
1703 /* When generating a shared object, these relocations
1704 are copied into the output file to be resolved at run
1711 name = (bfd_elf_string_from_elf_section
1713 elf_elfheader (input_bfd)->e_shstrndx,
1714 elf_section_data (input_section)->rel_hdr.sh_name));
1718 if (strncmp (name, ".rel", 4) != 0
1719 || strcmp (bfd_get_section_name (input_bfd,
1723 if (input_bfd->my_archive)
1724 (*_bfd_error_handler)\
1725 (_("%s(%s): bad relocation section name `%s\'"),
1726 bfd_get_filename (input_bfd->my_archive),
1727 bfd_get_filename (input_bfd),
1730 (*_bfd_error_handler)
1731 (_("%s: bad relocation section name `%s\'"),
1732 bfd_get_filename (input_bfd),
1737 sreloc = bfd_get_section_by_name (dynobj, name);
1744 if (elf_section_data (input_section)->stab_info == NULL)
1745 outrel.r_offset = rel->r_offset;
1750 off = (_bfd_stab_section_offset
1751 (output_bfd, htab->root.stab_info, input_section,
1752 &elf_section_data (input_section)->stab_info,
1754 if (off == (bfd_vma) -1)
1756 outrel.r_offset = off;
1759 outrel.r_offset += (input_section->output_section->vma
1760 + input_section->output_offset);
1764 memset (&outrel, 0, sizeof outrel);
1767 else if (r_type == R_386_PC32)
1769 BFD_ASSERT (h != NULL && h->dynindx != -1);
1771 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_PC32);
1775 /* h->dynindx may be -1 if this symbol was marked to
1779 && (info->symbolic || h->dynindx == -1)
1780 && (h->elf_link_hash_flags
1781 & ELF_LINK_HASH_DEF_REGULAR) != 0))
1784 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1788 BFD_ASSERT (h->dynindx != -1);
1790 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_32);
1794 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1795 (((Elf32_External_Rel *)
1797 + sreloc->reloc_count));
1798 ++sreloc->reloc_count;
1800 /* If this reloc is against an external symbol, we do
1801 not want to fiddle with the addend. Otherwise, we
1802 need to include the symbol value so that it becomes
1803 an addend for the dynamic reloc. */
1814 /* FIXME: Why do we allow debugging sections to escape this error?
1815 More importantly, why do we not emit dynamic relocs for
1816 R_386_32 above in debugging sections (which are ! SEC_ALLOC)?
1817 If we had emitted the dynamic reloc, we could remove the
1819 if (unresolved_reloc
1821 && (input_section->flags & SEC_DEBUGGING) != 0
1822 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
1823 (*_bfd_error_handler)
1824 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
1825 bfd_get_filename (input_bfd),
1826 bfd_get_section_name (input_bfd, input_section),
1827 (long) rel->r_offset,
1828 h->root.root.string);
1830 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1831 contents, rel->r_offset,
1832 relocation, (bfd_vma) 0);
1839 case bfd_reloc_overflow:
1844 name = h->root.root.string;
1847 name = bfd_elf_string_from_elf_section (input_bfd,
1848 symtab_hdr->sh_link,
1853 name = bfd_section_name (input_bfd, sec);
1855 if (! ((*info->callbacks->reloc_overflow)
1856 (info, name, howto->name, (bfd_vma) 0,
1857 input_bfd, input_section, rel->r_offset)))
1863 case bfd_reloc_outofrange:
1872 /* Finish up dynamic symbol handling. We set the contents of various
1873 dynamic sections here. */
1876 elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
1878 struct bfd_link_info *info;
1879 struct elf_link_hash_entry *h;
1880 Elf_Internal_Sym *sym;
1882 struct elf_i386_link_hash_table *htab;
1885 htab = elf_i386_hash_table (info);
1886 dynobj = htab->root.dynobj;
1888 if (h->plt.offset != (bfd_vma) -1)
1892 Elf_Internal_Rel rel;
1894 /* This symbol has an entry in the procedure linkage table. Set
1897 if (h->dynindx == -1
1898 || htab->splt == NULL
1899 || htab->sgotplt == NULL
1900 || htab->srelplt == NULL)
1903 /* Get the index in the procedure linkage table which
1904 corresponds to this symbol. This is the index of this symbol
1905 in all the symbols for which we are making plt entries. The
1906 first entry in the procedure linkage table is reserved. */
1907 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1909 /* Get the offset into the .got table of the entry that
1910 corresponds to this function. Each .got entry is 4 bytes.
1911 The first three are reserved. */
1912 got_offset = (plt_index + 3) * 4;
1914 /* Fill in the entry in the procedure linkage table. */
1917 memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
1919 bfd_put_32 (output_bfd,
1920 (htab->sgotplt->output_section->vma
1921 + htab->sgotplt->output_offset
1923 htab->splt->contents + h->plt.offset + 2);
1927 memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
1929 bfd_put_32 (output_bfd, got_offset,
1930 htab->splt->contents + h->plt.offset + 2);
1933 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
1934 htab->splt->contents + h->plt.offset + 7);
1935 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
1936 htab->splt->contents + h->plt.offset + 12);
1938 /* Fill in the entry in the global offset table. */
1939 bfd_put_32 (output_bfd,
1940 (htab->splt->output_section->vma
1941 + htab->splt->output_offset
1944 htab->sgotplt->contents + got_offset);
1946 /* Fill in the entry in the .rel.plt section. */
1947 rel.r_offset = (htab->sgotplt->output_section->vma
1948 + htab->sgotplt->output_offset
1950 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
1951 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1952 ((Elf32_External_Rel *) htab->srelplt->contents
1955 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1957 /* Mark the symbol as undefined, rather than as defined in
1958 the .plt section. Leave the value alone. */
1959 sym->st_shndx = SHN_UNDEF;
1963 if (h->got.offset != (bfd_vma) -1)
1965 Elf_Internal_Rel rel;
1967 /* This symbol has an entry in the global offset table. Set it
1970 if (htab->sgot == NULL || htab->srelgot == NULL)
1973 rel.r_offset = (htab->sgot->output_section->vma
1974 + htab->sgot->output_offset
1975 + (h->got.offset &~ 1));
1977 /* If this is a static link, or it is a -Bsymbolic link and the
1978 symbol is defined locally or was forced to be local because
1979 of a version file, we just want to emit a RELATIVE reloc.
1980 The entry in the global offset table will already have been
1981 initialized in the relocate_section function. */
1985 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
1986 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
1988 BFD_ASSERT((h->got.offset & 1) != 0);
1989 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1993 BFD_ASSERT((h->got.offset & 1) == 0);
1994 bfd_put_32 (output_bfd, (bfd_vma) 0,
1995 htab->sgot->contents + h->got.offset);
1996 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
1999 bfd_elf32_swap_reloc_out (output_bfd, &rel,
2000 ((Elf32_External_Rel *) htab->srelgot->contents
2001 + htab->srelgot->reloc_count));
2002 ++htab->srelgot->reloc_count;
2005 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2007 Elf_Internal_Rel rel;
2009 /* This symbol needs a copy reloc. Set it up. */
2011 if (h->dynindx == -1
2012 || (h->root.type != bfd_link_hash_defined
2013 && h->root.type != bfd_link_hash_defweak)
2014 || htab->srelbss == NULL)
2017 rel.r_offset = (h->root.u.def.value
2018 + h->root.u.def.section->output_section->vma
2019 + h->root.u.def.section->output_offset);
2020 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
2021 bfd_elf32_swap_reloc_out (output_bfd, &rel,
2022 ((Elf32_External_Rel *) htab->srelbss->contents
2023 + htab->srelbss->reloc_count));
2024 ++htab->srelbss->reloc_count;
2027 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2028 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2029 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2030 sym->st_shndx = SHN_ABS;
2035 /* Finish up the dynamic sections. */
2038 elf_i386_finish_dynamic_sections (output_bfd, info)
2040 struct bfd_link_info *info;
2042 struct elf_i386_link_hash_table *htab;
2046 htab = elf_i386_hash_table (info);
2047 dynobj = htab->root.dynobj;
2048 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2050 if (htab->root.dynamic_sections_created)
2052 Elf32_External_Dyn *dyncon, *dynconend;
2054 if (sdyn == NULL || htab->sgot == NULL)
2057 dyncon = (Elf32_External_Dyn *) sdyn->contents;
2058 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2059 for (; dyncon < dynconend; dyncon++)
2061 Elf_Internal_Dyn dyn;
2063 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2071 dyn.d_un.d_ptr = htab->sgot->output_section->vma;
2072 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2076 dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
2077 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2081 if (htab->srelplt->output_section->_cooked_size != 0)
2082 dyn.d_un.d_val = htab->srelplt->output_section->_cooked_size;
2084 dyn.d_un.d_val = htab->srelplt->output_section->_raw_size;
2085 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2089 /* My reading of the SVR4 ABI indicates that the
2090 procedure linkage table relocs (DT_JMPREL) should be
2091 included in the overall relocs (DT_REL). This is
2092 what Solaris does. However, UnixWare can not handle
2093 that case. Therefore, we override the DT_RELSZ entry
2094 here to make it not include the JMPREL relocs. Since
2095 the linker script arranges for .rel.plt to follow all
2096 other relocation sections, we don't have to worry
2097 about changing the DT_REL entry. */
2098 if (htab->srelplt != NULL)
2100 if (htab->srelplt->output_section->_cooked_size != 0)
2101 dyn.d_un.d_val -= htab->srelplt->output_section->_cooked_size;
2103 dyn.d_un.d_val -= htab->srelplt->output_section->_raw_size;
2105 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2110 /* Fill in the first entry in the procedure linkage table. */
2111 if (htab->splt && htab->splt->_raw_size > 0)
2114 memcpy (htab->splt->contents,
2115 elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
2118 memcpy (htab->splt->contents,
2119 elf_i386_plt0_entry, PLT_ENTRY_SIZE);
2120 bfd_put_32 (output_bfd,
2121 (htab->sgotplt->output_section->vma
2122 + htab->sgotplt->output_offset
2124 htab->splt->contents + 2);
2125 bfd_put_32 (output_bfd,
2126 (htab->sgotplt->output_section->vma
2127 + htab->sgotplt->output_offset
2129 htab->splt->contents + 8);
2132 /* UnixWare sets the entsize of .plt to 4, although that doesn't
2133 really seem like the right value. */
2134 elf_section_data (htab->splt->output_section)
2135 ->this_hdr.sh_entsize = 4;
2141 /* Fill in the first three entries in the global offset table. */
2142 if (htab->sgotplt->_raw_size > 0)
2144 bfd_put_32 (output_bfd,
2145 (sdyn == NULL ? (bfd_vma) 0
2146 : sdyn->output_section->vma + sdyn->output_offset),
2147 htab->sgotplt->contents);
2148 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 4);
2149 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8);
2152 elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
2157 /* Set the correct type for an x86 ELF section. We do this by the
2158 section name, which is a hack, but ought to work. */
2161 elf_i386_fake_sections (abfd, hdr, sec)
2162 bfd *abfd ATTRIBUTE_UNUSED;
2163 Elf32_Internal_Shdr *hdr;
2166 register const char *name;
2168 name = bfd_get_section_name (abfd, sec);
2170 if (strcmp (name, ".reloc") == 0)
2172 * This is an ugly, but unfortunately necessary hack that is
2173 * needed when producing EFI binaries on x86. It tells
2174 * elf.c:elf_fake_sections() not to consider ".reloc" as a section
2175 * containing ELF relocation info. We need this hack in order to
2176 * be able to generate ELF binaries that can be translated into
2177 * EFI applications (which are essentially COFF objects). Those
2178 * files contain a COFF ".reloc" section inside an ELFNN object,
2179 * which would normally cause BFD to segfault because it would
2180 * attempt to interpret this section as containing relocation
2181 * entries for section "oc". With this hack enabled, ".reloc"
2182 * will be treated as a normal data section, which will avoid the
2183 * segfault. However, you won't be able to create an ELFNN binary
2184 * with a section named "oc" that needs relocations, but that's
2185 * the kind of ugly side-effects you get when detecting section
2186 * types based on their names... In practice, this limitation is
2189 hdr->sh_type = SHT_PROGBITS;
2195 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
2196 #define TARGET_LITTLE_NAME "elf32-i386"
2197 #define ELF_ARCH bfd_arch_i386
2198 #define ELF_MACHINE_CODE EM_386
2199 #define ELF_MAXPAGESIZE 0x1000
2201 #define elf_backend_can_gc_sections 1
2202 #define elf_backend_want_got_plt 1
2203 #define elf_backend_plt_readonly 1
2204 #define elf_backend_want_plt_sym 0
2205 #define elf_backend_got_header_size 12
2206 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
2208 #define elf_info_to_howto elf_i386_info_to_howto
2209 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
2211 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
2212 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
2213 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
2215 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
2216 #define elf_backend_check_relocs elf_i386_check_relocs
2217 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
2218 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
2219 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
2220 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
2221 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
2222 #define elf_backend_relocate_section elf_i386_relocate_section
2223 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
2224 #define elf_backend_fake_sections elf_i386_fake_sections
2226 #include "elf32-target.h"