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 in check_relocs for each symbol. This is so that
361 it can discard PC relative relocs if it doesn't need them when
362 linking with -Bsymbolic. We store the information in a field
363 extending the regular ELF linker hash table. */
365 /* This structure keeps track of the number of PC relative relocs we
366 have copied for a given symbol. */
368 struct elf_i386_pcrel_relocs_copied
371 struct elf_i386_pcrel_relocs_copied
*next
;
372 /* A section in dynobj. */
374 /* Number of relocs copied in this section. */
378 /* i386 ELF linker hash entry. */
380 struct elf_i386_link_hash_entry
382 struct elf_link_hash_entry root
;
384 /* Number of PC relative relocs copied for this symbol. */
385 struct elf_i386_pcrel_relocs_copied
*pcrel_relocs_copied
;
388 /* i386 ELF linker hash table. */
390 struct elf_i386_link_hash_table
392 struct elf_link_hash_table root
;
394 /* Short-cuts to get to dynamic linker sections. */
404 /* Get the i386 ELF linker hash table from a link_info structure. */
406 #define elf_i386_hash_table(p) \
407 ((struct elf_i386_link_hash_table *) ((p)->hash))
409 /* Create an entry in an i386 ELF linker hash table. */
411 static struct bfd_hash_entry
*
412 elf_i386_link_hash_newfunc (entry
, table
, string
)
413 struct bfd_hash_entry
*entry
;
414 struct bfd_hash_table
*table
;
417 struct elf_i386_link_hash_entry
*ret
=
418 (struct elf_i386_link_hash_entry
*) entry
;
420 /* Allocate the structure if it has not already been allocated by a
422 if (ret
== (struct elf_i386_link_hash_entry
*) NULL
)
423 ret
= ((struct elf_i386_link_hash_entry
*)
424 bfd_hash_allocate (table
,
425 sizeof (struct elf_i386_link_hash_entry
)));
426 if (ret
== (struct elf_i386_link_hash_entry
*) NULL
)
427 return (struct bfd_hash_entry
*) ret
;
429 /* Call the allocation method of the superclass. */
430 ret
= ((struct elf_i386_link_hash_entry
*)
431 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
433 if (ret
!= (struct elf_i386_link_hash_entry
*) NULL
)
435 ret
->pcrel_relocs_copied
= NULL
;
438 return (struct bfd_hash_entry
*) ret
;
441 /* Create an i386 ELF linker hash table. */
443 static struct bfd_link_hash_table
*
444 elf_i386_link_hash_table_create (abfd
)
447 struct elf_i386_link_hash_table
*ret
;
449 ret
= ((struct elf_i386_link_hash_table
*)
450 bfd_alloc (abfd
, sizeof (struct elf_i386_link_hash_table
)));
451 if (ret
== (struct elf_i386_link_hash_table
*) NULL
)
454 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
455 elf_i386_link_hash_newfunc
))
457 bfd_release (abfd
, ret
);
469 return &ret
->root
.root
;
472 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
473 shortcuts to them in our hash table. */
476 create_got_section (dynobj
, info
)
478 struct bfd_link_info
*info
;
480 struct elf_i386_link_hash_table
*htab
;
482 if (! _bfd_elf_create_got_section (dynobj
, info
))
485 htab
= elf_i386_hash_table (info
);
486 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
487 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
488 if (!htab
->sgot
|| !htab
->sgotplt
)
491 htab
->srelgot
= bfd_make_section (dynobj
, ".rel.got");
492 if (htab
->srelgot
== NULL
493 || ! bfd_set_section_flags (dynobj
, htab
->srelgot
,
494 (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
495 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
497 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
502 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
503 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
507 elf_i386_create_dynamic_sections (dynobj
, info
)
509 struct bfd_link_info
*info
;
511 struct elf_i386_link_hash_table
*htab
;
513 htab
= elf_i386_hash_table (info
);
514 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
517 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
520 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
521 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rel.plt");
522 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
524 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rel.bss");
526 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
527 || (!info
->shared
&& !htab
->srelbss
))
533 /* Look through the relocs for a section during the first phase, and
534 allocate space in the global offset table or procedure linkage
538 elf_i386_check_relocs (abfd
, info
, sec
, relocs
)
540 struct bfd_link_info
*info
;
542 const Elf_Internal_Rela
*relocs
;
544 struct elf_i386_link_hash_table
*htab
;
546 Elf_Internal_Shdr
*symtab_hdr
;
547 struct elf_link_hash_entry
**sym_hashes
;
548 bfd_signed_vma
*local_got_refcounts
;
549 const Elf_Internal_Rela
*rel
;
550 const Elf_Internal_Rela
*rel_end
;
553 if (info
->relocateable
)
556 htab
= elf_i386_hash_table (info
);
557 dynobj
= htab
->root
.dynobj
;
558 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
559 sym_hashes
= elf_sym_hashes (abfd
);
560 local_got_refcounts
= elf_local_got_refcounts (abfd
);
564 rel_end
= relocs
+ sec
->reloc_count
;
565 for (rel
= relocs
; rel
< rel_end
; rel
++)
567 unsigned long r_symndx
;
568 struct elf_link_hash_entry
*h
;
570 r_symndx
= ELF32_R_SYM (rel
->r_info
);
572 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
574 if (abfd
->my_archive
)
575 (*_bfd_error_handler
) (_("%s(%s): bad symbol index: %d"),
576 bfd_get_filename (abfd
->my_archive
),
577 bfd_get_filename (abfd
),
580 (*_bfd_error_handler
) (_("%s: bad symbol index: %d"),
581 bfd_get_filename (abfd
),
586 if (r_symndx
< symtab_hdr
->sh_info
)
589 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
591 /* Some relocs require a global offset table. */
592 if (htab
->sgot
== NULL
)
594 switch (ELF32_R_TYPE (rel
->r_info
))
600 htab
->root
.dynobj
= dynobj
= abfd
;
601 if (!create_got_section (dynobj
, info
))
610 switch (ELF32_R_TYPE (rel
->r_info
))
613 /* This symbol requires a global offset table entry. */
616 if (h
->got
.refcount
== -1)
618 /* Make sure this symbol is output as a dynamic symbol. */
619 if (h
->dynindx
== -1)
621 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
627 h
->got
.refcount
+= 1;
631 /* This is a global offset table entry for a local symbol. */
632 if (local_got_refcounts
== NULL
)
636 size
= symtab_hdr
->sh_info
* sizeof (bfd_signed_vma
);
637 local_got_refcounts
= ((bfd_signed_vma
*)
638 bfd_alloc (abfd
, size
));
639 if (local_got_refcounts
== NULL
)
641 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
642 memset (local_got_refcounts
, -1, size
);
644 if (local_got_refcounts
[r_symndx
] == -1)
645 local_got_refcounts
[r_symndx
] = 1;
647 local_got_refcounts
[r_symndx
] += 1;
652 /* This symbol requires a procedure linkage table entry. We
653 actually build the entry in adjust_dynamic_symbol,
654 because this might be a case of linking PIC code which is
655 never referenced by a dynamic object, in which case we
656 don't need to generate a procedure linkage table entry
659 /* If this is a local symbol, we resolve it directly without
660 creating a procedure linkage table entry. */
664 if (h
->plt
.refcount
== -1)
666 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
670 h
->plt
.refcount
+= 1;
675 if (h
!= NULL
&& !info
->shared
)
677 /* If this reloc is in a read-only section, we might
678 need a copy reloc. */
679 if ((sec
->flags
& SEC_READONLY
) != 0)
680 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
682 /* We may need a .plt entry if the function this reloc
683 refers to is in a shared lib. */
684 if (h
->plt
.refcount
== -1)
687 h
->plt
.refcount
+= 1;
690 /* If we are creating a shared library, and this is a reloc
691 against a global symbol, or a non PC relative reloc
692 against a local symbol, then we need to copy the reloc
693 into the shared library. However, if we are linking with
694 -Bsymbolic, we do not need to copy a reloc against a
695 global symbol which is defined in an object we are
696 including in the link (i.e., DEF_REGULAR is set). At
697 this point we have not seen all the input files, so it is
698 possible that DEF_REGULAR is not set now but will be set
699 later (it is never cleared). In case of a weak definition,
700 DEF_REGULAR may be cleared later by a strong definition in
701 a shared library. We account for that possibility below by
702 storing information in the relocs_copied field of the hash
703 table entry. A similar situation occurs when creating
704 shared libraries and symbol visibility changes render the
706 If on the other hand, we are creating an executable, we
707 may need to keep relocations for symbols satisfied by a
708 dynamic library if we manage to avoid copy relocs for the
711 && (sec
->flags
& SEC_ALLOC
) != 0
712 && (ELF32_R_TYPE (rel
->r_info
) != R_386_PC32
715 || h
->root
.type
== bfd_link_hash_defweak
716 || (h
->elf_link_hash_flags
717 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
719 && (sec
->flags
& SEC_ALLOC
) != 0
721 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
722 && (h
->root
.type
== bfd_link_hash_defweak
723 || (h
->elf_link_hash_flags
724 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
726 /* We must copy these reloc types into the output file.
727 Create a reloc section in dynobj and make room for
730 htab
->root
.dynobj
= dynobj
= abfd
;
735 name
= (bfd_elf_string_from_elf_section
737 elf_elfheader (abfd
)->e_shstrndx
,
738 elf_section_data (sec
)->rel_hdr
.sh_name
));
742 if (strncmp (name
, ".rel", 4) != 0
743 || strcmp (bfd_get_section_name (abfd
, sec
),
746 if (abfd
->my_archive
)
747 (*_bfd_error_handler
) (_("%s(%s): bad relocation section name `%s\'"),
748 bfd_get_filename (abfd
->my_archive
),
749 bfd_get_filename (abfd
),
752 (*_bfd_error_handler
) (_("%s: bad relocation section name `%s\'"),
753 bfd_get_filename (abfd
),
757 sreloc
= bfd_get_section_by_name (dynobj
, name
);
762 sreloc
= bfd_make_section (dynobj
, name
);
763 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
764 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
765 if ((sec
->flags
& SEC_ALLOC
) != 0)
766 flags
|= SEC_ALLOC
| SEC_LOAD
;
768 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
769 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
774 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
776 /* If this is a global symbol, we count the number of PC
777 relative relocations we have entered for this symbol,
778 so that we can discard them later as necessary. Note
779 that this function is only called if we are using an
780 elf_i386 linker hash table, which means that h is
781 really a pointer to an elf_i386_link_hash_entry. */
784 && ELF32_R_TYPE (rel
->r_info
) == R_386_PC32
))
786 struct elf_i386_link_hash_entry
*eh
;
787 struct elf_i386_pcrel_relocs_copied
*p
;
789 eh
= (struct elf_i386_link_hash_entry
*) h
;
791 for (p
= eh
->pcrel_relocs_copied
; p
!= NULL
; p
= p
->next
)
792 if (p
->section
== sreloc
)
797 p
= ((struct elf_i386_pcrel_relocs_copied
*)
798 bfd_alloc (dynobj
, sizeof *p
));
801 p
->next
= eh
->pcrel_relocs_copied
;
802 eh
->pcrel_relocs_copied
= p
;
813 /* This relocation describes the C++ object vtable hierarchy.
814 Reconstruct it for later use during GC. */
815 case R_386_GNU_VTINHERIT
:
816 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
820 /* This relocation describes which C++ vtable entries are actually
821 used. Record for later use during GC. */
822 case R_386_GNU_VTENTRY
:
823 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
835 /* Return the section that should be marked against GC for a given
839 elf_i386_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
841 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
842 Elf_Internal_Rela
*rel
;
843 struct elf_link_hash_entry
*h
;
844 Elf_Internal_Sym
*sym
;
848 switch (ELF32_R_TYPE (rel
->r_info
))
850 case R_386_GNU_VTINHERIT
:
851 case R_386_GNU_VTENTRY
:
855 switch (h
->root
.type
)
857 case bfd_link_hash_defined
:
858 case bfd_link_hash_defweak
:
859 return h
->root
.u
.def
.section
;
861 case bfd_link_hash_common
:
862 return h
->root
.u
.c
.p
->section
;
871 if (!(elf_bad_symtab (abfd
)
872 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
873 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
874 && sym
->st_shndx
!= SHN_COMMON
))
876 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
883 /* Update the got entry reference counts for the section being removed. */
886 elf_i386_gc_sweep_hook (abfd
, info
, sec
, relocs
)
888 struct bfd_link_info
*info
;
890 const Elf_Internal_Rela
*relocs
;
892 Elf_Internal_Shdr
*symtab_hdr
;
893 struct elf_link_hash_entry
**sym_hashes
;
894 bfd_signed_vma
*local_got_refcounts
;
895 const Elf_Internal_Rela
*rel
, *relend
;
896 unsigned long r_symndx
;
897 struct elf_link_hash_entry
*h
;
900 dynobj
= elf_hash_table (info
)->dynobj
;
904 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
905 sym_hashes
= elf_sym_hashes (abfd
);
906 local_got_refcounts
= elf_local_got_refcounts (abfd
);
908 relend
= relocs
+ sec
->reloc_count
;
909 for (rel
= relocs
; rel
< relend
; rel
++)
910 switch (ELF32_R_TYPE (rel
->r_info
))
915 r_symndx
= ELF32_R_SYM (rel
->r_info
);
916 if (r_symndx
>= symtab_hdr
->sh_info
)
918 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
919 if (h
->got
.refcount
> 0)
920 h
->got
.refcount
-= 1;
922 else if (local_got_refcounts
!= NULL
)
924 if (local_got_refcounts
[r_symndx
] > 0)
925 local_got_refcounts
[r_symndx
] -= 1;
936 r_symndx
= ELF32_R_SYM (rel
->r_info
);
937 if (r_symndx
>= symtab_hdr
->sh_info
)
939 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
940 if (h
->plt
.refcount
> 0)
941 h
->plt
.refcount
-= 1;
952 /* Adjust a symbol defined by a dynamic object and referenced by a
953 regular object. The current definition is in some section of the
954 dynamic object, but we're not including those sections. We have to
955 change the definition to something the rest of the link can
959 elf_i386_adjust_dynamic_symbol (info
, h
)
960 struct bfd_link_info
*info
;
961 struct elf_link_hash_entry
*h
;
963 struct elf_i386_link_hash_table
*htab
;
966 unsigned int power_of_two
;
968 htab
= elf_i386_hash_table (info
);
969 dynobj
= htab
->root
.dynobj
;
971 /* Make sure we know what is going on here. */
972 BFD_ASSERT (dynobj
!= NULL
973 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
974 || h
->weakdef
!= NULL
975 || ((h
->elf_link_hash_flags
976 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
977 && (h
->elf_link_hash_flags
978 & ELF_LINK_HASH_REF_REGULAR
) != 0
979 && (h
->elf_link_hash_flags
980 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
982 /* If this is a function, put it in the procedure linkage table. We
983 will fill in the contents of the procedure linkage table later,
984 when we know the address of the .got section. */
985 if (h
->type
== STT_FUNC
986 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
988 if (h
->plt
.refcount
<= 0
990 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
991 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0))
993 /* This case can occur if we saw a PLT32 reloc in an input
994 file, but the symbol was never referred to by a dynamic
995 object, or if all references were garbage collected. In
996 such a case, we don't actually need to build a procedure
997 linkage table, and we can just do a PC32 reloc instead. */
998 h
->plt
.refcount
= (bfd_vma
) -1;
999 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1003 /* Make sure this symbol is output as a dynamic symbol. */
1004 if (h
->dynindx
== -1)
1006 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1013 /* It's possible that we incorrectly decided a .plt reloc was
1014 needed for an R_386_PC32 reloc to a non-function sym in
1015 check_relocs. We can't decide accurately between function and
1016 non-function syms in check-relocs; Objects loaded later in
1017 the link may change h->type. So fix it now. */
1018 h
->plt
.refcount
= (bfd_vma
) -1;
1020 /* If this is a weak symbol, and there is a real definition, the
1021 processor independent code will have arranged for us to see the
1022 real definition first, and we can just use the same value. */
1023 if (h
->weakdef
!= NULL
)
1025 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
1026 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
1027 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
1028 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
1032 /* This is a reference to a symbol defined by a dynamic object which
1033 is not a function. */
1035 /* If we are creating a shared library, we must presume that the
1036 only references to the symbol are via the global offset table.
1037 For such cases we need not do anything here; the relocations will
1038 be handled correctly by relocate_section. */
1042 /* If there are no references to this symbol that do not use the
1043 GOT, we don't need to generate a copy reloc. */
1044 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0)
1047 /* We must allocate the symbol in our .dynbss section, which will
1048 become part of the .bss section of the executable. There will be
1049 an entry for this symbol in the .dynsym section. The dynamic
1050 object will contain position independent code, so all references
1051 from the dynamic object to this symbol will go through the global
1052 offset table. The dynamic linker will use the .dynsym entry to
1053 determine the address it must put in the global offset table, so
1054 both the dynamic object and the regular object will refer to the
1055 same memory location for the variable. */
1058 BFD_ASSERT (s
!= NULL
);
1060 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1061 copy the initial value out of the dynamic object and into the
1062 runtime process image. We need to remember the offset into the
1063 .rel.bss section we are going to use. */
1064 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1068 srel
= htab
->srelbss
;
1069 BFD_ASSERT (srel
!= NULL
);
1070 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
1071 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
1074 /* We need to figure out the alignment required for this symbol. I
1075 have no idea how ELF linkers handle this. */
1076 power_of_two
= bfd_log2 (h
->size
);
1077 if (power_of_two
> 3)
1080 /* Apply the required alignment. */
1081 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
1082 (bfd_size_type
) (1 << power_of_two
));
1083 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
1085 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
1089 /* Define the symbol as being at this point in the section. */
1090 h
->root
.u
.def
.section
= s
;
1091 h
->root
.u
.def
.value
= s
->_raw_size
;
1093 /* Increment the section size to make room for the symbol. */
1094 s
->_raw_size
+= h
->size
;
1099 /* This is the condition under which elf_i386_finish_dynamic_symbol
1100 will be called from elflink.h. If elflink.h doesn't call our
1101 finish_dynamic_symbol routine, we'll need to do something about
1102 initializing any .plt and .got entries in elf_i386_relocate_section. */
1103 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1105 && ((INFO)->shared \
1106 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1107 && ((H)->dynindx != -1 \
1108 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1110 /* Allocate space in .plt, .got and associated reloc sections for
1111 global syms. Also discards space allocated for relocs in the
1112 check_relocs function that we subsequently have found to be
1116 allocate_plt_and_got_and_discard_relocs (h
, inf
)
1117 struct elf_link_hash_entry
*h
;
1120 struct bfd_link_info
*info
;
1121 struct elf_i386_link_hash_table
*htab
;
1124 if (h
->root
.type
== bfd_link_hash_indirect
1125 || h
->root
.type
== bfd_link_hash_warning
)
1128 info
= (struct bfd_link_info
*) inf
;
1129 htab
= elf_i386_hash_table (info
);
1131 if (htab
->root
.dynamic_sections_created
1132 && h
->plt
.refcount
> 0)
1135 BFD_ASSERT (s
!= NULL
);
1137 /* If this is the first .plt entry, make room for the special
1139 if (s
->_raw_size
== 0)
1140 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1142 h
->plt
.offset
= s
->_raw_size
;
1144 /* If this symbol is not defined in a regular file, and we are
1145 not generating a shared library, then set the symbol to this
1146 location in the .plt. This is required to make function
1147 pointers compare as equal between the normal executable and
1148 the shared library. */
1150 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1152 h
->root
.u
.def
.section
= s
;
1153 h
->root
.u
.def
.value
= h
->plt
.offset
;
1156 /* Make room for this entry. */
1157 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1159 /* We also need to make an entry in the .got.plt section, which
1160 will be placed in the .got section by the linker script. */
1162 BFD_ASSERT (s
!= NULL
);
1165 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
, h
))
1167 /* We also need to make an entry in the .rel.plt section. */
1169 BFD_ASSERT (s
!= NULL
);
1170 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
1175 h
->plt
.offset
= (bfd_vma
) -1;
1176 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1179 if (h
->got
.refcount
> 0)
1184 h
->got
.offset
= s
->_raw_size
;
1186 dyn
= htab
->root
.dynamic_sections_created
;
1187 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
))
1188 htab
->srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
1191 h
->got
.offset
= (bfd_vma
) -1;
1193 /* In the shared -Bsymbolic case, discard space allocated to copy
1194 PC relative relocs against symbols which turn out to be defined
1195 in regular objects. For the normal shared case, discard space
1196 for relocs that have become local due to symbol visibility
1197 changes. For the non-shared case, discard space for symbols
1198 which turn out to need copy relocs or are not dynamic. */
1201 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1202 && ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0
1205 && ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) != 0
1206 || h
->dynindx
== -1)))
1208 struct elf_i386_link_hash_entry
*eh
;
1209 struct elf_i386_pcrel_relocs_copied
*c
;
1211 eh
= (struct elf_i386_link_hash_entry
*) h
;
1212 for (c
= eh
->pcrel_relocs_copied
; c
!= NULL
; c
= c
->next
)
1213 c
->section
->_raw_size
-= c
->count
* sizeof (Elf32_External_Rel
);
1219 /* Set the sizes of the dynamic sections. */
1222 elf_i386_size_dynamic_sections (output_bfd
, info
)
1224 struct bfd_link_info
*info
;
1226 struct elf_i386_link_hash_table
*htab
;
1233 htab
= elf_i386_hash_table (info
);
1234 dynobj
= htab
->root
.dynobj
;
1235 BFD_ASSERT (dynobj
!= NULL
);
1237 if (htab
->root
.dynamic_sections_created
)
1239 /* Set the contents of the .interp section to the interpreter. */
1242 s
= bfd_get_section_by_name (dynobj
, ".interp");
1243 BFD_ASSERT (s
!= NULL
);
1244 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1245 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1249 /* Set up .got offsets for local syms. */
1250 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
1252 bfd_signed_vma
*local_got
;
1253 bfd_signed_vma
*end_local_got
;
1254 bfd_size_type locsymcount
;
1255 Elf_Internal_Shdr
*symtab_hdr
;
1258 if (bfd_get_flavour (i
) != bfd_target_elf_flavour
)
1261 local_got
= elf_local_got_refcounts (i
);
1265 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
1266 locsymcount
= symtab_hdr
->sh_info
;
1267 end_local_got
= local_got
+ locsymcount
;
1269 srel
= htab
->srelgot
;
1270 for (; local_got
< end_local_got
; ++local_got
)
1274 *local_got
= s
->_raw_size
;
1277 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
1280 *local_got
= (bfd_vma
) -1;
1284 /* Allocate global sym .plt and .got entries. Also discard all
1286 elf_link_hash_traverse (&htab
->root
,
1287 allocate_plt_and_got_and_discard_relocs
,
1290 /* The check_relocs and adjust_dynamic_symbol entry points have
1291 determined the sizes of the various dynamic sections. Allocate
1295 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1297 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1302 || s
== htab
->sgotplt
)
1304 /* Strip this section if we don't need it; see the
1307 else if (strncmp (bfd_get_section_name (dynobj
, s
), ".rel", 4) == 0)
1309 if (s
->_raw_size
== 0)
1311 /* If we don't need this section, strip it from the
1312 output file. This is mostly to handle .rel.bss and
1313 .rel.plt. We must create both sections in
1314 create_dynamic_sections, because they must be created
1315 before the linker maps input sections to output
1316 sections. The linker does that before
1317 adjust_dynamic_symbol is called, and it is that
1318 function which decides whether anything needs to go
1319 into these sections. */
1325 /* Remember whether there are any reloc sections other
1327 if (s
!= htab
->srelplt
)
1329 const char *outname
;
1333 /* If this relocation section applies to a read only
1334 section, then we probably need a DT_TEXTREL
1335 entry. The entries in the .rel.plt section
1336 really apply to the .got section, which we
1337 created ourselves and so know is not readonly. */
1338 outname
= bfd_get_section_name (output_bfd
,
1340 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
1342 && (target
->flags
& SEC_READONLY
) != 0
1343 && (target
->flags
& SEC_ALLOC
) != 0)
1347 /* We use the reloc_count field as a counter if we need
1348 to copy relocs into the output file. */
1354 /* It's not one of our sections, so don't allocate space. */
1358 if (s
->_raw_size
== 0)
1360 _bfd_strip_section_from_output (info
, s
);
1364 /* Allocate memory for the section contents. We use bfd_zalloc
1365 here in case unused entries are not reclaimed before the
1366 section's contents are written out. This should not happen,
1367 but this way if it does, we get a R_386_NONE reloc instead
1369 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1370 if (s
->contents
== NULL
)
1374 if (htab
->root
.dynamic_sections_created
)
1376 /* Add some entries to the .dynamic section. We fill in the
1377 values later, in elf_i386_finish_dynamic_sections, but we
1378 must add the entries now so that we get the correct size for
1379 the .dynamic section. The DT_DEBUG entry is filled in by the
1380 dynamic linker and used by the debugger. */
1383 if (! bfd_elf32_add_dynamic_entry (info
, DT_DEBUG
, 0))
1387 if (htab
->splt
->_raw_size
!= 0)
1389 if (! bfd_elf32_add_dynamic_entry (info
, DT_PLTGOT
, 0)
1390 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
1391 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTREL
, DT_REL
)
1392 || ! bfd_elf32_add_dynamic_entry (info
, DT_JMPREL
, 0))
1398 if (! bfd_elf32_add_dynamic_entry (info
, DT_REL
, 0)
1399 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELSZ
, 0)
1400 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELENT
,
1401 sizeof (Elf32_External_Rel
)))
1407 if (! bfd_elf32_add_dynamic_entry (info
, DT_TEXTREL
, 0))
1409 info
->flags
|= DF_TEXTREL
;
1416 /* Relocate an i386 ELF section. */
1419 elf_i386_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1420 contents
, relocs
, local_syms
, local_sections
)
1422 struct bfd_link_info
*info
;
1424 asection
*input_section
;
1426 Elf_Internal_Rela
*relocs
;
1427 Elf_Internal_Sym
*local_syms
;
1428 asection
**local_sections
;
1430 struct elf_i386_link_hash_table
*htab
;
1432 Elf_Internal_Shdr
*symtab_hdr
;
1433 struct elf_link_hash_entry
**sym_hashes
;
1434 bfd_vma
*local_got_offsets
;
1436 Elf_Internal_Rela
*rel
;
1437 Elf_Internal_Rela
*relend
;
1439 htab
= elf_i386_hash_table (info
);
1440 dynobj
= htab
->root
.dynobj
;
1441 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1442 sym_hashes
= elf_sym_hashes (input_bfd
);
1443 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1447 relend
= relocs
+ input_section
->reloc_count
;
1448 for (; rel
< relend
; rel
++)
1451 reloc_howto_type
*howto
;
1452 unsigned long r_symndx
;
1453 struct elf_link_hash_entry
*h
;
1454 Elf_Internal_Sym
*sym
;
1457 bfd_reloc_status_type r
;
1460 r_type
= ELF32_R_TYPE (rel
->r_info
);
1461 if (r_type
== (int) R_386_GNU_VTINHERIT
1462 || r_type
== (int) R_386_GNU_VTENTRY
)
1465 if ((indx
= (unsigned) r_type
) >= R_386_standard
1466 && ((indx
= (unsigned) r_type
- R_386_ext_offset
) - R_386_standard
1467 >= R_386_ext
- R_386_standard
))
1469 bfd_set_error (bfd_error_bad_value
);
1472 howto
= elf_howto_table
+ indx
;
1474 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1476 if (info
->relocateable
)
1478 /* This is a relocateable link. We don't have to change
1479 anything, unless the reloc is against a section symbol,
1480 in which case we have to adjust according to where the
1481 section symbol winds up in the output section. */
1482 if (r_symndx
< symtab_hdr
->sh_info
)
1484 sym
= local_syms
+ r_symndx
;
1485 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1489 sec
= local_sections
[r_symndx
];
1490 val
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1491 val
+= sec
->output_offset
+ sym
->st_value
;
1492 bfd_put_32 (input_bfd
, val
, contents
+ rel
->r_offset
);
1499 /* This is a final link. */
1503 if (r_symndx
< symtab_hdr
->sh_info
)
1505 sym
= local_syms
+ r_symndx
;
1506 sec
= local_sections
[r_symndx
];
1507 relocation
= (sec
->output_section
->vma
1508 + sec
->output_offset
1513 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1514 while (h
->root
.type
== bfd_link_hash_indirect
1515 || h
->root
.type
== bfd_link_hash_warning
)
1516 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1518 if (h
->root
.type
== bfd_link_hash_defined
1519 || h
->root
.type
== bfd_link_hash_defweak
)
1521 sec
= h
->root
.u
.def
.section
;
1522 if (r_type
== R_386_GOTPC
1523 || (r_type
== R_386_PLT32
1524 && htab
->splt
!= NULL
1525 && h
->plt
.offset
!= (bfd_vma
) -1)
1526 || (r_type
== R_386_GOT32
1527 && (WILL_CALL_FINISH_DYNAMIC_SYMBOL
1528 (htab
->root
.dynamic_sections_created
, info
, h
))
1532 || (h
->elf_link_hash_flags
1533 & ELF_LINK_FORCED_LOCAL
))
1534 && (h
->elf_link_hash_flags
1535 & ELF_LINK_HASH_DEF_REGULAR
)))
1536 || ((r_type
== R_386_32
1537 || r_type
== R_386_PC32
)
1539 && ((!info
->symbolic
&& h
->dynindx
!= -1)
1540 || (h
->elf_link_hash_flags
1541 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1544 && (h
->elf_link_hash_flags
1545 & ELF_LINK_NON_GOT_REF
) == 0
1546 && (h
->elf_link_hash_flags
1547 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1548 && ((input_section
->flags
& SEC_ALLOC
) != 0
1549 /* DWARF will emit R_386_32 relocations in its
1550 sections against symbols defined externally
1551 in shared libraries. We can't do anything
1553 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
1554 && (h
->elf_link_hash_flags
1555 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0))))
1556 /* In these cases, we don't need the relocation
1557 value. We check specially because in some
1558 obscure cases sec->output_section will be NULL. */
1560 else if (sec
->output_section
== NULL
)
1561 (*_bfd_error_handler
)
1562 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
1563 bfd_get_filename (input_bfd
),
1564 bfd_get_section_name (input_bfd
, input_section
),
1565 (long) rel
->r_offset
,
1566 h
->root
.root
.string
);
1568 relocation
= (h
->root
.u
.def
.value
1569 + sec
->output_section
->vma
1570 + sec
->output_offset
);
1572 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1574 else if (info
->shared
&& !info
->symbolic
1575 && !info
->no_undefined
1576 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1580 if (! ((*info
->callbacks
->undefined_symbol
)
1581 (info
, h
->root
.root
.string
, input_bfd
,
1582 input_section
, rel
->r_offset
,
1583 (!info
->shared
|| info
->no_undefined
1584 || ELF_ST_VISIBILITY (h
->other
)))))
1592 /* Relocation is to the entry for this symbol in the global
1594 BFD_ASSERT (htab
->sgot
!= NULL
);
1601 off
= h
->got
.offset
;
1602 BFD_ASSERT (off
!= (bfd_vma
) -1);
1604 dyn
= htab
->root
.dynamic_sections_created
;
1605 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
)
1609 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
1610 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1612 /* This is actually a static link, or it is a
1613 -Bsymbolic link and the symbol is defined
1614 locally, or the symbol was forced to be local
1615 because of a version file. We must initialize
1616 this entry in the global offset table. Since the
1617 offset must always be a multiple of 4, we use the
1618 least significant bit to record whether we have
1619 initialized it already.
1621 When doing a dynamic link, we create a .rel.got
1622 relocation entry to initialize the value. This
1623 is done in the finish_dynamic_symbol routine. */
1628 bfd_put_32 (output_bfd
, relocation
,
1629 htab
->sgot
->contents
+ off
);
1634 relocation
= htab
->sgot
->output_offset
+ off
;
1640 BFD_ASSERT (local_got_offsets
!= NULL
1641 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1643 off
= local_got_offsets
[r_symndx
];
1645 /* The offset must always be a multiple of 4. We use
1646 the least significant bit to record whether we have
1647 already generated the necessary reloc. */
1652 bfd_put_32 (output_bfd
, relocation
,
1653 htab
->sgot
->contents
+ off
);
1658 Elf_Internal_Rel outrel
;
1660 srelgot
= htab
->srelgot
;
1661 BFD_ASSERT (srelgot
!= NULL
);
1663 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
1664 + htab
->sgot
->output_offset
1666 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1667 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1668 (((Elf32_External_Rel
*)
1670 + srelgot
->reloc_count
));
1671 ++srelgot
->reloc_count
;
1674 local_got_offsets
[r_symndx
] |= 1;
1677 relocation
= htab
->sgot
->output_offset
+ off
;
1683 /* Relocation is relative to the start of the global offset
1686 /* Note that sgot->output_offset is not involved in this
1687 calculation. We always want the start of .got. If we
1688 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1689 permitted by the ABI, we might have to change this
1691 relocation
-= htab
->sgot
->output_section
->vma
;
1696 /* Use global offset table as symbol value. */
1697 relocation
= htab
->sgot
->output_section
->vma
;
1701 /* Relocation is to the entry for this symbol in the
1702 procedure linkage table. */
1704 /* Resolve a PLT32 reloc against a local symbol directly,
1705 without using the procedure linkage table. */
1709 if (h
->plt
.offset
== (bfd_vma
) -1
1710 || htab
->splt
== NULL
)
1712 /* We didn't make a PLT entry for this symbol. This
1713 happens when statically linking PIC code, or when
1714 using -Bsymbolic. */
1718 relocation
= (htab
->splt
->output_section
->vma
1719 + htab
->splt
->output_offset
1727 && (input_section
->flags
& SEC_ALLOC
) != 0
1728 && (r_type
!= R_386_PC32
1731 && (! info
->symbolic
1732 || (h
->elf_link_hash_flags
1733 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1735 && (input_section
->flags
& SEC_ALLOC
) != 0
1738 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1739 && (h
->root
.type
== bfd_link_hash_defweak
1740 || (h
->elf_link_hash_flags
1741 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
1743 Elf_Internal_Rel outrel
;
1744 boolean skip
, relocate
;
1746 /* When generating a shared object, these relocations
1747 are copied into the output file to be resolved at run
1754 name
= (bfd_elf_string_from_elf_section
1756 elf_elfheader (input_bfd
)->e_shstrndx
,
1757 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1761 if (strncmp (name
, ".rel", 4) != 0
1762 || strcmp (bfd_get_section_name (input_bfd
,
1766 if (input_bfd
->my_archive
)
1767 (*_bfd_error_handler
) (_("%s(%s): bad relocation section name `%s\'"),
1768 bfd_get_filename (input_bfd
->my_archive
),
1769 bfd_get_filename (input_bfd
),
1772 (*_bfd_error_handler
) (_("%s: bad relocation section name `%s\'"),
1773 bfd_get_filename (input_bfd
),
1778 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1779 BFD_ASSERT (sreloc
!= NULL
);
1784 if (elf_section_data (input_section
)->stab_info
== NULL
)
1785 outrel
.r_offset
= rel
->r_offset
;
1790 off
= (_bfd_stab_section_offset
1791 (output_bfd
, htab
->root
.stab_info
, input_section
,
1792 &elf_section_data (input_section
)->stab_info
,
1794 if (off
== (bfd_vma
) -1)
1796 outrel
.r_offset
= off
;
1799 outrel
.r_offset
+= (input_section
->output_section
->vma
1800 + input_section
->output_offset
);
1804 memset (&outrel
, 0, sizeof outrel
);
1807 else if (r_type
== R_386_PC32
)
1809 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
1811 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_PC32
);
1815 /* h->dynindx may be -1 if this symbol was marked to
1819 && (info
->symbolic
|| h
->dynindx
== -1)
1820 && (h
->elf_link_hash_flags
1821 & ELF_LINK_HASH_DEF_REGULAR
) != 0))
1824 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1828 BFD_ASSERT (h
->dynindx
!= -1);
1830 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_32
);
1834 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1835 (((Elf32_External_Rel
*)
1837 + sreloc
->reloc_count
));
1838 ++sreloc
->reloc_count
;
1840 /* If this reloc is against an external symbol, we do
1841 not want to fiddle with the addend. Otherwise, we
1842 need to include the symbol value so that it becomes
1843 an addend for the dynamic reloc. */
1854 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1855 contents
, rel
->r_offset
,
1856 relocation
, (bfd_vma
) 0);
1858 if (r
!= bfd_reloc_ok
)
1863 case bfd_reloc_outofrange
:
1865 case bfd_reloc_overflow
:
1870 name
= h
->root
.root
.string
;
1873 name
= bfd_elf_string_from_elf_section (input_bfd
,
1874 symtab_hdr
->sh_link
,
1879 name
= bfd_section_name (input_bfd
, sec
);
1881 if (! ((*info
->callbacks
->reloc_overflow
)
1882 (info
, name
, howto
->name
, (bfd_vma
) 0,
1883 input_bfd
, input_section
, rel
->r_offset
)))
1894 /* Finish up dynamic symbol handling. We set the contents of various
1895 dynamic sections here. */
1898 elf_i386_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
1900 struct bfd_link_info
*info
;
1901 struct elf_link_hash_entry
*h
;
1902 Elf_Internal_Sym
*sym
;
1904 struct elf_i386_link_hash_table
*htab
;
1907 htab
= elf_i386_hash_table (info
);
1908 dynobj
= htab
->root
.dynobj
;
1910 if (h
->plt
.offset
!= (bfd_vma
) -1)
1914 Elf_Internal_Rel rel
;
1916 /* This symbol has an entry in the procedure linkage table. Set
1919 BFD_ASSERT (h
->dynindx
!= -1
1920 && htab
->splt
!= NULL
1921 && htab
->sgotplt
!= NULL
1922 && htab
->srelplt
!= NULL
);
1924 /* Get the index in the procedure linkage table which
1925 corresponds to this symbol. This is the index of this symbol
1926 in all the symbols for which we are making plt entries. The
1927 first entry in the procedure linkage table is reserved. */
1928 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
1930 /* Get the offset into the .got table of the entry that
1931 corresponds to this function. Each .got entry is 4 bytes.
1932 The first three are reserved. */
1933 got_offset
= (plt_index
+ 3) * 4;
1935 /* Fill in the entry in the procedure linkage table. */
1938 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_plt_entry
,
1940 bfd_put_32 (output_bfd
,
1941 (htab
->sgotplt
->output_section
->vma
1942 + htab
->sgotplt
->output_offset
1944 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
1948 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_pic_plt_entry
,
1950 bfd_put_32 (output_bfd
, got_offset
,
1951 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
1954 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rel
),
1955 htab
->splt
->contents
+ h
->plt
.offset
+ 7);
1956 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
1957 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
1959 /* Fill in the entry in the global offset table. */
1960 bfd_put_32 (output_bfd
,
1961 (htab
->splt
->output_section
->vma
1962 + htab
->splt
->output_offset
1965 htab
->sgotplt
->contents
+ got_offset
);
1967 /* Fill in the entry in the .rel.plt section. */
1968 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
1969 + htab
->sgotplt
->output_offset
1971 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
1972 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
1973 ((Elf32_External_Rel
*) htab
->srelplt
->contents
1976 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1978 /* Mark the symbol as undefined, rather than as defined in
1979 the .plt section. Leave the value alone. */
1980 sym
->st_shndx
= SHN_UNDEF
;
1984 if (h
->got
.offset
!= (bfd_vma
) -1)
1986 Elf_Internal_Rel rel
;
1988 /* This symbol has an entry in the global offset table. Set it
1991 BFD_ASSERT (htab
->sgot
!= NULL
&& htab
->srelgot
!= NULL
);
1993 rel
.r_offset
= (htab
->sgot
->output_section
->vma
1994 + htab
->sgot
->output_offset
1995 + (h
->got
.offset
&~ 1));
1997 /* If this is a static link, or it is a -Bsymbolic link and the
1998 symbol is defined locally or was forced to be local because
1999 of a version file, we just want to emit a RELATIVE reloc.
2000 The entry in the global offset table will already have been
2001 initialized in the relocate_section function. */
2005 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
2006 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
2008 BFD_ASSERT((h
->got
.offset
& 1) != 0);
2009 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2013 BFD_ASSERT((h
->got
.offset
& 1) == 0);
2014 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2015 htab
->sgot
->contents
+ h
->got
.offset
);
2016 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
2019 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
2020 ((Elf32_External_Rel
*) htab
->srelgot
->contents
2021 + htab
->srelgot
->reloc_count
));
2022 ++htab
->srelgot
->reloc_count
;
2025 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
2027 Elf_Internal_Rel rel
;
2029 /* This symbol needs a copy reloc. Set it up. */
2031 BFD_ASSERT (h
->dynindx
!= -1
2032 && (h
->root
.type
== bfd_link_hash_defined
2033 || h
->root
.type
== bfd_link_hash_defweak
)
2034 && htab
->srelbss
!= NULL
);
2036 rel
.r_offset
= (h
->root
.u
.def
.value
2037 + h
->root
.u
.def
.section
->output_section
->vma
2038 + h
->root
.u
.def
.section
->output_offset
);
2039 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
2040 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
2041 ((Elf32_External_Rel
*) htab
->srelbss
->contents
2042 + htab
->srelbss
->reloc_count
));
2043 ++htab
->srelbss
->reloc_count
;
2046 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2047 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2048 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2049 sym
->st_shndx
= SHN_ABS
;
2054 /* Finish up the dynamic sections. */
2057 elf_i386_finish_dynamic_sections (output_bfd
, info
)
2059 struct bfd_link_info
*info
;
2061 struct elf_i386_link_hash_table
*htab
;
2065 htab
= elf_i386_hash_table (info
);
2066 dynobj
= htab
->root
.dynobj
;
2067 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2069 if (htab
->root
.dynamic_sections_created
)
2071 Elf32_External_Dyn
*dyncon
, *dynconend
;
2073 BFD_ASSERT (sdyn
!= NULL
&& htab
->sgot
!= NULL
);
2075 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2076 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
2077 for (; dyncon
< dynconend
; dyncon
++)
2079 Elf_Internal_Dyn dyn
;
2081 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2089 dyn
.d_un
.d_ptr
= htab
->sgot
->output_section
->vma
;
2090 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2094 dyn
.d_un
.d_ptr
= htab
->srelplt
->output_section
->vma
;
2095 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2099 if (htab
->srelplt
->output_section
->_cooked_size
!= 0)
2100 dyn
.d_un
.d_val
= htab
->srelplt
->output_section
->_cooked_size
;
2102 dyn
.d_un
.d_val
= htab
->srelplt
->output_section
->_raw_size
;
2103 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2107 /* My reading of the SVR4 ABI indicates that the
2108 procedure linkage table relocs (DT_JMPREL) should be
2109 included in the overall relocs (DT_REL). This is
2110 what Solaris does. However, UnixWare can not handle
2111 that case. Therefore, we override the DT_RELSZ entry
2112 here to make it not include the JMPREL relocs. Since
2113 the linker script arranges for .rel.plt to follow all
2114 other relocation sections, we don't have to worry
2115 about changing the DT_REL entry. */
2116 if (htab
->srelplt
!= NULL
)
2118 if (htab
->srelplt
->output_section
->_cooked_size
!= 0)
2119 dyn
.d_un
.d_val
-= htab
->srelplt
->output_section
->_cooked_size
;
2121 dyn
.d_un
.d_val
-= htab
->srelplt
->output_section
->_raw_size
;
2123 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2128 /* Fill in the first entry in the procedure linkage table. */
2129 if (htab
->splt
&& htab
->splt
->_raw_size
> 0)
2132 memcpy (htab
->splt
->contents
,
2133 elf_i386_pic_plt0_entry
, PLT_ENTRY_SIZE
);
2136 memcpy (htab
->splt
->contents
,
2137 elf_i386_plt0_entry
, PLT_ENTRY_SIZE
);
2138 bfd_put_32 (output_bfd
,
2139 (htab
->sgotplt
->output_section
->vma
2140 + htab
->sgotplt
->output_offset
2142 htab
->splt
->contents
+ 2);
2143 bfd_put_32 (output_bfd
,
2144 (htab
->sgotplt
->output_section
->vma
2145 + htab
->sgotplt
->output_offset
2147 htab
->splt
->contents
+ 8);
2150 /* UnixWare sets the entsize of .plt to 4, although that doesn't
2151 really seem like the right value. */
2152 elf_section_data (htab
->splt
->output_section
)
2153 ->this_hdr
.sh_entsize
= 4;
2159 /* Fill in the first three entries in the global offset table. */
2160 if (htab
->sgotplt
->_raw_size
> 0)
2162 bfd_put_32 (output_bfd
,
2163 (sdyn
== NULL
? (bfd_vma
) 0
2164 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
2165 htab
->sgotplt
->contents
);
2166 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 4);
2167 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 8);
2170 elf_section_data (htab
->sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
2175 /* Set the correct type for an x86 ELF section. We do this by the
2176 section name, which is a hack, but ought to work. */
2179 elf_i386_fake_sections (abfd
, hdr
, sec
)
2180 bfd
*abfd ATTRIBUTE_UNUSED
;
2181 Elf32_Internal_Shdr
*hdr
;
2184 register const char *name
;
2186 name
= bfd_get_section_name (abfd
, sec
);
2188 if (strcmp (name
, ".reloc") == 0)
2190 * This is an ugly, but unfortunately necessary hack that is
2191 * needed when producing EFI binaries on x86. It tells
2192 * elf.c:elf_fake_sections() not to consider ".reloc" as a section
2193 * containing ELF relocation info. We need this hack in order to
2194 * be able to generate ELF binaries that can be translated into
2195 * EFI applications (which are essentially COFF objects). Those
2196 * files contain a COFF ".reloc" section inside an ELFNN object,
2197 * which would normally cause BFD to segfault because it would
2198 * attempt to interpret this section as containing relocation
2199 * entries for section "oc". With this hack enabled, ".reloc"
2200 * will be treated as a normal data section, which will avoid the
2201 * segfault. However, you won't be able to create an ELFNN binary
2202 * with a section named "oc" that needs relocations, but that's
2203 * the kind of ugly side-effects you get when detecting section
2204 * types based on their names... In practice, this limitation is
2207 hdr
->sh_type
= SHT_PROGBITS
;
2213 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
2214 #define TARGET_LITTLE_NAME "elf32-i386"
2215 #define ELF_ARCH bfd_arch_i386
2216 #define ELF_MACHINE_CODE EM_386
2217 #define ELF_MAXPAGESIZE 0x1000
2219 #define elf_backend_can_gc_sections 1
2220 #define elf_backend_want_got_plt 1
2221 #define elf_backend_plt_readonly 1
2222 #define elf_backend_want_plt_sym 0
2223 #define elf_backend_got_header_size 12
2224 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
2226 #define elf_info_to_howto elf_i386_info_to_howto
2227 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
2229 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
2230 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
2231 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
2233 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
2234 #define elf_backend_check_relocs elf_i386_check_relocs
2235 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
2236 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
2237 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
2238 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
2239 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
2240 #define elf_backend_relocate_section elf_i386_relocate_section
2241 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
2242 #define elf_backend_fake_sections elf_i386_fake_sections
2244 #include "elf32-target.h"