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
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 discard_copies
51 PARAMS ((struct elf_link_hash_entry
*, PTR
));
52 static boolean elf_i386_relocate_section
53 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
54 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
55 static boolean elf_i386_finish_dynamic_symbol
56 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
58 static boolean elf_i386_finish_dynamic_sections
59 PARAMS ((bfd
*, struct bfd_link_info
*));
61 #define USE_REL 1 /* 386 uses REL relocations instead of RELA */
65 static reloc_howto_type elf_howto_table
[]=
67 HOWTO(R_386_NONE
, 0, 0, 0, false, 0, complain_overflow_bitfield
,
68 bfd_elf_generic_reloc
, "R_386_NONE",
69 true, 0x00000000, 0x00000000, false),
70 HOWTO(R_386_32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
71 bfd_elf_generic_reloc
, "R_386_32",
72 true, 0xffffffff, 0xffffffff, false),
73 HOWTO(R_386_PC32
, 0, 2, 32, true, 0, complain_overflow_bitfield
,
74 bfd_elf_generic_reloc
, "R_386_PC32",
75 true, 0xffffffff, 0xffffffff, true),
76 HOWTO(R_386_GOT32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
77 bfd_elf_generic_reloc
, "R_386_GOT32",
78 true, 0xffffffff, 0xffffffff, false),
79 HOWTO(R_386_PLT32
, 0, 2, 32, true, 0, complain_overflow_bitfield
,
80 bfd_elf_generic_reloc
, "R_386_PLT32",
81 true, 0xffffffff, 0xffffffff, true),
82 HOWTO(R_386_COPY
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
83 bfd_elf_generic_reloc
, "R_386_COPY",
84 true, 0xffffffff, 0xffffffff, false),
85 HOWTO(R_386_GLOB_DAT
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
86 bfd_elf_generic_reloc
, "R_386_GLOB_DAT",
87 true, 0xffffffff, 0xffffffff, false),
88 HOWTO(R_386_JUMP_SLOT
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
89 bfd_elf_generic_reloc
, "R_386_JUMP_SLOT",
90 true, 0xffffffff, 0xffffffff, false),
91 HOWTO(R_386_RELATIVE
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
92 bfd_elf_generic_reloc
, "R_386_RELATIVE",
93 true, 0xffffffff, 0xffffffff, false),
94 HOWTO(R_386_GOTOFF
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
95 bfd_elf_generic_reloc
, "R_386_GOTOFF",
96 true, 0xffffffff, 0xffffffff, false),
97 HOWTO(R_386_GOTPC
, 0, 2, 32, true, 0, complain_overflow_bitfield
,
98 bfd_elf_generic_reloc
, "R_386_GOTPC",
99 true, 0xffffffff, 0xffffffff, true),
101 /* We have a gap in the reloc numbers here.
102 R_386_standard counts the number up to this point, and
103 R_386_ext_offset is the value to subtract from a reloc type of
104 R_386_16 thru R_386_PC8 to form an index into this table. */
105 #define R_386_standard ((unsigned int) R_386_GOTPC + 1)
106 #define R_386_ext_offset ((unsigned int) R_386_16 - R_386_standard)
108 /* The remaining relocs are a GNU extension. */
109 HOWTO(R_386_16
, 0, 1, 16, false, 0, complain_overflow_bitfield
,
110 bfd_elf_generic_reloc
, "R_386_16",
111 true, 0xffff, 0xffff, false),
112 HOWTO(R_386_PC16
, 0, 1, 16, true, 0, complain_overflow_bitfield
,
113 bfd_elf_generic_reloc
, "R_386_PC16",
114 true, 0xffff, 0xffff, true),
115 HOWTO(R_386_8
, 0, 0, 8, false, 0, complain_overflow_bitfield
,
116 bfd_elf_generic_reloc
, "R_386_8",
117 true, 0xff, 0xff, false),
118 HOWTO(R_386_PC8
, 0, 0, 8, true, 0, complain_overflow_signed
,
119 bfd_elf_generic_reloc
, "R_386_PC8",
120 true, 0xff, 0xff, true),
123 #define R_386_ext ((unsigned int) R_386_PC8 + 1 - R_386_ext_offset)
124 #define R_386_vt_offset ((unsigned int) R_386_GNU_VTINHERIT - R_386_ext)
126 /* GNU extension to record C++ vtable hierarchy. */
127 HOWTO (R_386_GNU_VTINHERIT
, /* type */
129 2, /* size (0 = byte, 1 = short, 2 = long) */
131 false, /* pc_relative */
133 complain_overflow_dont
, /* complain_on_overflow */
134 NULL
, /* special_function */
135 "R_386_GNU_VTINHERIT", /* name */
136 false, /* partial_inplace */
141 /* GNU extension to record C++ vtable member usage. */
142 HOWTO (R_386_GNU_VTENTRY
, /* type */
144 2, /* size (0 = byte, 1 = short, 2 = long) */
146 false, /* pc_relative */
148 complain_overflow_dont
, /* complain_on_overflow */
149 _bfd_elf_rel_vtable_reloc_fn
, /* special_function */
150 "R_386_GNU_VTENTRY", /* name */
151 false, /* partial_inplace */
156 #define R_386_vt ((unsigned int) R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
160 #ifdef DEBUG_GEN_RELOC
161 #define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
166 static reloc_howto_type
*
167 elf_i386_reloc_type_lookup (abfd
, code
)
168 bfd
*abfd ATTRIBUTE_UNUSED
;
169 bfd_reloc_code_real_type code
;
174 TRACE ("BFD_RELOC_NONE");
175 return &elf_howto_table
[(unsigned int) R_386_NONE
];
178 TRACE ("BFD_RELOC_32");
179 return &elf_howto_table
[(unsigned int) R_386_32
];
182 TRACE ("BFD_RELOC_CTOR");
183 return &elf_howto_table
[(unsigned int) R_386_32
];
185 case BFD_RELOC_32_PCREL
:
186 TRACE ("BFD_RELOC_PC32");
187 return &elf_howto_table
[(unsigned int) R_386_PC32
];
189 case BFD_RELOC_386_GOT32
:
190 TRACE ("BFD_RELOC_386_GOT32");
191 return &elf_howto_table
[(unsigned int) R_386_GOT32
];
193 case BFD_RELOC_386_PLT32
:
194 TRACE ("BFD_RELOC_386_PLT32");
195 return &elf_howto_table
[(unsigned int) R_386_PLT32
];
197 case BFD_RELOC_386_COPY
:
198 TRACE ("BFD_RELOC_386_COPY");
199 return &elf_howto_table
[(unsigned int) R_386_COPY
];
201 case BFD_RELOC_386_GLOB_DAT
:
202 TRACE ("BFD_RELOC_386_GLOB_DAT");
203 return &elf_howto_table
[(unsigned int) R_386_GLOB_DAT
];
205 case BFD_RELOC_386_JUMP_SLOT
:
206 TRACE ("BFD_RELOC_386_JUMP_SLOT");
207 return &elf_howto_table
[(unsigned int) R_386_JUMP_SLOT
];
209 case BFD_RELOC_386_RELATIVE
:
210 TRACE ("BFD_RELOC_386_RELATIVE");
211 return &elf_howto_table
[(unsigned int) R_386_RELATIVE
];
213 case BFD_RELOC_386_GOTOFF
:
214 TRACE ("BFD_RELOC_386_GOTOFF");
215 return &elf_howto_table
[(unsigned int) R_386_GOTOFF
];
217 case BFD_RELOC_386_GOTPC
:
218 TRACE ("BFD_RELOC_386_GOTPC");
219 return &elf_howto_table
[(unsigned int) R_386_GOTPC
];
221 /* The remaining relocs are a GNU extension. */
223 TRACE ("BFD_RELOC_16");
224 return &elf_howto_table
[(unsigned int) R_386_16
- R_386_ext_offset
];
226 case BFD_RELOC_16_PCREL
:
227 TRACE ("BFD_RELOC_16_PCREL");
228 return &elf_howto_table
[(unsigned int) R_386_PC16
- R_386_ext_offset
];
231 TRACE ("BFD_RELOC_8");
232 return &elf_howto_table
[(unsigned int) R_386_8
- R_386_ext_offset
];
234 case BFD_RELOC_8_PCREL
:
235 TRACE ("BFD_RELOC_8_PCREL");
236 return &elf_howto_table
[(unsigned int) R_386_PC8
- R_386_ext_offset
];
238 case BFD_RELOC_VTABLE_INHERIT
:
239 TRACE ("BFD_RELOC_VTABLE_INHERIT");
240 return &elf_howto_table
[(unsigned int) R_386_GNU_VTINHERIT
243 case BFD_RELOC_VTABLE_ENTRY
:
244 TRACE ("BFD_RELOC_VTABLE_ENTRY");
245 return &elf_howto_table
[(unsigned int) R_386_GNU_VTENTRY
257 elf_i386_info_to_howto (abfd
, cache_ptr
, dst
)
258 bfd
*abfd ATTRIBUTE_UNUSED
;
259 arelent
*cache_ptr ATTRIBUTE_UNUSED
;
260 Elf32_Internal_Rela
*dst ATTRIBUTE_UNUSED
;
266 elf_i386_info_to_howto_rel (abfd
, cache_ptr
, dst
)
267 bfd
*abfd ATTRIBUTE_UNUSED
;
269 Elf32_Internal_Rel
*dst
;
271 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
274 if ((indx
= r_type
) >= R_386_standard
275 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
276 >= R_386_ext
- R_386_standard
)
277 && ((indx
= r_type
- R_386_vt_offset
) - R_386_ext
278 >= R_386_vt
- R_386_ext
))
280 (*_bfd_error_handler
) (_("%s: invalid relocation type %d"),
281 bfd_get_filename (abfd
), (int) r_type
);
282 indx
= (unsigned int) R_386_NONE
;
284 cache_ptr
->howto
= &elf_howto_table
[indx
];
287 /* Return whether a symbol name implies a local label. The UnixWare
288 2.1 cc generates temporary symbols that start with .X, so we
289 recognize them here. FIXME: do other SVR4 compilers also use .X?.
290 If so, we should move the .X recognition into
291 _bfd_elf_is_local_label_name. */
294 elf_i386_is_local_label_name (abfd
, name
)
298 if (name
[0] == '.' && name
[1] == 'X')
301 return _bfd_elf_is_local_label_name (abfd
, name
);
304 /* Functions for the i386 ELF linker. */
306 /* The name of the dynamic interpreter. This is put in the .interp
309 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
311 /* The size in bytes of an entry in the procedure linkage table. */
313 #define PLT_ENTRY_SIZE 16
315 /* The first entry in an absolute procedure linkage table looks like
316 this. See the SVR4 ABI i386 supplement to see how this works. */
318 static const bfd_byte elf_i386_plt0_entry
[PLT_ENTRY_SIZE
] =
320 0xff, 0x35, /* pushl contents of address */
321 0, 0, 0, 0, /* replaced with address of .got + 4. */
322 0xff, 0x25, /* jmp indirect */
323 0, 0, 0, 0, /* replaced with address of .got + 8. */
324 0, 0, 0, 0 /* pad out to 16 bytes. */
327 /* Subsequent entries in an absolute procedure linkage table look like
330 static const bfd_byte elf_i386_plt_entry
[PLT_ENTRY_SIZE
] =
332 0xff, 0x25, /* jmp indirect */
333 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
334 0x68, /* pushl immediate */
335 0, 0, 0, 0, /* replaced with offset into relocation table. */
336 0xe9, /* jmp relative */
337 0, 0, 0, 0 /* replaced with offset to start of .plt. */
340 /* The first entry in a PIC procedure linkage table look like this. */
342 static const bfd_byte elf_i386_pic_plt0_entry
[PLT_ENTRY_SIZE
] =
344 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
345 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
346 0, 0, 0, 0 /* pad out to 16 bytes. */
349 /* Subsequent entries in a PIC procedure linkage table look like this. */
351 static const bfd_byte elf_i386_pic_plt_entry
[PLT_ENTRY_SIZE
] =
353 0xff, 0xa3, /* jmp *offset(%ebx) */
354 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
355 0x68, /* pushl immediate */
356 0, 0, 0, 0, /* replaced with offset into relocation table. */
357 0xe9, /* jmp relative */
358 0, 0, 0, 0 /* replaced with offset to start of .plt. */
361 /* The i386 linker needs to keep track of the number of relocs that it
362 decides to copy in check_relocs for each symbol. This is so that
363 it can discard PC relative relocs if it doesn't need them when
364 linking with -Bsymbolic. We store the information in a field
365 extending the regular ELF linker hash table. */
367 /* This structure keeps track of the number of PC relative relocs we
368 have copied for a given symbol. */
370 struct elf_i386_pcrel_relocs_copied
373 struct elf_i386_pcrel_relocs_copied
*next
;
374 /* A section in dynobj. */
376 /* Number of relocs copied in this section. */
380 /* i386 ELF linker hash entry. */
382 struct elf_i386_link_hash_entry
384 struct elf_link_hash_entry root
;
386 /* Number of PC relative relocs copied for this symbol. */
387 struct elf_i386_pcrel_relocs_copied
*pcrel_relocs_copied
;
390 /* i386 ELF linker hash table. */
392 struct elf_i386_link_hash_table
394 struct elf_link_hash_table root
;
396 /* Short-cuts to get to dynamic linker sections. */
406 /* Get the i386 ELF linker hash table from a link_info structure. */
408 #define elf_i386_hash_table(p) \
409 ((struct elf_i386_link_hash_table *) ((p)->hash))
411 /* Create an entry in an i386 ELF linker hash table. */
413 static struct bfd_hash_entry
*
414 elf_i386_link_hash_newfunc (entry
, table
, string
)
415 struct bfd_hash_entry
*entry
;
416 struct bfd_hash_table
*table
;
419 struct elf_i386_link_hash_entry
*ret
=
420 (struct elf_i386_link_hash_entry
*) entry
;
422 /* Allocate the structure if it has not already been allocated by a
424 if (ret
== (struct elf_i386_link_hash_entry
*) NULL
)
425 ret
= ((struct elf_i386_link_hash_entry
*)
426 bfd_hash_allocate (table
,
427 sizeof (struct elf_i386_link_hash_entry
)));
428 if (ret
== (struct elf_i386_link_hash_entry
*) NULL
)
429 return (struct bfd_hash_entry
*) ret
;
431 /* Call the allocation method of the superclass. */
432 ret
= ((struct elf_i386_link_hash_entry
*)
433 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
435 if (ret
!= (struct elf_i386_link_hash_entry
*) NULL
)
437 ret
->pcrel_relocs_copied
= NULL
;
440 return (struct bfd_hash_entry
*) ret
;
443 /* Create an i386 ELF linker hash table. */
445 static struct bfd_link_hash_table
*
446 elf_i386_link_hash_table_create (abfd
)
449 struct elf_i386_link_hash_table
*ret
;
451 ret
= ((struct elf_i386_link_hash_table
*)
452 bfd_alloc (abfd
, sizeof (struct elf_i386_link_hash_table
)));
453 if (ret
== (struct elf_i386_link_hash_table
*) NULL
)
456 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
457 elf_i386_link_hash_newfunc
))
459 bfd_release (abfd
, ret
);
471 return &ret
->root
.root
;
474 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
475 shortcuts to them in our hash table. */
478 create_got_section (dynobj
, info
)
480 struct bfd_link_info
*info
;
482 struct elf_i386_link_hash_table
*htab
;
484 if (! _bfd_elf_create_got_section (dynobj
, info
))
487 htab
= elf_i386_hash_table (info
);
488 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
489 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
490 if (!htab
->sgot
|| !htab
->sgotplt
)
493 htab
->srelgot
= bfd_make_section (dynobj
, ".rel.got");
494 if (htab
->srelgot
== NULL
495 || ! bfd_set_section_flags (dynobj
, htab
->srelgot
,
496 (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
497 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
499 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
504 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
505 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
509 elf_i386_create_dynamic_sections (dynobj
, info
)
511 struct bfd_link_info
*info
;
513 struct elf_i386_link_hash_table
*htab
;
515 htab
= elf_i386_hash_table (info
);
516 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
519 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
522 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
523 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rel.plt");
524 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
526 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rel.bss");
528 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
529 || (!info
->shared
&& !htab
->srelbss
))
535 /* Look through the relocs for a section during the first phase, and
536 allocate space in the global offset table or procedure linkage
540 elf_i386_check_relocs (abfd
, info
, sec
, relocs
)
542 struct bfd_link_info
*info
;
544 const Elf_Internal_Rela
*relocs
;
546 struct elf_i386_link_hash_table
*htab
;
548 Elf_Internal_Shdr
*symtab_hdr
;
549 struct elf_link_hash_entry
**sym_hashes
;
550 bfd_signed_vma
*local_got_refcounts
;
551 const Elf_Internal_Rela
*rel
;
552 const Elf_Internal_Rela
*rel_end
;
555 if (info
->relocateable
)
558 htab
= elf_i386_hash_table (info
);
559 dynobj
= htab
->root
.dynobj
;
560 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
561 sym_hashes
= elf_sym_hashes (abfd
);
562 local_got_refcounts
= elf_local_got_refcounts (abfd
);
566 rel_end
= relocs
+ sec
->reloc_count
;
567 for (rel
= relocs
; rel
< rel_end
; rel
++)
569 unsigned long r_symndx
;
570 struct elf_link_hash_entry
*h
;
572 r_symndx
= ELF32_R_SYM (rel
->r_info
);
574 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
576 if (abfd
->my_archive
)
577 (*_bfd_error_handler
) (_("%s(%s): bad symbol index: %d"),
578 bfd_get_filename (abfd
->my_archive
),
579 bfd_get_filename (abfd
),
582 (*_bfd_error_handler
) (_("%s: bad symbol index: %d"),
583 bfd_get_filename (abfd
),
588 if (r_symndx
< symtab_hdr
->sh_info
)
591 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
593 /* Some relocs require a global offset table. */
596 switch (ELF32_R_TYPE (rel
->r_info
))
601 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
602 if (!create_got_section (dynobj
, info
))
611 switch (ELF32_R_TYPE (rel
->r_info
))
614 /* This symbol requires a global offset table entry. */
617 if (h
->got
.refcount
== -1)
619 /* Make sure this symbol is output as a dynamic symbol. */
620 if (h
->dynindx
== -1)
622 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
628 h
->got
.refcount
+= 1;
632 /* This is a global offset table entry for a local symbol. */
633 if (local_got_refcounts
== NULL
)
637 size
= symtab_hdr
->sh_info
* sizeof (bfd_signed_vma
);
638 local_got_refcounts
= ((bfd_signed_vma
*)
639 bfd_alloc (abfd
, size
));
640 if (local_got_refcounts
== NULL
)
642 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
643 memset (local_got_refcounts
, -1, size
);
645 if (local_got_refcounts
[r_symndx
] == -1)
646 local_got_refcounts
[r_symndx
] = 1;
648 local_got_refcounts
[r_symndx
] += 1;
653 /* This symbol requires a procedure linkage table entry. We
654 actually build the entry in adjust_dynamic_symbol,
655 because this might be a case of linking PIC code which is
656 never referenced by a dynamic object, in which case we
657 don't need to generate a procedure linkage table entry
660 /* If this is a local symbol, we resolve it directly without
661 creating a procedure linkage table entry. */
665 if (h
->plt
.refcount
== -1)
667 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
671 h
->plt
.refcount
+= 1;
678 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
682 /* We may need a .plt entry if the function this
683 reloc refers to is in a shared lib. */
684 if (h
->plt
.refcount
== -1)
687 h
->plt
.refcount
+= 1;
691 /* If we are creating a shared library, and this is a reloc
692 against a global symbol, or a non PC relative reloc
693 against a local symbol, then we need to copy the reloc
694 into the shared library. However, if we are linking with
695 -Bsymbolic, we do not need to copy a reloc against a
696 global symbol which is defined in an object we are
697 including in the link (i.e., DEF_REGULAR is set). At
698 this point we have not seen all the input files, so it is
699 possible that DEF_REGULAR is not set now but will be set
700 later (it is never cleared). In case of a weak definition,
701 DEF_REGULAR may be cleared later by a strong definition in
702 a shared library. We account for that possibility below by
703 storing information in the relocs_copied field of the hash
704 table entry. A similar situation occurs when creating
705 shared libraries and symbol visibility changes render 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 /* When creating a shared object, we must copy these
717 reloc types into the output file. We create a reloc
718 section in dynobj and make room for this reloc. */
723 name
= (bfd_elf_string_from_elf_section
725 elf_elfheader (abfd
)->e_shstrndx
,
726 elf_section_data (sec
)->rel_hdr
.sh_name
));
730 if (strncmp (name
, ".rel", 4) != 0
731 || strcmp (bfd_get_section_name (abfd
, sec
),
734 if (abfd
->my_archive
)
735 (*_bfd_error_handler
) (_("%s(%s): bad relocation section name `%s\'"),
736 bfd_get_filename (abfd
->my_archive
),
737 bfd_get_filename (abfd
),
740 (*_bfd_error_handler
) (_("%s: bad relocation section name `%s\'"),
741 bfd_get_filename (abfd
),
745 sreloc
= bfd_get_section_by_name (dynobj
, name
);
750 sreloc
= bfd_make_section (dynobj
, name
);
751 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
752 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
753 if ((sec
->flags
& SEC_ALLOC
) != 0)
754 flags
|= SEC_ALLOC
| SEC_LOAD
;
756 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
757 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
762 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
764 /* If this is a global symbol, we count the number of PC
765 relative relocations we have entered for this symbol,
766 so that we can discard them later as necessary. Note
767 that this function is only called if we are using an
768 elf_i386 linker hash table, which means that h is
769 really a pointer to an elf_i386_link_hash_entry. */
771 && ELF32_R_TYPE (rel
->r_info
) == R_386_PC32
)
773 struct elf_i386_link_hash_entry
*eh
;
774 struct elf_i386_pcrel_relocs_copied
*p
;
776 eh
= (struct elf_i386_link_hash_entry
*) h
;
778 for (p
= eh
->pcrel_relocs_copied
; p
!= NULL
; p
= p
->next
)
779 if (p
->section
== sreloc
)
784 p
= ((struct elf_i386_pcrel_relocs_copied
*)
785 bfd_alloc (dynobj
, sizeof *p
));
788 p
->next
= eh
->pcrel_relocs_copied
;
789 eh
->pcrel_relocs_copied
= p
;
800 /* This relocation describes the C++ object vtable hierarchy.
801 Reconstruct it for later use during GC. */
802 case R_386_GNU_VTINHERIT
:
803 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
807 /* This relocation describes which C++ vtable entries are actually
808 used. Record for later use during GC. */
809 case R_386_GNU_VTENTRY
:
810 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
822 /* Return the section that should be marked against GC for a given
826 elf_i386_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
828 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
829 Elf_Internal_Rela
*rel
;
830 struct elf_link_hash_entry
*h
;
831 Elf_Internal_Sym
*sym
;
835 switch (ELF32_R_TYPE (rel
->r_info
))
837 case R_386_GNU_VTINHERIT
:
838 case R_386_GNU_VTENTRY
:
842 switch (h
->root
.type
)
844 case bfd_link_hash_defined
:
845 case bfd_link_hash_defweak
:
846 return h
->root
.u
.def
.section
;
848 case bfd_link_hash_common
:
849 return h
->root
.u
.c
.p
->section
;
858 if (!(elf_bad_symtab (abfd
)
859 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
860 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
861 && sym
->st_shndx
!= SHN_COMMON
))
863 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
870 /* Update the got entry reference counts for the section being removed. */
873 elf_i386_gc_sweep_hook (abfd
, info
, sec
, relocs
)
875 struct bfd_link_info
*info
;
877 const Elf_Internal_Rela
*relocs
;
879 Elf_Internal_Shdr
*symtab_hdr
;
880 struct elf_link_hash_entry
**sym_hashes
;
881 bfd_signed_vma
*local_got_refcounts
;
882 const Elf_Internal_Rela
*rel
, *relend
;
883 unsigned long r_symndx
;
884 struct elf_link_hash_entry
*h
;
887 dynobj
= elf_hash_table (info
)->dynobj
;
891 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
892 sym_hashes
= elf_sym_hashes (abfd
);
893 local_got_refcounts
= elf_local_got_refcounts (abfd
);
895 relend
= relocs
+ sec
->reloc_count
;
896 for (rel
= relocs
; rel
< relend
; rel
++)
897 switch (ELF32_R_TYPE (rel
->r_info
))
902 r_symndx
= ELF32_R_SYM (rel
->r_info
);
903 if (r_symndx
>= symtab_hdr
->sh_info
)
905 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
906 if (h
->got
.refcount
> 0)
907 h
->got
.refcount
-= 1;
909 else if (local_got_refcounts
!= NULL
)
911 if (local_got_refcounts
[r_symndx
] > 0)
912 local_got_refcounts
[r_symndx
] -= 1;
923 r_symndx
= ELF32_R_SYM (rel
->r_info
);
924 if (r_symndx
>= symtab_hdr
->sh_info
)
926 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
927 if (h
->plt
.refcount
> 0)
928 h
->plt
.refcount
-= 1;
939 /* Adjust a symbol defined by a dynamic object and referenced by a
940 regular object. The current definition is in some section of the
941 dynamic object, but we're not including those sections. We have to
942 change the definition to something the rest of the link can
946 elf_i386_adjust_dynamic_symbol (info
, h
)
947 struct bfd_link_info
*info
;
948 struct elf_link_hash_entry
*h
;
950 struct elf_i386_link_hash_table
*htab
;
953 unsigned int power_of_two
;
955 htab
= elf_i386_hash_table (info
);
956 dynobj
= htab
->root
.dynobj
;
958 /* Make sure we know what is going on here. */
959 BFD_ASSERT (dynobj
!= NULL
960 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
961 || h
->weakdef
!= NULL
962 || ((h
->elf_link_hash_flags
963 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
964 && (h
->elf_link_hash_flags
965 & ELF_LINK_HASH_REF_REGULAR
) != 0
966 && (h
->elf_link_hash_flags
967 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
969 /* If this is a function, put it in the procedure linkage table. We
970 will fill in the contents of the procedure linkage table later,
971 when we know the address of the .got section. */
972 if (h
->type
== STT_FUNC
973 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
975 if (h
->plt
.refcount
<= 0
977 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
978 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0))
980 /* This case can occur if we saw a PLT32 reloc in an input
981 file, but the symbol was never referred to by a dynamic
982 object, or if all references were garbage collected. In
983 such a case, we don't actually need to build a procedure
984 linkage table, and we can just do a PC32 reloc instead. */
985 h
->plt
.refcount
= (bfd_vma
) -1;
986 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
990 /* Make sure this symbol is output as a dynamic symbol. */
991 if (h
->dynindx
== -1)
993 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1000 /* It's possible that we incorrectly decided a .plt reloc was
1001 needed for an R_386_PC32 reloc to a non-function sym in
1002 check_relocs. We can't decide accurately between function and
1003 non-function syms in check-relocs; Objects loaded later in
1004 the link may change h->type. So fix it now. */
1005 h
->plt
.refcount
= (bfd_vma
) -1;
1007 /* If this is a weak symbol, and there is a real definition, the
1008 processor independent code will have arranged for us to see the
1009 real definition first, and we can just use the same value. */
1010 if (h
->weakdef
!= NULL
)
1012 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
1013 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
1014 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
1015 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
1019 /* This is a reference to a symbol defined by a dynamic object which
1020 is not a function. */
1022 /* If we are creating a shared library, we must presume that the
1023 only references to the symbol are via the global offset table.
1024 For such cases we need not do anything here; the relocations will
1025 be handled correctly by relocate_section. */
1029 /* If there are no references to this symbol that do not use the
1030 GOT, we don't need to generate a copy reloc. */
1031 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0)
1034 /* We must allocate the symbol in our .dynbss section, which will
1035 become part of the .bss section of the executable. There will be
1036 an entry for this symbol in the .dynsym section. The dynamic
1037 object will contain position independent code, so all references
1038 from the dynamic object to this symbol will go through the global
1039 offset table. The dynamic linker will use the .dynsym entry to
1040 determine the address it must put in the global offset table, so
1041 both the dynamic object and the regular object will refer to the
1042 same memory location for the variable. */
1045 BFD_ASSERT (s
!= NULL
);
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
;
1056 BFD_ASSERT (srel
!= NULL
);
1057 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
1058 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
1061 /* We need to figure out the alignment required for this symbol. I
1062 have no idea how ELF linkers handle this. */
1063 power_of_two
= bfd_log2 (h
->size
);
1064 if (power_of_two
> 3)
1067 /* Apply the required alignment. */
1068 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
1069 (bfd_size_type
) (1 << power_of_two
));
1070 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
1072 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
1076 /* Define the symbol as being at this point in the section. */
1077 h
->root
.u
.def
.section
= s
;
1078 h
->root
.u
.def
.value
= s
->_raw_size
;
1080 /* Increment the section size to make room for the symbol. */
1081 s
->_raw_size
+= h
->size
;
1086 /* This is the condition under which elf_i386_finish_dynamic_symbol
1087 will be called from elflink.h. If elflink.h doesn't call our
1088 finish_dynamic_symbol routine, we'll need to do something about
1089 initializing any .plt and .got entries in elf_i386_relocate_section. */
1090 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1092 && ((INFO)->shared \
1093 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1094 && ((H)->dynindx != -1 \
1095 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1097 /* Allocate space in .plt, .got and associated reloc sections for
1101 allocate_plt_and_got (h
, inf
)
1102 struct elf_link_hash_entry
*h
;
1105 struct bfd_link_info
*info
;
1106 struct elf_i386_link_hash_table
*htab
;
1109 if (h
->root
.type
== bfd_link_hash_indirect
1110 || h
->root
.type
== bfd_link_hash_warning
)
1113 info
= (struct bfd_link_info
*) inf
;
1114 htab
= elf_i386_hash_table (info
);
1116 if (htab
->root
.dynamic_sections_created
1117 && h
->plt
.refcount
> 0)
1120 BFD_ASSERT (s
!= NULL
);
1122 /* If this is the first .plt entry, make room for the special
1124 if (s
->_raw_size
== 0)
1125 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1127 h
->plt
.offset
= s
->_raw_size
;
1129 /* If this symbol is not defined in a regular file, and we are
1130 not generating a shared library, then set the symbol to this
1131 location in the .plt. This is required to make function
1132 pointers compare as equal between the normal executable and
1133 the shared library. */
1135 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1137 h
->root
.u
.def
.section
= s
;
1138 h
->root
.u
.def
.value
= h
->plt
.offset
;
1141 /* Make room for this entry. */
1142 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1144 /* We also need to make an entry in the .got.plt section, which
1145 will be placed in the .got section by the linker script. */
1147 BFD_ASSERT (s
!= NULL
);
1150 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
, h
))
1152 /* We also need to make an entry in the .rel.plt section. */
1154 BFD_ASSERT (s
!= NULL
);
1155 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
1160 h
->plt
.offset
= (bfd_vma
) -1;
1161 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1164 if (h
->got
.refcount
> 0)
1169 h
->got
.offset
= s
->_raw_size
;
1171 dyn
= htab
->root
.dynamic_sections_created
;
1172 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
))
1173 htab
->srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
1176 h
->got
.offset
= (bfd_vma
) -1;
1181 /* Set the sizes of the dynamic sections. */
1184 elf_i386_size_dynamic_sections (output_bfd
, info
)
1186 struct bfd_link_info
*info
;
1188 struct elf_i386_link_hash_table
*htab
;
1194 htab
= elf_i386_hash_table (info
);
1195 dynobj
= htab
->root
.dynobj
;
1196 BFD_ASSERT (dynobj
!= NULL
);
1198 if (htab
->root
.dynamic_sections_created
)
1202 /* Set the contents of the .interp section to the interpreter. */
1205 s
= bfd_get_section_by_name (dynobj
, ".interp");
1206 BFD_ASSERT (s
!= NULL
);
1207 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1208 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1211 /* Set up .got offsets for local syms. */
1212 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
1214 bfd_signed_vma
*local_got
;
1215 bfd_signed_vma
*end_local_got
;
1216 bfd_size_type locsymcount
;
1217 Elf_Internal_Shdr
*symtab_hdr
;
1220 if (bfd_get_flavour (i
) != bfd_target_elf_flavour
)
1223 local_got
= elf_local_got_refcounts (i
);
1227 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
1228 locsymcount
= symtab_hdr
->sh_info
;
1229 end_local_got
= local_got
+ locsymcount
;
1231 srel
= htab
->srelgot
;
1232 for (; local_got
< end_local_got
; ++local_got
)
1236 *local_got
= s
->_raw_size
;
1239 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
1242 *local_got
= (bfd_vma
) -1;
1247 /* Allocate global sym .plt and .got entries. */
1248 elf_link_hash_traverse (&htab
->root
,
1249 allocate_plt_and_got
,
1252 /* If this is a -Bsymbolic shared link, then we need to discard all
1253 PC relative relocs against symbols defined in a regular object.
1254 We allocated space for them in the check_relocs routine, but we
1255 will not fill them in in the relocate_section routine. */
1257 elf_link_hash_traverse (&htab
->root
,
1261 /* The check_relocs and adjust_dynamic_symbol entry points have
1262 determined the sizes of the various dynamic sections. Allocate
1266 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1268 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1273 || s
== htab
->sgotplt
)
1275 /* Strip this section if we don't need it; see the
1278 else if (strncmp (bfd_get_section_name (dynobj
, s
), ".rel", 4) == 0)
1280 if (s
->_raw_size
== 0)
1282 /* If we don't need this section, strip it from the
1283 output file. This is mostly to handle .rel.bss and
1284 .rel.plt. We must create both sections in
1285 create_dynamic_sections, because they must be created
1286 before the linker maps input sections to output
1287 sections. The linker does that before
1288 adjust_dynamic_symbol is called, and it is that
1289 function which decides whether anything needs to go
1290 into these sections. */
1296 /* Remember whether there are any reloc sections other
1298 if (s
!= htab
->srelplt
)
1300 const char *outname
;
1304 /* If this relocation section applies to a read only
1305 section, then we probably need a DT_TEXTREL
1306 entry. The entries in the .rel.plt section
1307 really apply to the .got section, which we
1308 created ourselves and so know is not readonly. */
1309 outname
= bfd_get_section_name (output_bfd
,
1311 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
1313 && (target
->flags
& SEC_READONLY
) != 0
1314 && (target
->flags
& SEC_ALLOC
) != 0)
1318 /* We use the reloc_count field as a counter if we need
1319 to copy relocs into the output file. */
1325 /* It's not one of our sections, so don't allocate space. */
1329 if (s
->_raw_size
== 0)
1331 _bfd_strip_section_from_output (info
, s
);
1335 /* Allocate memory for the section contents. We use bfd_zalloc
1336 here in case unused entries are not reclaimed before the
1337 section's contents are written out. This should not happen,
1338 but this way if it does, we get a R_386_NONE reloc instead
1340 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1341 if (s
->contents
== NULL
)
1345 if (htab
->root
.dynamic_sections_created
)
1347 /* Add some entries to the .dynamic section. We fill in the
1348 values later, in elf_i386_finish_dynamic_sections, but we
1349 must add the entries now so that we get the correct size for
1350 the .dynamic section. The DT_DEBUG entry is filled in by the
1351 dynamic linker and used by the debugger. */
1354 if (! bfd_elf32_add_dynamic_entry (info
, DT_DEBUG
, 0))
1358 if (htab
->splt
->_raw_size
!= 0)
1360 if (! bfd_elf32_add_dynamic_entry (info
, DT_PLTGOT
, 0)
1361 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
1362 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTREL
, DT_REL
)
1363 || ! bfd_elf32_add_dynamic_entry (info
, DT_JMPREL
, 0))
1369 if (! bfd_elf32_add_dynamic_entry (info
, DT_REL
, 0)
1370 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELSZ
, 0)
1371 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELENT
,
1372 sizeof (Elf32_External_Rel
)))
1378 if (! bfd_elf32_add_dynamic_entry (info
, DT_TEXTREL
, 0))
1380 info
->flags
|= DF_TEXTREL
;
1387 /* This function is called via elf_link_hash_traverse if we are
1388 creating a shared object. In the -Bsymbolic case, it discards the
1389 space allocated to copy PC relative relocs against symbols which
1390 are defined in regular objects. For the normal non-symbolic case,
1391 we also discard space for relocs that have become local due to
1392 symbol visibility changes. We allocated space for them in the
1393 check_relocs routine, but we won't fill them in in the
1394 relocate_section routine. */
1397 discard_copies (h
, inf
)
1398 struct elf_link_hash_entry
*h
;
1401 struct elf_i386_pcrel_relocs_copied
*s
;
1402 struct bfd_link_info
*info
;
1403 struct elf_i386_link_hash_entry
*eh
;
1405 info
= (struct bfd_link_info
*) inf
;
1406 eh
= (struct elf_i386_link_hash_entry
*) h
;
1408 /* If a symbol has been forced local or we have found a regular
1409 definition for the symbolic link case, then we won't be needing
1411 if ((eh
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1412 && ((eh
->root
.elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0
1415 for (s
= eh
->pcrel_relocs_copied
; s
!= NULL
; s
= s
->next
)
1416 s
->section
->_raw_size
-= s
->count
* sizeof (Elf32_External_Rel
);
1422 /* Relocate an i386 ELF section. */
1425 elf_i386_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1426 contents
, relocs
, local_syms
, local_sections
)
1428 struct bfd_link_info
*info
;
1430 asection
*input_section
;
1432 Elf_Internal_Rela
*relocs
;
1433 Elf_Internal_Sym
*local_syms
;
1434 asection
**local_sections
;
1436 struct elf_i386_link_hash_table
*htab
;
1438 Elf_Internal_Shdr
*symtab_hdr
;
1439 struct elf_link_hash_entry
**sym_hashes
;
1440 bfd_vma
*local_got_offsets
;
1442 Elf_Internal_Rela
*rel
;
1443 Elf_Internal_Rela
*relend
;
1445 htab
= elf_i386_hash_table (info
);
1446 dynobj
= htab
->root
.dynobj
;
1447 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1448 sym_hashes
= elf_sym_hashes (input_bfd
);
1449 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1453 relend
= relocs
+ input_section
->reloc_count
;
1454 for (; rel
< relend
; rel
++)
1457 reloc_howto_type
*howto
;
1458 unsigned long r_symndx
;
1459 struct elf_link_hash_entry
*h
;
1460 Elf_Internal_Sym
*sym
;
1463 bfd_reloc_status_type r
;
1466 r_type
= ELF32_R_TYPE (rel
->r_info
);
1467 if (r_type
== (int) R_386_GNU_VTINHERIT
1468 || r_type
== (int) R_386_GNU_VTENTRY
)
1471 if ((indx
= (unsigned) r_type
) >= R_386_standard
1472 && ((indx
= (unsigned) r_type
- R_386_ext_offset
) - R_386_standard
1473 >= R_386_ext
- R_386_standard
))
1475 bfd_set_error (bfd_error_bad_value
);
1478 howto
= elf_howto_table
+ indx
;
1480 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1482 if (info
->relocateable
)
1484 /* This is a relocateable link. We don't have to change
1485 anything, unless the reloc is against a section symbol,
1486 in which case we have to adjust according to where the
1487 section symbol winds up in the output section. */
1488 if (r_symndx
< symtab_hdr
->sh_info
)
1490 sym
= local_syms
+ r_symndx
;
1491 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1495 sec
= local_sections
[r_symndx
];
1496 val
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1497 val
+= sec
->output_offset
+ sym
->st_value
;
1498 bfd_put_32 (input_bfd
, val
, contents
+ rel
->r_offset
);
1505 /* This is a final link. */
1509 if (r_symndx
< symtab_hdr
->sh_info
)
1511 sym
= local_syms
+ r_symndx
;
1512 sec
= local_sections
[r_symndx
];
1513 relocation
= (sec
->output_section
->vma
1514 + sec
->output_offset
1519 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1520 while (h
->root
.type
== bfd_link_hash_indirect
1521 || h
->root
.type
== bfd_link_hash_warning
)
1522 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1524 if (h
->root
.type
== bfd_link_hash_defined
1525 || h
->root
.type
== bfd_link_hash_defweak
)
1527 sec
= h
->root
.u
.def
.section
;
1528 if (r_type
== R_386_GOTPC
1529 || (r_type
== R_386_PLT32
1530 && htab
->splt
!= NULL
1531 && h
->plt
.offset
!= (bfd_vma
) -1)
1532 || (r_type
== R_386_GOT32
1533 && (WILL_CALL_FINISH_DYNAMIC_SYMBOL
1534 (htab
->root
.dynamic_sections_created
, info
, h
))
1538 || (h
->elf_link_hash_flags
1539 & ELF_LINK_FORCED_LOCAL
))
1540 && (h
->elf_link_hash_flags
1541 & ELF_LINK_HASH_DEF_REGULAR
)))
1543 && ((! info
->symbolic
&& h
->dynindx
!= -1)
1544 || (h
->elf_link_hash_flags
1545 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
1546 && (r_type
== R_386_32
1547 || r_type
== R_386_PC32
)
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 Elf_Internal_Rel outrel
;
1736 boolean skip
, relocate
;
1738 /* When generating a shared object, these relocations
1739 are copied into the output file to be resolved at run
1746 name
= (bfd_elf_string_from_elf_section
1748 elf_elfheader (input_bfd
)->e_shstrndx
,
1749 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1753 if (strncmp (name
, ".rel", 4) != 0
1754 || strcmp (bfd_get_section_name (input_bfd
,
1758 if (input_bfd
->my_archive
)
1759 (*_bfd_error_handler
) (_("%s(%s): bad relocation section name `%s\'"),
1760 bfd_get_filename (input_bfd
->my_archive
),
1761 bfd_get_filename (input_bfd
),
1764 (*_bfd_error_handler
) (_("%s: bad relocation section name `%s\'"),
1765 bfd_get_filename (input_bfd
),
1770 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1771 BFD_ASSERT (sreloc
!= NULL
);
1776 if (elf_section_data (input_section
)->stab_info
== NULL
)
1777 outrel
.r_offset
= rel
->r_offset
;
1782 off
= (_bfd_stab_section_offset
1783 (output_bfd
, &elf_hash_table (info
)->stab_info
,
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
1811 || ((info
->symbolic
|| h
->dynindx
== -1)
1812 && (h
->elf_link_hash_flags
1813 & ELF_LINK_HASH_DEF_REGULAR
) != 0))
1816 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1820 BFD_ASSERT (h
->dynindx
!= -1);
1822 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_32
);
1826 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1827 (((Elf32_External_Rel
*)
1829 + sreloc
->reloc_count
));
1830 ++sreloc
->reloc_count
;
1832 /* If this reloc is against an external symbol, we do
1833 not want to fiddle with the addend. Otherwise, we
1834 need to include the symbol value so that it becomes
1835 an addend for the dynamic reloc. */
1846 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1847 contents
, rel
->r_offset
,
1848 relocation
, (bfd_vma
) 0);
1850 if (r
!= bfd_reloc_ok
)
1855 case bfd_reloc_outofrange
:
1857 case bfd_reloc_overflow
:
1862 name
= h
->root
.root
.string
;
1865 name
= bfd_elf_string_from_elf_section (input_bfd
,
1866 symtab_hdr
->sh_link
,
1871 name
= bfd_section_name (input_bfd
, sec
);
1873 if (! ((*info
->callbacks
->reloc_overflow
)
1874 (info
, name
, howto
->name
, (bfd_vma
) 0,
1875 input_bfd
, input_section
, rel
->r_offset
)))
1886 /* Finish up dynamic symbol handling. We set the contents of various
1887 dynamic sections here. */
1890 elf_i386_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
1892 struct bfd_link_info
*info
;
1893 struct elf_link_hash_entry
*h
;
1894 Elf_Internal_Sym
*sym
;
1896 struct elf_i386_link_hash_table
*htab
;
1899 htab
= elf_i386_hash_table (info
);
1900 dynobj
= htab
->root
.dynobj
;
1902 if (h
->plt
.offset
!= (bfd_vma
) -1)
1906 Elf_Internal_Rel rel
;
1908 /* This symbol has an entry in the procedure linkage table. Set
1911 BFD_ASSERT (h
->dynindx
!= -1
1912 && htab
->splt
!= NULL
1913 && htab
->sgotplt
!= NULL
1914 && htab
->srelplt
!= NULL
);
1916 /* Get the index in the procedure linkage table which
1917 corresponds to this symbol. This is the index of this symbol
1918 in all the symbols for which we are making plt entries. The
1919 first entry in the procedure linkage table is reserved. */
1920 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
1922 /* Get the offset into the .got table of the entry that
1923 corresponds to this function. Each .got entry is 4 bytes.
1924 The first three are reserved. */
1925 got_offset
= (plt_index
+ 3) * 4;
1927 /* Fill in the entry in the procedure linkage table. */
1930 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_plt_entry
,
1932 bfd_put_32 (output_bfd
,
1933 (htab
->sgotplt
->output_section
->vma
1934 + htab
->sgotplt
->output_offset
1936 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
1940 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf_i386_pic_plt_entry
,
1942 bfd_put_32 (output_bfd
, got_offset
,
1943 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
1946 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rel
),
1947 htab
->splt
->contents
+ h
->plt
.offset
+ 7);
1948 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
1949 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
1951 /* Fill in the entry in the global offset table. */
1952 bfd_put_32 (output_bfd
,
1953 (htab
->splt
->output_section
->vma
1954 + htab
->splt
->output_offset
1957 htab
->sgotplt
->contents
+ got_offset
);
1959 /* Fill in the entry in the .rel.plt section. */
1960 rel
.r_offset
= (htab
->sgotplt
->output_section
->vma
1961 + htab
->sgotplt
->output_offset
1963 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
1964 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
1965 ((Elf32_External_Rel
*) htab
->srelplt
->contents
1968 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1970 /* Mark the symbol as undefined, rather than as defined in
1971 the .plt section. Leave the value alone. */
1972 sym
->st_shndx
= SHN_UNDEF
;
1976 if (h
->got
.offset
!= (bfd_vma
) -1)
1978 Elf_Internal_Rel rel
;
1980 /* This symbol has an entry in the global offset table. Set it
1983 BFD_ASSERT (htab
->sgot
!= NULL
&& htab
->srelgot
!= NULL
);
1985 rel
.r_offset
= (htab
->sgot
->output_section
->vma
1986 + htab
->sgot
->output_offset
1987 + (h
->got
.offset
&~ 1));
1989 /* If this is a static link, or it is a -Bsymbolic link and the
1990 symbol is defined locally or was forced to be local because
1991 of a version file, we just want to emit a RELATIVE reloc.
1992 The entry in the global offset table will already have been
1993 initialized in the relocate_section function. */
1997 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
1998 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
2000 BFD_ASSERT((h
->got
.offset
& 1) != 0);
2001 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
2005 BFD_ASSERT((h
->got
.offset
& 1) == 0);
2006 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2007 htab
->sgot
->contents
+ h
->got
.offset
);
2008 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
2011 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
2012 ((Elf32_External_Rel
*) htab
->srelgot
->contents
2013 + htab
->srelgot
->reloc_count
));
2014 ++htab
->srelgot
->reloc_count
;
2017 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
2019 Elf_Internal_Rel rel
;
2021 /* This symbol needs a copy reloc. Set it up. */
2023 BFD_ASSERT (h
->dynindx
!= -1
2024 && (h
->root
.type
== bfd_link_hash_defined
2025 || h
->root
.type
== bfd_link_hash_defweak
)
2026 && htab
->srelbss
!= NULL
);
2028 rel
.r_offset
= (h
->root
.u
.def
.value
2029 + h
->root
.u
.def
.section
->output_section
->vma
2030 + h
->root
.u
.def
.section
->output_offset
);
2031 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
2032 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
2033 ((Elf32_External_Rel
*) htab
->srelbss
->contents
2034 + htab
->srelbss
->reloc_count
));
2035 ++htab
->srelbss
->reloc_count
;
2038 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2039 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2040 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2041 sym
->st_shndx
= SHN_ABS
;
2046 /* Finish up the dynamic sections. */
2049 elf_i386_finish_dynamic_sections (output_bfd
, info
)
2051 struct bfd_link_info
*info
;
2053 struct elf_i386_link_hash_table
*htab
;
2057 htab
= elf_i386_hash_table (info
);
2058 dynobj
= htab
->root
.dynobj
;
2060 BFD_ASSERT (htab
->sgot
!= NULL
);
2061 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2063 if (htab
->root
.dynamic_sections_created
)
2065 Elf32_External_Dyn
*dyncon
, *dynconend
;
2067 BFD_ASSERT (sdyn
!= NULL
);
2069 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2070 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
2071 for (; dyncon
< dynconend
; dyncon
++)
2073 Elf_Internal_Dyn dyn
;
2075 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2083 dyn
.d_un
.d_ptr
= htab
->sgot
->output_section
->vma
;
2084 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2088 dyn
.d_un
.d_ptr
= htab
->srelplt
->output_section
->vma
;
2089 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2093 if (htab
->srelplt
->output_section
->_cooked_size
!= 0)
2094 dyn
.d_un
.d_val
= htab
->srelplt
->output_section
->_cooked_size
;
2096 dyn
.d_un
.d_val
= htab
->srelplt
->output_section
->_raw_size
;
2097 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2101 /* My reading of the SVR4 ABI indicates that the
2102 procedure linkage table relocs (DT_JMPREL) should be
2103 included in the overall relocs (DT_REL). This is
2104 what Solaris does. However, UnixWare can not handle
2105 that case. Therefore, we override the DT_RELSZ entry
2106 here to make it not include the JMPREL relocs. Since
2107 the linker script arranges for .rel.plt to follow all
2108 other relocation sections, we don't have to worry
2109 about changing the DT_REL entry. */
2110 if (htab
->srelplt
!= NULL
)
2112 if (htab
->srelplt
->output_section
->_cooked_size
!= 0)
2113 dyn
.d_un
.d_val
-= htab
->srelplt
->output_section
->_cooked_size
;
2115 dyn
.d_un
.d_val
-= htab
->srelplt
->output_section
->_raw_size
;
2117 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2122 /* Fill in the first entry in the procedure linkage table. */
2123 if (htab
->splt
&& htab
->splt
->_raw_size
> 0)
2126 memcpy (htab
->splt
->contents
,
2127 elf_i386_pic_plt0_entry
, PLT_ENTRY_SIZE
);
2130 memcpy (htab
->splt
->contents
,
2131 elf_i386_plt0_entry
, PLT_ENTRY_SIZE
);
2132 bfd_put_32 (output_bfd
,
2133 (htab
->sgotplt
->output_section
->vma
2134 + htab
->sgotplt
->output_offset
2136 htab
->splt
->contents
+ 2);
2137 bfd_put_32 (output_bfd
,
2138 (htab
->sgotplt
->output_section
->vma
2139 + htab
->sgotplt
->output_offset
2141 htab
->splt
->contents
+ 8);
2144 /* UnixWare sets the entsize of .plt to 4, although that doesn't
2145 really seem like the right value. */
2146 elf_section_data (htab
->splt
->output_section
)
2147 ->this_hdr
.sh_entsize
= 4;
2151 /* Fill in the first three entries in the global offset table. */
2152 if (htab
->sgotplt
->_raw_size
> 0)
2154 bfd_put_32 (output_bfd
,
2155 (sdyn
== NULL
? (bfd_vma
) 0
2156 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
2157 htab
->sgotplt
->contents
);
2158 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 4);
2159 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 8);
2162 elf_section_data (htab
->sgotplt
->output_section
)->this_hdr
.sh_entsize
= 4;
2167 /* Set the correct type for an x86 ELF section. We do this by the
2168 section name, which is a hack, but ought to work. */
2171 elf_i386_fake_sections (abfd
, hdr
, sec
)
2172 bfd
*abfd ATTRIBUTE_UNUSED
;
2173 Elf32_Internal_Shdr
*hdr
;
2176 register const char *name
;
2178 name
= bfd_get_section_name (abfd
, sec
);
2180 if (strcmp (name
, ".reloc") == 0)
2182 * This is an ugly, but unfortunately necessary hack that is
2183 * needed when producing EFI binaries on x86. It tells
2184 * elf.c:elf_fake_sections() not to consider ".reloc" as a section
2185 * containing ELF relocation info. We need this hack in order to
2186 * be able to generate ELF binaries that can be translated into
2187 * EFI applications (which are essentially COFF objects). Those
2188 * files contain a COFF ".reloc" section inside an ELFNN object,
2189 * which would normally cause BFD to segfault because it would
2190 * attempt to interpret this section as containing relocation
2191 * entries for section "oc". With this hack enabled, ".reloc"
2192 * will be treated as a normal data section, which will avoid the
2193 * segfault. However, you won't be able to create an ELFNN binary
2194 * with a section named "oc" that needs relocations, but that's
2195 * the kind of ugly side-effects you get when detecting section
2196 * types based on their names... In practice, this limitation is
2199 hdr
->sh_type
= SHT_PROGBITS
;
2205 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
2206 #define TARGET_LITTLE_NAME "elf32-i386"
2207 #define ELF_ARCH bfd_arch_i386
2208 #define ELF_MACHINE_CODE EM_386
2209 #define ELF_MAXPAGESIZE 0x1000
2211 #define elf_backend_can_gc_sections 1
2212 #define elf_backend_want_got_plt 1
2213 #define elf_backend_plt_readonly 1
2214 #define elf_backend_want_plt_sym 0
2215 #define elf_backend_got_header_size 12
2216 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
2218 #define elf_info_to_howto elf_i386_info_to_howto
2219 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
2221 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
2222 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
2223 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
2225 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
2226 #define elf_backend_check_relocs elf_i386_check_relocs
2227 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
2228 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
2229 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
2230 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
2231 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
2232 #define elf_backend_relocate_section elf_i386_relocate_section
2233 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
2234 #define elf_backend_fake_sections elf_i386_fake_sections
2236 #include "elf32-target.h"