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
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) != 0
1197 || h
->dynindx
== -1)))
1199 struct elf_i386_link_hash_entry
*eh
;
1200 struct elf_i386_dyn_relocs
*c
;
1202 eh
= (struct elf_i386_link_hash_entry
*) h
;
1203 for (c
= eh
->dyn_relocs
; c
!= NULL
; c
= c
->next
)
1204 c
->section
->_raw_size
-= c
->count
* sizeof (Elf32_External_Rel
);
1210 /* Set the sizes of the dynamic sections. */
1213 elf_i386_size_dynamic_sections (output_bfd
, info
)
1215 struct bfd_link_info
*info
;
1217 struct elf_i386_link_hash_table
*htab
;
1224 htab
= elf_i386_hash_table (info
);
1225 dynobj
= htab
->root
.dynobj
;
1229 if (htab
->root
.dynamic_sections_created
)
1231 /* Set the contents of the .interp section to the interpreter. */
1234 s
= bfd_get_section_by_name (dynobj
, ".interp");
1237 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1238 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1242 /* Set up .got offsets for local syms. */
1243 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
1245 bfd_signed_vma
*local_got
;
1246 bfd_signed_vma
*end_local_got
;
1247 bfd_size_type locsymcount
;
1248 Elf_Internal_Shdr
*symtab_hdr
;
1251 if (bfd_get_flavour (i
) != bfd_target_elf_flavour
)
1254 local_got
= elf_local_got_refcounts (i
);
1258 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
1259 locsymcount
= symtab_hdr
->sh_info
;
1260 end_local_got
= local_got
+ locsymcount
;
1262 srel
= htab
->srelgot
;
1263 for (; local_got
< end_local_got
; ++local_got
)
1267 *local_got
= s
->_raw_size
;
1270 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
1273 *local_got
= (bfd_vma
) -1;
1277 /* Allocate global sym .plt and .got entries. Also discard all
1279 elf_link_hash_traverse (&htab
->root
,
1280 allocate_plt_and_got_and_discard_relocs
,
1283 /* The check_relocs and adjust_dynamic_symbol entry points have
1284 determined the sizes of the various dynamic sections. Allocate
1288 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1290 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1295 || s
== htab
->sgotplt
)
1297 /* Strip this section if we don't need it; see the
1300 else if (strncmp (bfd_get_section_name (dynobj
, s
), ".rel", 4) == 0)
1302 if (s
->_raw_size
== 0)
1304 /* If we don't need this section, strip it from the
1305 output file. This is mostly to handle .rel.bss and
1306 .rel.plt. We must create both sections in
1307 create_dynamic_sections, because they must be created
1308 before the linker maps input sections to output
1309 sections. The linker does that before
1310 adjust_dynamic_symbol is called, and it is that
1311 function which decides whether anything needs to go
1312 into these sections. */
1318 /* Remember whether there are any reloc sections other
1320 if (s
!= htab
->srelplt
)
1322 const char *outname
;
1326 /* If this relocation section applies to a read only
1327 section, then we probably need a DT_TEXTREL
1328 entry. The entries in the .rel.plt section
1329 really apply to the .got section, which we
1330 created ourselves and so know is not readonly. */
1331 outname
= bfd_get_section_name (output_bfd
,
1333 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
1335 && (target
->flags
& SEC_READONLY
) != 0
1336 && (target
->flags
& SEC_ALLOC
) != 0)
1340 /* We use the reloc_count field as a counter if we need
1341 to copy relocs into the output file. */
1347 /* It's not one of our sections, so don't allocate space. */
1351 if (s
->_raw_size
== 0)
1353 _bfd_strip_section_from_output (info
, s
);
1357 /* Allocate memory for the section contents. We use bfd_zalloc
1358 here in case unused entries are not reclaimed before the
1359 section's contents are written out. This should not happen,
1360 but this way if it does, we get a R_386_NONE reloc instead
1362 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1363 if (s
->contents
== NULL
)
1367 if (htab
->root
.dynamic_sections_created
)
1369 /* Add some entries to the .dynamic section. We fill in the
1370 values later, in elf_i386_finish_dynamic_sections, but we
1371 must add the entries now so that we get the correct size for
1372 the .dynamic section. The DT_DEBUG entry is filled in by the
1373 dynamic linker and used by the debugger. */
1376 if (! bfd_elf32_add_dynamic_entry (info
, DT_DEBUG
, 0))
1380 if (htab
->splt
->_raw_size
!= 0)
1382 if (! bfd_elf32_add_dynamic_entry (info
, DT_PLTGOT
, 0)
1383 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
1384 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTREL
, DT_REL
)
1385 || ! bfd_elf32_add_dynamic_entry (info
, DT_JMPREL
, 0))
1391 if (! bfd_elf32_add_dynamic_entry (info
, DT_REL
, 0)
1392 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELSZ
, 0)
1393 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELENT
,
1394 sizeof (Elf32_External_Rel
)))
1400 if (! bfd_elf32_add_dynamic_entry (info
, DT_TEXTREL
, 0))
1402 info
->flags
|= DF_TEXTREL
;
1409 /* Relocate an i386 ELF section. */
1412 elf_i386_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1413 contents
, relocs
, local_syms
, local_sections
)
1415 struct bfd_link_info
*info
;
1417 asection
*input_section
;
1419 Elf_Internal_Rela
*relocs
;
1420 Elf_Internal_Sym
*local_syms
;
1421 asection
**local_sections
;
1423 struct elf_i386_link_hash_table
*htab
;
1425 Elf_Internal_Shdr
*symtab_hdr
;
1426 struct elf_link_hash_entry
**sym_hashes
;
1427 bfd_vma
*local_got_offsets
;
1429 Elf_Internal_Rela
*rel
;
1430 Elf_Internal_Rela
*relend
;
1432 htab
= elf_i386_hash_table (info
);
1433 dynobj
= htab
->root
.dynobj
;
1434 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1435 sym_hashes
= elf_sym_hashes (input_bfd
);
1436 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1440 relend
= relocs
+ input_section
->reloc_count
;
1441 for (; rel
< relend
; rel
++)
1444 reloc_howto_type
*howto
;
1445 unsigned long r_symndx
;
1446 struct elf_link_hash_entry
*h
;
1447 Elf_Internal_Sym
*sym
;
1451 bfd_reloc_status_type r
;
1454 r_type
= ELF32_R_TYPE (rel
->r_info
);
1455 if (r_type
== (int) R_386_GNU_VTINHERIT
1456 || r_type
== (int) R_386_GNU_VTENTRY
)
1459 if ((indx
= (unsigned) r_type
) >= R_386_standard
1460 && ((indx
= (unsigned) r_type
- R_386_ext_offset
) - R_386_standard
1461 >= R_386_ext
- R_386_standard
))
1463 bfd_set_error (bfd_error_bad_value
);
1466 howto
= elf_howto_table
+ indx
;
1468 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1470 if (info
->relocateable
)
1472 /* This is a relocateable link. We don't have to change
1473 anything, unless the reloc is against a section symbol,
1474 in which case we have to adjust according to where the
1475 section symbol winds up in the output section. */
1476 if (r_symndx
< symtab_hdr
->sh_info
)
1478 sym
= local_syms
+ r_symndx
;
1479 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1483 sec
= local_sections
[r_symndx
];
1484 val
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1485 val
+= sec
->output_offset
+ sym
->st_value
;
1486 bfd_put_32 (input_bfd
, val
, contents
+ rel
->r_offset
);
1493 /* This is a final link. */
1497 if (r_symndx
< symtab_hdr
->sh_info
)
1499 sym
= local_syms
+ r_symndx
;
1500 sec
= local_sections
[r_symndx
];
1501 relocation
= (sec
->output_section
->vma
1502 + sec
->output_offset
1507 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1508 while (h
->root
.type
== bfd_link_hash_indirect
1509 || h
->root
.type
== bfd_link_hash_warning
)
1510 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1513 if (h
->root
.type
== bfd_link_hash_defined
1514 || h
->root
.type
== bfd_link_hash_defweak
)
1516 sec
= h
->root
.u
.def
.section
;
1517 if (r_type
== R_386_GOTPC
1518 || (r_type
== R_386_PLT32
1519 && htab
->splt
!= NULL
1520 && h
->plt
.offset
!= (bfd_vma
) -1)
1521 || (r_type
== R_386_GOT32
1522 && (WILL_CALL_FINISH_DYNAMIC_SYMBOL
1523 (htab
->root
.dynamic_sections_created
, info
, h
))
1527 || (h
->elf_link_hash_flags
1528 & ELF_LINK_FORCED_LOCAL
))
1529 && (h
->elf_link_hash_flags
1530 & ELF_LINK_HASH_DEF_REGULAR
)))
1531 || ((r_type
== R_386_32
1532 || r_type
== R_386_PC32
)
1534 && ((!info
->symbolic
&& h
->dynindx
!= -1)
1535 || (h
->elf_link_hash_flags
1536 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1539 && (h
->elf_link_hash_flags
1540 & ELF_LINK_NON_GOT_REF
) == 0
1541 && (h
->elf_link_hash_flags
1542 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1543 && ((input_section
->flags
& SEC_ALLOC
) != 0
1544 /* DWARF will emit R_386_32 relocations in its
1545 sections against symbols defined externally
1546 in shared libraries. We can't do anything
1548 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
1549 && (h
->elf_link_hash_flags
1550 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0))))
1551 /* In these cases, we don't need the relocation
1552 value. We check specially because in some
1553 obscure cases sec->output_section will be NULL. */
1555 else if (sec
->output_section
== NULL
)
1556 (*_bfd_error_handler
)
1557 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
1558 bfd_get_filename (input_bfd
),
1559 bfd_get_section_name (input_bfd
, input_section
),
1560 (long) rel
->r_offset
,
1561 h
->root
.root
.string
);
1563 relocation
= (h
->root
.u
.def
.value
1564 + sec
->output_section
->vma
1565 + sec
->output_offset
);
1567 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1569 else if (info
->shared
&& !info
->symbolic
1570 && !info
->no_undefined
1571 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1575 if (! ((*info
->callbacks
->undefined_symbol
)
1576 (info
, h
->root
.root
.string
, input_bfd
,
1577 input_section
, rel
->r_offset
,
1578 (!info
->shared
|| info
->no_undefined
1579 || ELF_ST_VISIBILITY (h
->other
)))))
1587 /* Relocation is to the entry for this symbol in the global
1589 if (htab
->sgot
== NULL
)
1596 off
= h
->got
.offset
;
1597 dyn
= htab
->root
.dynamic_sections_created
;
1598 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
)
1602 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
1603 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1605 /* This is actually a static link, or it is a
1606 -Bsymbolic link and the symbol is defined
1607 locally, or the symbol was forced to be local
1608 because of a version file. We must initialize
1609 this entry in the global offset table. Since the
1610 offset must always be a multiple of 4, we use the
1611 least significant bit to record whether we have
1612 initialized it already.
1614 When doing a dynamic link, we create a .rel.got
1615 relocation entry to initialize the value. This
1616 is done in the finish_dynamic_symbol routine. */
1621 bfd_put_32 (output_bfd
, relocation
,
1622 htab
->sgot
->contents
+ off
);
1629 if (local_got_offsets
== NULL
)
1632 off
= local_got_offsets
[r_symndx
];
1634 /* The offset must always be a multiple of 4. We use
1635 the least significant bit to record whether we have
1636 already generated the necessary reloc. */
1641 bfd_put_32 (output_bfd
, relocation
,
1642 htab
->sgot
->contents
+ off
);
1647 Elf_Internal_Rel outrel
;
1649 srelgot
= htab
->srelgot
;
1650 if (srelgot
== NULL
)
1653 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
1654 + htab
->sgot
->output_offset
1656 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1657 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1658 (((Elf32_External_Rel
*)
1660 + srelgot
->reloc_count
));
1661 ++srelgot
->reloc_count
;
1664 local_got_offsets
[r_symndx
] |= 1;
1668 if (off
>= (bfd_vma
) -2)
1671 relocation
= htab
->sgot
->output_offset
+ off
;
1675 /* Relocation is relative to the start of the global offset
1678 /* Note that sgot->output_offset is not involved in this
1679 calculation. We always want the start of .got. If we
1680 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1681 permitted by the ABI, we might have to change this
1683 relocation
-= htab
->sgot
->output_section
->vma
;
1687 /* Use global offset table as symbol value. */
1688 relocation
= htab
->sgot
->output_section
->vma
;
1692 /* Relocation is to the entry for this symbol in the
1693 procedure linkage table. */
1695 /* Resolve a PLT32 reloc against a local symbol directly,
1696 without using the procedure linkage table. */
1700 if (h
->plt
.offset
== (bfd_vma
) -1
1701 || htab
->splt
== NULL
)
1703 /* We didn't make a PLT entry for this symbol. This
1704 happens when statically linking PIC code, or when
1705 using -Bsymbolic. */
1709 relocation
= (htab
->splt
->output_section
->vma
1710 + htab
->splt
->output_offset
1717 && (input_section
->flags
& SEC_ALLOC
) != 0
1718 && (r_type
!= R_386_PC32
1721 && (! info
->symbolic
1722 || (h
->elf_link_hash_flags
1723 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1725 && (input_section
->flags
& SEC_ALLOC
) != 0
1728 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1729 && (h
->root
.type
== bfd_link_hash_defweak
1730 || (h
->elf_link_hash_flags
1731 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
1733 Elf_Internal_Rel outrel
;
1734 boolean skip
, relocate
;
1736 /* When generating a shared object, these relocations
1737 are copied into the output file to be resolved at run
1744 name
= (bfd_elf_string_from_elf_section
1746 elf_elfheader (input_bfd
)->e_shstrndx
,
1747 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1751 if (strncmp (name
, ".rel", 4) != 0
1752 || strcmp (bfd_get_section_name (input_bfd
,
1756 if (input_bfd
->my_archive
)
1757 (*_bfd_error_handler
)\
1758 (_("%s(%s): bad relocation section name `%s\'"),
1759 bfd_get_filename (input_bfd
->my_archive
),
1760 bfd_get_filename (input_bfd
),
1763 (*_bfd_error_handler
)
1764 (_("%s: bad relocation section name `%s\'"),
1765 bfd_get_filename (input_bfd
),
1770 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1777 if (elf_section_data (input_section
)->stab_info
== NULL
)
1778 outrel
.r_offset
= rel
->r_offset
;
1783 off
= (_bfd_stab_section_offset
1784 (output_bfd
, htab
->root
.stab_info
, input_section
,
1785 &elf_section_data (input_section
)->stab_info
,
1787 if (off
== (bfd_vma
) -1)
1789 outrel
.r_offset
= off
;
1792 outrel
.r_offset
+= (input_section
->output_section
->vma
1793 + input_section
->output_offset
);
1797 memset (&outrel
, 0, sizeof outrel
);
1800 else if (r_type
== R_386_PC32
)
1802 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
1804 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_PC32
);
1808 /* h->dynindx may be -1 if this symbol was marked to
1812 && (info
->symbolic
|| h
->dynindx
== -1)
1813 && (h
->elf_link_hash_flags
1814 & ELF_LINK_HASH_DEF_REGULAR
) != 0))
1817 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1821 BFD_ASSERT (h
->dynindx
!= -1);
1823 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_32
);
1827 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1828 (((Elf32_External_Rel
*)
1830 + sreloc
->reloc_count
));
1831 ++sreloc
->reloc_count
;
1833 /* If this reloc is against an external symbol, we do
1834 not want to fiddle with the addend. Otherwise, we
1835 need to include the symbol value so that it becomes
1836 an addend for the dynamic reloc. */
1847 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1848 contents
, rel
->r_offset
,
1849 relocation
, (bfd_vma
) 0);
1856 case bfd_reloc_overflow
:
1861 name
= h
->root
.root
.string
;
1864 name
= bfd_elf_string_from_elf_section (input_bfd
,
1865 symtab_hdr
->sh_link
,
1870 name
= bfd_section_name (input_bfd
, sec
);
1872 if (! ((*info
->callbacks
->reloc_overflow
)
1873 (info
, name
, howto
->name
, (bfd_vma
) 0,
1874 input_bfd
, input_section
, rel
->r_offset
)))
1880 case bfd_reloc_outofrange
:
1889 /* Finish up dynamic symbol handling. We set the contents of various
1890 dynamic sections here. */
1893 elf_i386_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
1895 struct bfd_link_info
*info
;
1896 struct elf_link_hash_entry
*h
;
1897 Elf_Internal_Sym
*sym
;
1899 struct elf_i386_link_hash_table
*htab
;
1902 htab
= elf_i386_hash_table (info
);
1903 dynobj
= htab
->root
.dynobj
;
1905 if (h
->plt
.offset
!= (bfd_vma
) -1)
1909 Elf_Internal_Rel rel
;
1911 /* This symbol has an entry in the procedure linkage table. Set
1914 if (h
->dynindx
== -1
1915 || htab
->splt
== NULL
1916 || htab
->sgotplt
== NULL
1917 || htab
->srelplt
== NULL
)
1920 /* Get the index in the procedure linkage table which
1921 corresponds to this symbol. This is the index of this symbol
1922 in all the symbols for which we are making plt entries. The
1923 first entry in the procedure linkage table is reserved. */
1924 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
1926 /* Get the offset into the .got table of the entry that
1927 corresponds to this function. Each .got entry is 4 bytes.
1928 The first three are reserved. */
1929 got_offset
= (plt_index
+ 3) * 4;
1931 /* Fill in the entry in the procedure linkage table. */
1934 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_plt_entry
,
1936 bfd_put_32 (output_bfd
,
1937 (htab
->sgotplt
->output_section
->vma
1938 + htab
->sgotplt
->output_offset
1940 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
1944 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_pic_plt_entry
,
1946 bfd_put_32 (output_bfd
, got_offset
,
1947 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
1950 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rel
),
1951 htab
->splt
->contents
+ h
->plt
.offset
+ 7);
1952 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
1953 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
1955 /* Fill in the entry in the global offset table. */
1956 bfd_put_32 (output_bfd
,
1957 (htab
->splt
->output_section
->vma
1958 + htab
->splt
->output_offset
1961 htab
->sgotplt
->contents
+ got_offset
);
1963 /* Fill in the entry in the .rel.plt section. */
1964 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
1965 + htab
->sgotplt
->output_offset
1967 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
1968 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
1969 ((Elf32_External_Rel
*) htab
->srelplt
->contents
1972 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1974 /* Mark the symbol as undefined, rather than as defined in
1975 the .plt section. Leave the value alone. */
1976 sym
->st_shndx
= SHN_UNDEF
;
1980 if (h
->got
.offset
!= (bfd_vma
) -1)
1982 Elf_Internal_Rel rel
;
1984 /* This symbol has an entry in the global offset table. Set it
1987 if (htab
->sgot
== NULL
|| htab
->srelgot
== NULL
)
1990 rel
.r_offset
= (htab
->sgot
->output_section
->vma
1991 + htab
->sgot
->output_offset
1992 + (h
->got
.offset
&~ 1));
1994 /* If this is a static link, or it is a -Bsymbolic link and the
1995 symbol is defined locally or was forced to be local because
1996 of a version file, we just want to emit a RELATIVE reloc.
1997 The entry in the global offset table will already have been
1998 initialized in the relocate_section function. */
2002 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
2003 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
2005 BFD_ASSERT((h
->got
.offset
& 1) != 0);
2006 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2010 BFD_ASSERT((h
->got
.offset
& 1) == 0);
2011 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2012 htab
->sgot
->contents
+ h
->got
.offset
);
2013 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
2016 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
2017 ((Elf32_External_Rel
*) htab
->srelgot
->contents
2018 + htab
->srelgot
->reloc_count
));
2019 ++htab
->srelgot
->reloc_count
;
2022 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
2024 Elf_Internal_Rel rel
;
2026 /* This symbol needs a copy reloc. Set it up. */
2028 if (h
->dynindx
== -1
2029 || (h
->root
.type
!= bfd_link_hash_defined
2030 && h
->root
.type
!= bfd_link_hash_defweak
)
2031 || htab
->srelbss
== NULL
)
2034 rel
.r_offset
= (h
->root
.u
.def
.value
2035 + h
->root
.u
.def
.section
->output_section
->vma
2036 + h
->root
.u
.def
.section
->output_offset
);
2037 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
2038 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
2039 ((Elf32_External_Rel
*) htab
->srelbss
->contents
2040 + htab
->srelbss
->reloc_count
));
2041 ++htab
->srelbss
->reloc_count
;
2044 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2045 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2046 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2047 sym
->st_shndx
= SHN_ABS
;
2052 /* Finish up the dynamic sections. */
2055 elf_i386_finish_dynamic_sections (output_bfd
, info
)
2057 struct bfd_link_info
*info
;
2059 struct elf_i386_link_hash_table
*htab
;
2063 htab
= elf_i386_hash_table (info
);
2064 dynobj
= htab
->root
.dynobj
;
2065 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2067 if (htab
->root
.dynamic_sections_created
)
2069 Elf32_External_Dyn
*dyncon
, *dynconend
;
2071 if (sdyn
== NULL
|| htab
->sgot
== NULL
)
2074 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2075 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
2076 for (; dyncon
< dynconend
; dyncon
++)
2078 Elf_Internal_Dyn dyn
;
2080 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2088 dyn
.d_un
.d_ptr
= htab
->sgot
->output_section
->vma
;
2089 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2093 dyn
.d_un
.d_ptr
= htab
->srelplt
->output_section
->vma
;
2094 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2098 if (htab
->srelplt
->output_section
->_cooked_size
!= 0)
2099 dyn
.d_un
.d_val
= htab
->srelplt
->output_section
->_cooked_size
;
2101 dyn
.d_un
.d_val
= htab
->srelplt
->output_section
->_raw_size
;
2102 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2106 /* My reading of the SVR4 ABI indicates that the
2107 procedure linkage table relocs (DT_JMPREL) should be
2108 included in the overall relocs (DT_REL). This is
2109 what Solaris does. However, UnixWare can not handle
2110 that case. Therefore, we override the DT_RELSZ entry
2111 here to make it not include the JMPREL relocs. Since
2112 the linker script arranges for .rel.plt to follow all
2113 other relocation sections, we don't have to worry
2114 about changing the DT_REL entry. */
2115 if (htab
->srelplt
!= NULL
)
2117 if (htab
->srelplt
->output_section
->_cooked_size
!= 0)
2118 dyn
.d_un
.d_val
-= htab
->srelplt
->output_section
->_cooked_size
;
2120 dyn
.d_un
.d_val
-= htab
->srelplt
->output_section
->_raw_size
;
2122 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2127 /* Fill in the first entry in the procedure linkage table. */
2128 if (htab
->splt
&& htab
->splt
->_raw_size
> 0)
2131 memcpy (htab
->splt
->contents
,
2132 elf_i386_pic_plt0_entry
, PLT_ENTRY_SIZE
);
2135 memcpy (htab
->splt
->contents
,
2136 elf_i386_plt0_entry
, PLT_ENTRY_SIZE
);
2137 bfd_put_32 (output_bfd
,
2138 (htab
->sgotplt
->output_section
->vma
2139 + htab
->sgotplt
->output_offset
2141 htab
->splt
->contents
+ 2);
2142 bfd_put_32 (output_bfd
,
2143 (htab
->sgotplt
->output_section
->vma
2144 + htab
->sgotplt
->output_offset
2146 htab
->splt
->contents
+ 8);
2149 /* UnixWare sets the entsize of .plt to 4, although that doesn't
2150 really seem like the right value. */
2151 elf_section_data (htab
->splt
->output_section
)
2152 ->this_hdr
.sh_entsize
= 4;
2158 /* Fill in the first three entries in the global offset table. */
2159 if (htab
->sgotplt
->_raw_size
> 0)
2161 bfd_put_32 (output_bfd
,
2162 (sdyn
== NULL
? (bfd_vma
) 0
2163 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
2164 htab
->sgotplt
->contents
);
2165 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 4);
2166 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 8);
2169 elf_section_data (htab
->sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
2174 /* Set the correct type for an x86 ELF section. We do this by the
2175 section name, which is a hack, but ought to work. */
2178 elf_i386_fake_sections (abfd
, hdr
, sec
)
2179 bfd
*abfd ATTRIBUTE_UNUSED
;
2180 Elf32_Internal_Shdr
*hdr
;
2183 register const char *name
;
2185 name
= bfd_get_section_name (abfd
, sec
);
2187 if (strcmp (name
, ".reloc") == 0)
2189 * This is an ugly, but unfortunately necessary hack that is
2190 * needed when producing EFI binaries on x86. It tells
2191 * elf.c:elf_fake_sections() not to consider ".reloc" as a section
2192 * containing ELF relocation info. We need this hack in order to
2193 * be able to generate ELF binaries that can be translated into
2194 * EFI applications (which are essentially COFF objects). Those
2195 * files contain a COFF ".reloc" section inside an ELFNN object,
2196 * which would normally cause BFD to segfault because it would
2197 * attempt to interpret this section as containing relocation
2198 * entries for section "oc". With this hack enabled, ".reloc"
2199 * will be treated as a normal data section, which will avoid the
2200 * segfault. However, you won't be able to create an ELFNN binary
2201 * with a section named "oc" that needs relocations, but that's
2202 * the kind of ugly side-effects you get when detecting section
2203 * types based on their names... In practice, this limitation is
2206 hdr
->sh_type
= SHT_PROGBITS
;
2212 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
2213 #define TARGET_LITTLE_NAME "elf32-i386"
2214 #define ELF_ARCH bfd_arch_i386
2215 #define ELF_MACHINE_CODE EM_386
2216 #define ELF_MAXPAGESIZE 0x1000
2218 #define elf_backend_can_gc_sections 1
2219 #define elf_backend_want_got_plt 1
2220 #define elf_backend_plt_readonly 1
2221 #define elf_backend_want_plt_sym 0
2222 #define elf_backend_got_header_size 12
2223 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
2225 #define elf_info_to_howto elf_i386_info_to_howto
2226 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
2228 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
2229 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
2230 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
2232 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
2233 #define elf_backend_check_relocs elf_i386_check_relocs
2234 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
2235 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
2236 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
2237 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
2238 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
2239 #define elf_backend_relocate_section elf_i386_relocate_section
2240 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
2241 #define elf_backend_fake_sections elf_i386_fake_sections
2243 #include "elf32-target.h"