* Makefile.in (all-bootstrap): Added all-texinfo and all-zlib.
[binutils.git] / bfd / elf32-i386.c
blob336e889f5f649d04aa39f8782c3280d5ab158a5b
1 /* Intel 80386/80486-specific support for 32-bit ELF
2 Copyright 1993, 94, 95, 96, 97, 98, 99, 2000
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. */
21 #include "bfd.h"
22 #include "sysdep.h"
23 #include "bfdlink.h"
24 #include "libbfd.h"
25 #include "elf-bfd.h"
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
37 PARAMS ((bfd *));
38 static boolean elf_i386_check_relocs
39 PARAMS ((bfd *, struct bfd_link_info *, asection *,
40 const Elf_Internal_Rela *));
41 static boolean elf_i386_adjust_dynamic_symbol
42 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
43 static boolean elf_i386_size_dynamic_sections
44 PARAMS ((bfd *, struct bfd_link_info *));
45 static boolean elf_i386_relocate_section
46 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
47 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
48 static boolean elf_i386_finish_dynamic_symbol
49 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
50 Elf_Internal_Sym *));
51 static boolean elf_i386_finish_dynamic_sections
52 PARAMS ((bfd *, struct bfd_link_info *));
54 #define USE_REL 1 /* 386 uses REL relocations instead of RELA */
56 #include "elf/i386.h"
58 static reloc_howto_type elf_howto_table[]=
60 HOWTO(R_386_NONE, 0, 0, 0, false, 0, complain_overflow_bitfield,
61 bfd_elf_generic_reloc, "R_386_NONE",
62 true, 0x00000000, 0x00000000, false),
63 HOWTO(R_386_32, 0, 2, 32, false, 0, complain_overflow_bitfield,
64 bfd_elf_generic_reloc, "R_386_32",
65 true, 0xffffffff, 0xffffffff, false),
66 HOWTO(R_386_PC32, 0, 2, 32, true, 0, complain_overflow_bitfield,
67 bfd_elf_generic_reloc, "R_386_PC32",
68 true, 0xffffffff, 0xffffffff, true),
69 HOWTO(R_386_GOT32, 0, 2, 32, false, 0, complain_overflow_bitfield,
70 bfd_elf_generic_reloc, "R_386_GOT32",
71 true, 0xffffffff, 0xffffffff, false),
72 HOWTO(R_386_PLT32, 0, 2, 32, true, 0, complain_overflow_bitfield,
73 bfd_elf_generic_reloc, "R_386_PLT32",
74 true, 0xffffffff, 0xffffffff, true),
75 HOWTO(R_386_COPY, 0, 2, 32, false, 0, complain_overflow_bitfield,
76 bfd_elf_generic_reloc, "R_386_COPY",
77 true, 0xffffffff, 0xffffffff, false),
78 HOWTO(R_386_GLOB_DAT, 0, 2, 32, false, 0, complain_overflow_bitfield,
79 bfd_elf_generic_reloc, "R_386_GLOB_DAT",
80 true, 0xffffffff, 0xffffffff, false),
81 HOWTO(R_386_JUMP_SLOT, 0, 2, 32, false, 0, complain_overflow_bitfield,
82 bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
83 true, 0xffffffff, 0xffffffff, false),
84 HOWTO(R_386_RELATIVE, 0, 2, 32, false, 0, complain_overflow_bitfield,
85 bfd_elf_generic_reloc, "R_386_RELATIVE",
86 true, 0xffffffff, 0xffffffff, false),
87 HOWTO(R_386_GOTOFF, 0, 2, 32, false, 0, complain_overflow_bitfield,
88 bfd_elf_generic_reloc, "R_386_GOTOFF",
89 true, 0xffffffff, 0xffffffff, false),
90 HOWTO(R_386_GOTPC, 0, 2, 32, true, 0, complain_overflow_bitfield,
91 bfd_elf_generic_reloc, "R_386_GOTPC",
92 true, 0xffffffff, 0xffffffff, true),
94 /* We have a gap in the reloc numbers here.
95 R_386_standard counts the number up to this point, and
96 R_386_ext_offset is the value to subtract from a reloc type of
97 R_386_16 thru R_386_PC8 to form an index into this table. */
98 #define R_386_standard ((unsigned int) R_386_GOTPC + 1)
99 #define R_386_ext_offset ((unsigned int) R_386_16 - R_386_standard)
101 /* The remaining relocs are a GNU extension. */
102 HOWTO(R_386_16, 0, 1, 16, false, 0, complain_overflow_bitfield,
103 bfd_elf_generic_reloc, "R_386_16",
104 true, 0xffff, 0xffff, false),
105 HOWTO(R_386_PC16, 0, 1, 16, true, 0, complain_overflow_bitfield,
106 bfd_elf_generic_reloc, "R_386_PC16",
107 true, 0xffff, 0xffff, true),
108 HOWTO(R_386_8, 0, 0, 8, false, 0, complain_overflow_bitfield,
109 bfd_elf_generic_reloc, "R_386_8",
110 true, 0xff, 0xff, false),
111 HOWTO(R_386_PC8, 0, 0, 8, true, 0, complain_overflow_signed,
112 bfd_elf_generic_reloc, "R_386_PC8",
113 true, 0xff, 0xff, true),
115 /* Another gap. */
116 #define R_386_ext ((unsigned int) R_386_PC8 + 1 - R_386_ext_offset)
117 #define R_386_vt_offset ((unsigned int) R_386_GNU_VTINHERIT - R_386_ext)
119 /* GNU extension to record C++ vtable hierarchy. */
120 HOWTO (R_386_GNU_VTINHERIT, /* type */
121 0, /* rightshift */
122 2, /* size (0 = byte, 1 = short, 2 = long) */
123 0, /* bitsize */
124 false, /* pc_relative */
125 0, /* bitpos */
126 complain_overflow_dont, /* complain_on_overflow */
127 NULL, /* special_function */
128 "R_386_GNU_VTINHERIT", /* name */
129 false, /* partial_inplace */
130 0, /* src_mask */
131 0, /* dst_mask */
132 false),
134 /* GNU extension to record C++ vtable member usage. */
135 HOWTO (R_386_GNU_VTENTRY, /* type */
136 0, /* rightshift */
137 2, /* size (0 = byte, 1 = short, 2 = long) */
138 0, /* bitsize */
139 false, /* pc_relative */
140 0, /* bitpos */
141 complain_overflow_dont, /* complain_on_overflow */
142 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
143 "R_386_GNU_VTENTRY", /* name */
144 false, /* partial_inplace */
145 0, /* src_mask */
146 0, /* dst_mask */
147 false)
149 #define R_386_vt ((unsigned int) R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
154 #ifdef DEBUG_GEN_RELOC
155 #define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
156 #else
157 #define TRACE(str)
158 #endif
160 static reloc_howto_type *
161 elf_i386_reloc_type_lookup (abfd, code)
162 bfd *abfd ATTRIBUTE_UNUSED;
163 bfd_reloc_code_real_type code;
165 switch (code)
167 case BFD_RELOC_NONE:
168 TRACE ("BFD_RELOC_NONE");
169 return &elf_howto_table[(unsigned int) R_386_NONE ];
171 case BFD_RELOC_32:
172 TRACE ("BFD_RELOC_32");
173 return &elf_howto_table[(unsigned int) R_386_32 ];
175 case BFD_RELOC_CTOR:
176 TRACE ("BFD_RELOC_CTOR");
177 return &elf_howto_table[(unsigned int) R_386_32 ];
179 case BFD_RELOC_32_PCREL:
180 TRACE ("BFD_RELOC_PC32");
181 return &elf_howto_table[(unsigned int) R_386_PC32 ];
183 case BFD_RELOC_386_GOT32:
184 TRACE ("BFD_RELOC_386_GOT32");
185 return &elf_howto_table[(unsigned int) R_386_GOT32 ];
187 case BFD_RELOC_386_PLT32:
188 TRACE ("BFD_RELOC_386_PLT32");
189 return &elf_howto_table[(unsigned int) R_386_PLT32 ];
191 case BFD_RELOC_386_COPY:
192 TRACE ("BFD_RELOC_386_COPY");
193 return &elf_howto_table[(unsigned int) R_386_COPY ];
195 case BFD_RELOC_386_GLOB_DAT:
196 TRACE ("BFD_RELOC_386_GLOB_DAT");
197 return &elf_howto_table[(unsigned int) R_386_GLOB_DAT ];
199 case BFD_RELOC_386_JUMP_SLOT:
200 TRACE ("BFD_RELOC_386_JUMP_SLOT");
201 return &elf_howto_table[(unsigned int) R_386_JUMP_SLOT ];
203 case BFD_RELOC_386_RELATIVE:
204 TRACE ("BFD_RELOC_386_RELATIVE");
205 return &elf_howto_table[(unsigned int) R_386_RELATIVE ];
207 case BFD_RELOC_386_GOTOFF:
208 TRACE ("BFD_RELOC_386_GOTOFF");
209 return &elf_howto_table[(unsigned int) R_386_GOTOFF ];
211 case BFD_RELOC_386_GOTPC:
212 TRACE ("BFD_RELOC_386_GOTPC");
213 return &elf_howto_table[(unsigned int) R_386_GOTPC ];
215 /* The remaining relocs are a GNU extension. */
216 case BFD_RELOC_16:
217 TRACE ("BFD_RELOC_16");
218 return &elf_howto_table[(unsigned int) R_386_16 - R_386_ext_offset];
220 case BFD_RELOC_16_PCREL:
221 TRACE ("BFD_RELOC_16_PCREL");
222 return &elf_howto_table[(unsigned int) R_386_PC16 - R_386_ext_offset];
224 case BFD_RELOC_8:
225 TRACE ("BFD_RELOC_8");
226 return &elf_howto_table[(unsigned int) R_386_8 - R_386_ext_offset];
228 case BFD_RELOC_8_PCREL:
229 TRACE ("BFD_RELOC_8_PCREL");
230 return &elf_howto_table[(unsigned int) R_386_PC8 - R_386_ext_offset];
232 case BFD_RELOC_VTABLE_INHERIT:
233 TRACE ("BFD_RELOC_VTABLE_INHERIT");
234 return &elf_howto_table[(unsigned int) R_386_GNU_VTINHERIT
235 - R_386_vt_offset];
237 case BFD_RELOC_VTABLE_ENTRY:
238 TRACE ("BFD_RELOC_VTABLE_ENTRY");
239 return &elf_howto_table[(unsigned int) R_386_GNU_VTENTRY
240 - R_386_vt_offset];
242 default:
243 break;
246 TRACE ("Unknown");
247 return 0;
250 static void
251 elf_i386_info_to_howto (abfd, cache_ptr, dst)
252 bfd *abfd ATTRIBUTE_UNUSED;
253 arelent *cache_ptr ATTRIBUTE_UNUSED;
254 Elf32_Internal_Rela *dst ATTRIBUTE_UNUSED;
256 abort ();
259 static void
260 elf_i386_info_to_howto_rel (abfd, cache_ptr, dst)
261 bfd *abfd ATTRIBUTE_UNUSED;
262 arelent *cache_ptr;
263 Elf32_Internal_Rel *dst;
265 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
266 unsigned int indx;
268 if ((indx = r_type) >= R_386_standard
269 && ((indx = r_type - R_386_ext_offset) - R_386_standard
270 >= R_386_ext - R_386_standard)
271 && ((indx = r_type - R_386_vt_offset) - R_386_ext
272 >= R_386_vt - R_386_ext))
274 (*_bfd_error_handler) (_("%s: invalid relocation type %d"),
275 bfd_get_filename (abfd), (int) r_type);
276 indx = (unsigned int) R_386_NONE;
278 cache_ptr->howto = &elf_howto_table[indx];
281 /* Return whether a symbol name implies a local label. The UnixWare
282 2.1 cc generates temporary symbols that start with .X, so we
283 recognize them here. FIXME: do other SVR4 compilers also use .X?.
284 If so, we should move the .X recognition into
285 _bfd_elf_is_local_label_name. */
287 static boolean
288 elf_i386_is_local_label_name (abfd, name)
289 bfd *abfd;
290 const char *name;
292 if (name[0] == '.' && name[1] == 'X')
293 return true;
295 return _bfd_elf_is_local_label_name (abfd, name);
298 /* Functions for the i386 ELF linker. */
300 /* The name of the dynamic interpreter. This is put in the .interp
301 section. */
303 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
305 /* The size in bytes of an entry in the procedure linkage table. */
307 #define PLT_ENTRY_SIZE 16
309 /* The first entry in an absolute procedure linkage table looks like
310 this. See the SVR4 ABI i386 supplement to see how this works. */
312 static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] =
314 0xff, 0x35, /* pushl contents of address */
315 0, 0, 0, 0, /* replaced with address of .got + 4. */
316 0xff, 0x25, /* jmp indirect */
317 0, 0, 0, 0, /* replaced with address of .got + 8. */
318 0, 0, 0, 0 /* pad out to 16 bytes. */
321 /* Subsequent entries in an absolute procedure linkage table look like
322 this. */
324 static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
326 0xff, 0x25, /* jmp indirect */
327 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
328 0x68, /* pushl immediate */
329 0, 0, 0, 0, /* replaced with offset into relocation table. */
330 0xe9, /* jmp relative */
331 0, 0, 0, 0 /* replaced with offset to start of .plt. */
334 /* The first entry in a PIC procedure linkage table look like this. */
336 static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] =
338 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
339 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
340 0, 0, 0, 0 /* pad out to 16 bytes. */
343 /* Subsequent entries in a PIC procedure linkage table look like this. */
345 static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
347 0xff, 0xa3, /* jmp *offset(%ebx) */
348 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
349 0x68, /* pushl immediate */
350 0, 0, 0, 0, /* replaced with offset into relocation table. */
351 0xe9, /* jmp relative */
352 0, 0, 0, 0 /* replaced with offset to start of .plt. */
355 /* The i386 linker needs to keep track of the number of relocs that it
356 decides to copy in check_relocs for each symbol. This is so that
357 it can discard PC relative relocs if it doesn't need them when
358 linking with -Bsymbolic. We store the information in a field
359 extending the regular ELF linker hash table. */
361 /* This structure keeps track of the number of PC relative relocs we
362 have copied for a given symbol. */
364 struct elf_i386_pcrel_relocs_copied
366 /* Next section. */
367 struct elf_i386_pcrel_relocs_copied *next;
368 /* A section in dynobj. */
369 asection *section;
370 /* Number of relocs copied in this section. */
371 bfd_size_type count;
374 /* i386 ELF linker hash entry. */
376 struct elf_i386_link_hash_entry
378 struct elf_link_hash_entry root;
380 /* Number of PC relative relocs copied for this symbol. */
381 struct elf_i386_pcrel_relocs_copied *pcrel_relocs_copied;
384 /* i386 ELF linker hash table. */
386 struct elf_i386_link_hash_table
388 struct elf_link_hash_table root;
391 /* Declare this now that the above structures are defined. */
393 static boolean elf_i386_discard_copies
394 PARAMS ((struct elf_i386_link_hash_entry *, PTR));
396 /* Traverse an i386 ELF linker hash table. */
398 #define elf_i386_link_hash_traverse(table, func, info) \
399 (elf_link_hash_traverse \
400 (&(table)->root, \
401 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
402 (info)))
404 /* Get the i386 ELF linker hash table from a link_info structure. */
406 #define elf_i386_hash_table(p) \
407 ((struct elf_i386_link_hash_table *) ((p)->hash))
409 /* Create an entry in an i386 ELF linker hash table. */
411 static struct bfd_hash_entry *
412 elf_i386_link_hash_newfunc (entry, table, string)
413 struct bfd_hash_entry *entry;
414 struct bfd_hash_table *table;
415 const char *string;
417 struct elf_i386_link_hash_entry *ret =
418 (struct elf_i386_link_hash_entry *) entry;
420 /* Allocate the structure if it has not already been allocated by a
421 subclass. */
422 if (ret == (struct elf_i386_link_hash_entry *) NULL)
423 ret = ((struct elf_i386_link_hash_entry *)
424 bfd_hash_allocate (table,
425 sizeof (struct elf_i386_link_hash_entry)));
426 if (ret == (struct elf_i386_link_hash_entry *) NULL)
427 return (struct bfd_hash_entry *) ret;
429 /* Call the allocation method of the superclass. */
430 ret = ((struct elf_i386_link_hash_entry *)
431 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
432 table, string));
433 if (ret != (struct elf_i386_link_hash_entry *) NULL)
435 ret->pcrel_relocs_copied = NULL;
438 return (struct bfd_hash_entry *) ret;
441 /* Create an i386 ELF linker hash table. */
443 static struct bfd_link_hash_table *
444 elf_i386_link_hash_table_create (abfd)
445 bfd *abfd;
447 struct elf_i386_link_hash_table *ret;
449 ret = ((struct elf_i386_link_hash_table *)
450 bfd_alloc (abfd, sizeof (struct elf_i386_link_hash_table)));
451 if (ret == (struct elf_i386_link_hash_table *) NULL)
452 return NULL;
454 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
455 elf_i386_link_hash_newfunc))
457 bfd_release (abfd, ret);
458 return NULL;
461 return &ret->root.root;
464 /* Look through the relocs for a section during the first phase, and
465 allocate space in the global offset table or procedure linkage
466 table. */
468 static boolean
469 elf_i386_check_relocs (abfd, info, sec, relocs)
470 bfd *abfd;
471 struct bfd_link_info *info;
472 asection *sec;
473 const Elf_Internal_Rela *relocs;
475 bfd *dynobj;
476 Elf_Internal_Shdr *symtab_hdr;
477 struct elf_link_hash_entry **sym_hashes;
478 bfd_signed_vma *local_got_refcounts;
479 const Elf_Internal_Rela *rel;
480 const Elf_Internal_Rela *rel_end;
481 asection *sgot;
482 asection *srelgot;
483 asection *sreloc;
485 if (info->relocateable)
486 return true;
488 dynobj = elf_hash_table (info)->dynobj;
489 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
490 sym_hashes = elf_sym_hashes (abfd);
491 local_got_refcounts = elf_local_got_refcounts (abfd);
493 sgot = NULL;
494 srelgot = NULL;
495 sreloc = NULL;
497 rel_end = relocs + sec->reloc_count;
498 for (rel = relocs; rel < rel_end; rel++)
500 unsigned long r_symndx;
501 struct elf_link_hash_entry *h;
503 r_symndx = ELF32_R_SYM (rel->r_info);
505 if (r_symndx < symtab_hdr->sh_info)
506 h = NULL;
507 else
508 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
510 /* Some relocs require a global offset table. */
511 if (dynobj == NULL)
513 switch (ELF32_R_TYPE (rel->r_info))
515 case R_386_GOT32:
516 case R_386_GOTOFF:
517 case R_386_GOTPC:
518 elf_hash_table (info)->dynobj = dynobj = abfd;
519 if (! _bfd_elf_create_got_section (dynobj, info))
520 return false;
521 break;
523 default:
524 break;
528 switch (ELF32_R_TYPE (rel->r_info))
530 case R_386_GOT32:
531 /* This symbol requires a global offset table entry. */
533 if (sgot == NULL)
535 sgot = bfd_get_section_by_name (dynobj, ".got");
536 BFD_ASSERT (sgot != NULL);
539 if (srelgot == NULL
540 && (h != NULL || info->shared))
542 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
543 if (srelgot == NULL)
545 srelgot = bfd_make_section (dynobj, ".rel.got");
546 if (srelgot == NULL
547 || ! bfd_set_section_flags (dynobj, srelgot,
548 (SEC_ALLOC
549 | SEC_LOAD
550 | SEC_HAS_CONTENTS
551 | SEC_IN_MEMORY
552 | SEC_LINKER_CREATED
553 | SEC_READONLY))
554 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
555 return false;
559 if (h != NULL)
561 if (h->got.refcount == -1)
563 h->got.refcount = 1;
565 /* Make sure this symbol is output as a dynamic symbol. */
566 if (h->dynindx == -1)
568 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
569 return false;
572 sgot->_raw_size += 4;
573 srelgot->_raw_size += sizeof (Elf32_External_Rel);
575 else
576 h->got.refcount += 1;
578 else
580 /* This is a global offset table entry for a local symbol. */
581 if (local_got_refcounts == NULL)
583 size_t size;
585 size = symtab_hdr->sh_info * sizeof (bfd_signed_vma);
586 local_got_refcounts = ((bfd_signed_vma *)
587 bfd_alloc (abfd, size));
588 if (local_got_refcounts == NULL)
589 return false;
590 elf_local_got_refcounts (abfd) = local_got_refcounts;
591 memset (local_got_refcounts, -1, size);
593 if (local_got_refcounts[r_symndx] == -1)
595 local_got_refcounts[r_symndx] = 1;
597 sgot->_raw_size += 4;
598 if (info->shared)
600 /* If we are generating a shared object, we need to
601 output a R_386_RELATIVE reloc so that the dynamic
602 linker can adjust this GOT entry. */
603 srelgot->_raw_size += sizeof (Elf32_External_Rel);
606 else
607 local_got_refcounts[r_symndx] += 1;
609 break;
611 case R_386_PLT32:
612 /* This symbol requires a procedure linkage table entry. We
613 actually build the entry in adjust_dynamic_symbol,
614 because this might be a case of linking PIC code which is
615 never referenced by a dynamic object, in which case we
616 don't need to generate a procedure linkage table entry
617 after all. */
619 /* If this is a local symbol, we resolve it directly without
620 creating a procedure linkage table entry. */
621 if (h == NULL)
622 continue;
624 if (h->plt.refcount == -1)
626 h->plt.refcount = 1;
627 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
629 else
630 h->plt.refcount += 1;
631 break;
633 case R_386_32:
634 case R_386_PC32:
635 if (h != NULL)
636 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
638 /* If we are creating a shared library, and this is a reloc
639 against a global symbol, or a non PC relative reloc
640 against a local symbol, then we need to copy the reloc
641 into the shared library. However, if we are linking with
642 -Bsymbolic, we do not need to copy a reloc against a
643 global symbol which is defined in an object we are
644 including in the link (i.e., DEF_REGULAR is set). At
645 this point we have not seen all the input files, so it is
646 possible that DEF_REGULAR is not set now but will be set
647 later (it is never cleared). We account for that
648 possibility below by storing information in the
649 pcrel_relocs_copied field of the hash table entry.
650 A similar situation occurs when creating shared libraries
651 and symbol visibility changes render the symbol local. */
652 if (info->shared
653 && (sec->flags & SEC_ALLOC) != 0
654 && (ELF32_R_TYPE (rel->r_info) != R_386_PC32
655 || (h != NULL
656 && (! info->symbolic
657 || (h->elf_link_hash_flags
658 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
660 /* When creating a shared object, we must copy these
661 reloc types into the output file. We create a reloc
662 section in dynobj and make room for this reloc. */
663 if (sreloc == NULL)
665 const char *name;
667 name = (bfd_elf_string_from_elf_section
668 (abfd,
669 elf_elfheader (abfd)->e_shstrndx,
670 elf_section_data (sec)->rel_hdr.sh_name));
671 if (name == NULL)
672 return false;
674 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
675 && strcmp (bfd_get_section_name (abfd, sec),
676 name + 4) == 0);
678 sreloc = bfd_get_section_by_name (dynobj, name);
679 if (sreloc == NULL)
681 flagword flags;
683 sreloc = bfd_make_section (dynobj, name);
684 flags = (SEC_HAS_CONTENTS | SEC_READONLY
685 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
686 if ((sec->flags & SEC_ALLOC) != 0)
687 flags |= SEC_ALLOC | SEC_LOAD;
688 if (sreloc == NULL
689 || ! bfd_set_section_flags (dynobj, sreloc, flags)
690 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
691 return false;
695 sreloc->_raw_size += sizeof (Elf32_External_Rel);
697 /* If this is a global symbol, we count the number of PC
698 relative relocations we have entered for this symbol,
699 so that we can discard them later as necessary. Note
700 that this function is only called if we are using an
701 elf_i386 linker hash table, which means that h is
702 really a pointer to an elf_i386_link_hash_entry. */
703 if (h != NULL
704 && ELF32_R_TYPE (rel->r_info) == R_386_PC32)
706 struct elf_i386_link_hash_entry *eh;
707 struct elf_i386_pcrel_relocs_copied *p;
709 eh = (struct elf_i386_link_hash_entry *) h;
711 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
712 if (p->section == sreloc)
713 break;
715 if (p == NULL)
717 p = ((struct elf_i386_pcrel_relocs_copied *)
718 bfd_alloc (dynobj, sizeof *p));
719 if (p == NULL)
720 return false;
721 p->next = eh->pcrel_relocs_copied;
722 eh->pcrel_relocs_copied = p;
723 p->section = sreloc;
724 p->count = 0;
727 ++p->count;
731 break;
733 /* This relocation describes the C++ object vtable hierarchy.
734 Reconstruct it for later use during GC. */
735 case R_386_GNU_VTINHERIT:
736 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
737 return false;
738 break;
740 /* This relocation describes which C++ vtable entries are actually
741 used. Record for later use during GC. */
742 case R_386_GNU_VTENTRY:
743 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
744 return false;
745 break;
747 default:
748 break;
752 return true;
755 /* Return the section that should be marked against GC for a given
756 relocation. */
758 static asection *
759 elf_i386_gc_mark_hook (abfd, info, rel, h, sym)
760 bfd *abfd;
761 struct bfd_link_info *info ATTRIBUTE_UNUSED;
762 Elf_Internal_Rela *rel;
763 struct elf_link_hash_entry *h;
764 Elf_Internal_Sym *sym;
766 if (h != NULL)
768 switch (ELF32_R_TYPE (rel->r_info))
770 case R_386_GNU_VTINHERIT:
771 case R_386_GNU_VTENTRY:
772 break;
774 default:
775 switch (h->root.type)
777 case bfd_link_hash_defined:
778 case bfd_link_hash_defweak:
779 return h->root.u.def.section;
781 case bfd_link_hash_common:
782 return h->root.u.c.p->section;
784 default:
785 break;
789 else
791 if (!(elf_bad_symtab (abfd)
792 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
793 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
794 && sym->st_shndx != SHN_COMMON))
796 return bfd_section_from_elf_index (abfd, sym->st_shndx);
800 return NULL;
803 /* Update the got entry reference counts for the section being removed. */
805 static boolean
806 elf_i386_gc_sweep_hook (abfd, info, sec, relocs)
807 bfd *abfd;
808 struct bfd_link_info *info ATTRIBUTE_UNUSED;
809 asection *sec;
810 const Elf_Internal_Rela *relocs;
812 Elf_Internal_Shdr *symtab_hdr;
813 struct elf_link_hash_entry **sym_hashes;
814 bfd_signed_vma *local_got_refcounts;
815 const Elf_Internal_Rela *rel, *relend;
816 unsigned long r_symndx;
817 struct elf_link_hash_entry *h;
818 bfd *dynobj;
819 asection *sgot;
820 asection *srelgot;
822 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
823 sym_hashes = elf_sym_hashes (abfd);
824 local_got_refcounts = elf_local_got_refcounts (abfd);
826 dynobj = elf_hash_table (info)->dynobj;
827 if (dynobj == NULL)
828 return true;
830 sgot = bfd_get_section_by_name (dynobj, ".got");
831 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
833 relend = relocs + sec->reloc_count;
834 for (rel = relocs; rel < relend; rel++)
835 switch (ELF32_R_TYPE (rel->r_info))
837 case R_386_GOT32:
838 case R_386_GOTOFF:
839 case R_386_GOTPC:
840 r_symndx = ELF32_R_SYM (rel->r_info);
841 if (r_symndx >= symtab_hdr->sh_info)
843 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
844 if (h->got.refcount > 0)
846 h->got.refcount -= 1;
847 if (h->got.refcount == 0)
849 sgot->_raw_size -= 4;
850 srelgot->_raw_size -= sizeof (Elf32_External_Rel);
854 else if (local_got_refcounts != NULL)
856 if (local_got_refcounts[r_symndx] > 0)
858 local_got_refcounts[r_symndx] -= 1;
859 if (local_got_refcounts[r_symndx] == 0)
861 sgot->_raw_size -= 4;
862 if (info->shared)
863 srelgot->_raw_size -= sizeof (Elf32_External_Rel);
867 break;
869 case R_386_PLT32:
870 r_symndx = ELF32_R_SYM (rel->r_info);
871 if (r_symndx >= symtab_hdr->sh_info)
873 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
874 if (h->plt.refcount > 0)
875 h->plt.refcount -= 1;
877 break;
879 default:
880 break;
883 return true;
886 /* Adjust a symbol defined by a dynamic object and referenced by a
887 regular object. The current definition is in some section of the
888 dynamic object, but we're not including those sections. We have to
889 change the definition to something the rest of the link can
890 understand. */
892 static boolean
893 elf_i386_adjust_dynamic_symbol (info, h)
894 struct bfd_link_info *info;
895 struct elf_link_hash_entry *h;
897 bfd *dynobj;
898 asection *s;
899 unsigned int power_of_two;
901 dynobj = elf_hash_table (info)->dynobj;
903 /* Make sure we know what is going on here. */
904 BFD_ASSERT (dynobj != NULL
905 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
906 || h->weakdef != NULL
907 || ((h->elf_link_hash_flags
908 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
909 && (h->elf_link_hash_flags
910 & ELF_LINK_HASH_REF_REGULAR) != 0
911 && (h->elf_link_hash_flags
912 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
914 /* If this is a function, put it in the procedure linkage table. We
915 will fill in the contents of the procedure linkage table later,
916 when we know the address of the .got section. */
917 if (h->type == STT_FUNC
918 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
920 if ((! info->shared
921 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
922 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
923 || (info->shared && h->plt.refcount <= 0))
925 /* This case can occur if we saw a PLT32 reloc in an input
926 file, but the symbol was never referred to by a dynamic
927 object, or if all references were garbage collected. In
928 such a case, we don't actually need to build a procedure
929 linkage table, and we can just do a PC32 reloc instead. */
930 h->plt.offset = (bfd_vma) -1;
931 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
932 return true;
935 /* Make sure this symbol is output as a dynamic symbol. */
936 if (h->dynindx == -1)
938 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
939 return false;
942 s = bfd_get_section_by_name (dynobj, ".plt");
943 BFD_ASSERT (s != NULL);
945 /* If this is the first .plt entry, make room for the special
946 first entry. */
947 if (s->_raw_size == 0)
948 s->_raw_size += PLT_ENTRY_SIZE;
950 /* If this symbol is not defined in a regular file, and we are
951 not generating a shared library, then set the symbol to this
952 location in the .plt. This is required to make function
953 pointers compare as equal between the normal executable and
954 the shared library. */
955 if (! info->shared
956 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
958 h->root.u.def.section = s;
959 h->root.u.def.value = s->_raw_size;
962 h->plt.offset = s->_raw_size;
964 /* Make room for this entry. */
965 s->_raw_size += PLT_ENTRY_SIZE;
967 /* We also need to make an entry in the .got.plt section, which
968 will be placed in the .got section by the linker script. */
969 s = bfd_get_section_by_name (dynobj, ".got.plt");
970 BFD_ASSERT (s != NULL);
971 s->_raw_size += 4;
973 /* We also need to make an entry in the .rel.plt section. */
974 s = bfd_get_section_by_name (dynobj, ".rel.plt");
975 BFD_ASSERT (s != NULL);
976 s->_raw_size += sizeof (Elf32_External_Rel);
978 return true;
981 /* If this is a weak symbol, and there is a real definition, the
982 processor independent code will have arranged for us to see the
983 real definition first, and we can just use the same value. */
984 if (h->weakdef != NULL)
986 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
987 || h->weakdef->root.type == bfd_link_hash_defweak);
988 h->root.u.def.section = h->weakdef->root.u.def.section;
989 h->root.u.def.value = h->weakdef->root.u.def.value;
990 return true;
993 /* This is a reference to a symbol defined by a dynamic object which
994 is not a function. */
996 /* If we are creating a shared library, we must presume that the
997 only references to the symbol are via the global offset table.
998 For such cases we need not do anything here; the relocations will
999 be handled correctly by relocate_section. */
1000 if (info->shared)
1001 return true;
1003 /* If there are no references to this symbol that do not use the
1004 GOT, we don't need to generate a copy reloc. */
1005 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
1006 return true;
1008 /* We must allocate the symbol in our .dynbss section, which will
1009 become part of the .bss section of the executable. There will be
1010 an entry for this symbol in the .dynsym section. The dynamic
1011 object will contain position independent code, so all references
1012 from the dynamic object to this symbol will go through the global
1013 offset table. The dynamic linker will use the .dynsym entry to
1014 determine the address it must put in the global offset table, so
1015 both the dynamic object and the regular object will refer to the
1016 same memory location for the variable. */
1018 s = bfd_get_section_by_name (dynobj, ".dynbss");
1019 BFD_ASSERT (s != NULL);
1021 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1022 copy the initial value out of the dynamic object and into the
1023 runtime process image. We need to remember the offset into the
1024 .rel.bss section we are going to use. */
1025 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1027 asection *srel;
1029 srel = bfd_get_section_by_name (dynobj, ".rel.bss");
1030 BFD_ASSERT (srel != NULL);
1031 srel->_raw_size += sizeof (Elf32_External_Rel);
1032 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1035 /* We need to figure out the alignment required for this symbol. I
1036 have no idea how ELF linkers handle this. */
1037 power_of_two = bfd_log2 (h->size);
1038 if (power_of_two > 3)
1039 power_of_two = 3;
1041 /* Apply the required alignment. */
1042 s->_raw_size = BFD_ALIGN (s->_raw_size,
1043 (bfd_size_type) (1 << power_of_two));
1044 if (power_of_two > bfd_get_section_alignment (dynobj, s))
1046 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
1047 return false;
1050 /* Define the symbol as being at this point in the section. */
1051 h->root.u.def.section = s;
1052 h->root.u.def.value = s->_raw_size;
1054 /* Increment the section size to make room for the symbol. */
1055 s->_raw_size += h->size;
1057 return true;
1060 /* Set the sizes of the dynamic sections. */
1062 static boolean
1063 elf_i386_size_dynamic_sections (output_bfd, info)
1064 bfd *output_bfd;
1065 struct bfd_link_info *info;
1067 bfd *dynobj;
1068 asection *s;
1069 boolean plt;
1070 boolean relocs;
1071 boolean reltext;
1073 dynobj = elf_hash_table (info)->dynobj;
1074 BFD_ASSERT (dynobj != NULL);
1076 if (elf_hash_table (info)->dynamic_sections_created)
1078 /* Set the contents of the .interp section to the interpreter. */
1079 if (! info->shared)
1081 s = bfd_get_section_by_name (dynobj, ".interp");
1082 BFD_ASSERT (s != NULL);
1083 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1084 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1087 else
1089 /* We may have created entries in the .rel.got section.
1090 However, if we are not creating the dynamic sections, we will
1091 not actually use these entries. Reset the size of .rel.got,
1092 which will cause it to get stripped from the output file
1093 below. */
1094 s = bfd_get_section_by_name (dynobj, ".rel.got");
1095 if (s != NULL)
1096 s->_raw_size = 0;
1099 /* If this is a -Bsymbolic shared link, then we need to discard all
1100 PC relative relocs against symbols defined in a regular object.
1101 We allocated space for them in the check_relocs routine, but we
1102 will not fill them in in the relocate_section routine. */
1103 if (info->shared)
1104 elf_i386_link_hash_traverse (elf_i386_hash_table (info),
1105 elf_i386_discard_copies,
1106 (PTR) info);
1108 /* The check_relocs and adjust_dynamic_symbol entry points have
1109 determined the sizes of the various dynamic sections. Allocate
1110 memory for them. */
1111 plt = false;
1112 relocs = false;
1113 reltext = false;
1114 for (s = dynobj->sections; s != NULL; s = s->next)
1116 const char *name;
1117 boolean strip;
1119 if ((s->flags & SEC_LINKER_CREATED) == 0)
1120 continue;
1122 /* It's OK to base decisions on the section name, because none
1123 of the dynobj section names depend upon the input files. */
1124 name = bfd_get_section_name (dynobj, s);
1126 strip = false;
1128 if (strcmp (name, ".plt") == 0)
1130 if (s->_raw_size == 0)
1132 /* Strip this section if we don't need it; see the
1133 comment below. */
1134 strip = true;
1136 else
1138 /* Remember whether there is a PLT. */
1139 plt = true;
1142 else if (strncmp (name, ".rel", 4) == 0)
1144 if (s->_raw_size == 0)
1146 /* If we don't need this section, strip it from the
1147 output file. This is mostly to handle .rel.bss and
1148 .rel.plt. We must create both sections in
1149 create_dynamic_sections, because they must be created
1150 before the linker maps input sections to output
1151 sections. The linker does that before
1152 adjust_dynamic_symbol is called, and it is that
1153 function which decides whether anything needs to go
1154 into these sections. */
1155 strip = true;
1157 else
1159 asection *target;
1161 /* Remember whether there are any reloc sections other
1162 than .rel.plt. */
1163 if (strcmp (name, ".rel.plt") != 0)
1165 const char *outname;
1167 relocs = true;
1169 /* If this relocation section applies to a read only
1170 section, then we probably need a DT_TEXTREL
1171 entry. The entries in the .rel.plt section
1172 really apply to the .got section, which we
1173 created ourselves and so know is not readonly. */
1174 outname = bfd_get_section_name (output_bfd,
1175 s->output_section);
1176 target = bfd_get_section_by_name (output_bfd, outname + 4);
1177 if (target != NULL
1178 && (target->flags & SEC_READONLY) != 0
1179 && (target->flags & SEC_ALLOC) != 0)
1180 reltext = true;
1183 /* We use the reloc_count field as a counter if we need
1184 to copy relocs into the output file. */
1185 s->reloc_count = 0;
1188 else if (strncmp (name, ".got", 4) != 0)
1190 /* It's not one of our sections, so don't allocate space. */
1191 continue;
1194 if (strip)
1196 _bfd_strip_section_from_output (info, s);
1197 continue;
1200 /* Allocate memory for the section contents. We use bfd_zalloc
1201 here in case unused entries are not reclaimed before the
1202 section's contents are written out. This should not happen,
1203 but this way if it does, we get a R_386_NONE reloc instead
1204 of garbage. */
1205 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1206 if (s->contents == NULL && s->_raw_size != 0)
1207 return false;
1210 if (elf_hash_table (info)->dynamic_sections_created)
1212 /* Add some entries to the .dynamic section. We fill in the
1213 values later, in elf_i386_finish_dynamic_sections, but we
1214 must add the entries now so that we get the correct size for
1215 the .dynamic section. The DT_DEBUG entry is filled in by the
1216 dynamic linker and used by the debugger. */
1217 if (! info->shared)
1219 if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
1220 return false;
1223 if (plt)
1225 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
1226 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
1227 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL)
1228 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
1229 return false;
1232 if (relocs)
1234 if (! bfd_elf32_add_dynamic_entry (info, DT_REL, 0)
1235 || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0)
1236 || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
1237 sizeof (Elf32_External_Rel)))
1238 return false;
1241 if (reltext)
1243 if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
1244 return false;
1245 info->flags |= DF_TEXTREL;
1249 return true;
1252 /* This function is called via elf_i386_link_hash_traverse if we are
1253 creating a shared object. In the -Bsymbolic case, it discards the
1254 space allocated to copy PC relative relocs against symbols which
1255 are defined in regular objects. For the normal non-symbolic case,
1256 we also discard space for relocs that have become local due to
1257 symbol visibility changes. We allocated space for them in the
1258 check_relocs routine, but we won't fill them in in the
1259 relocate_section routine. */
1261 /*ARGSUSED*/
1262 static boolean
1263 elf_i386_discard_copies (h, inf)
1264 struct elf_i386_link_hash_entry *h;
1265 PTR inf;
1267 struct elf_i386_pcrel_relocs_copied *s;
1268 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1270 /* If a symbol has been forced local or we have found a regular
1271 definition for the symbolic link case, then we won't be needing
1272 any relocs. */
1273 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1274 && ((h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1275 || info->symbolic))
1277 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
1278 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
1281 return true;
1284 /* Relocate an i386 ELF section. */
1286 static boolean
1287 elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
1288 contents, relocs, local_syms, local_sections)
1289 bfd *output_bfd;
1290 struct bfd_link_info *info;
1291 bfd *input_bfd;
1292 asection *input_section;
1293 bfd_byte *contents;
1294 Elf_Internal_Rela *relocs;
1295 Elf_Internal_Sym *local_syms;
1296 asection **local_sections;
1298 bfd *dynobj;
1299 Elf_Internal_Shdr *symtab_hdr;
1300 struct elf_link_hash_entry **sym_hashes;
1301 bfd_vma *local_got_offsets;
1302 asection *sgot;
1303 asection *splt;
1304 asection *sreloc;
1305 Elf_Internal_Rela *rel;
1306 Elf_Internal_Rela *relend;
1308 dynobj = elf_hash_table (info)->dynobj;
1309 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1310 sym_hashes = elf_sym_hashes (input_bfd);
1311 local_got_offsets = elf_local_got_offsets (input_bfd);
1313 sreloc = NULL;
1314 splt = NULL;
1315 sgot = NULL;
1316 if (dynobj != NULL)
1318 splt = bfd_get_section_by_name (dynobj, ".plt");
1319 sgot = bfd_get_section_by_name (dynobj, ".got");
1322 rel = relocs;
1323 relend = relocs + input_section->reloc_count;
1324 for (; rel < relend; rel++)
1326 int r_type;
1327 reloc_howto_type *howto;
1328 unsigned long r_symndx;
1329 struct elf_link_hash_entry *h;
1330 Elf_Internal_Sym *sym;
1331 asection *sec;
1332 bfd_vma relocation;
1333 bfd_reloc_status_type r;
1334 unsigned int indx;
1336 r_type = ELF32_R_TYPE (rel->r_info);
1337 if (r_type == (int) R_386_GNU_VTINHERIT
1338 || r_type == (int) R_386_GNU_VTENTRY)
1339 continue;
1341 if ((indx = (unsigned) r_type) >= R_386_standard
1342 && ((indx = (unsigned) r_type - R_386_ext_offset) - R_386_standard
1343 >= R_386_ext - R_386_standard))
1345 bfd_set_error (bfd_error_bad_value);
1346 return false;
1348 howto = elf_howto_table + indx;
1350 r_symndx = ELF32_R_SYM (rel->r_info);
1352 if (info->relocateable)
1354 /* This is a relocateable link. We don't have to change
1355 anything, unless the reloc is against a section symbol,
1356 in which case we have to adjust according to where the
1357 section symbol winds up in the output section. */
1358 if (r_symndx < symtab_hdr->sh_info)
1360 sym = local_syms + r_symndx;
1361 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1363 bfd_vma val;
1365 sec = local_sections[r_symndx];
1366 val = bfd_get_32 (input_bfd, contents + rel->r_offset);
1367 val += sec->output_offset + sym->st_value;
1368 bfd_put_32 (input_bfd, val, contents + rel->r_offset);
1372 continue;
1375 /* This is a final link. */
1376 h = NULL;
1377 sym = NULL;
1378 sec = NULL;
1379 if (r_symndx < symtab_hdr->sh_info)
1381 sym = local_syms + r_symndx;
1382 sec = local_sections[r_symndx];
1383 relocation = (sec->output_section->vma
1384 + sec->output_offset
1385 + sym->st_value);
1387 else
1389 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1390 while (h->root.type == bfd_link_hash_indirect
1391 || h->root.type == bfd_link_hash_warning)
1392 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1393 if (h->root.type == bfd_link_hash_defined
1394 || h->root.type == bfd_link_hash_defweak)
1396 sec = h->root.u.def.section;
1397 if (r_type == R_386_GOTPC
1398 || (r_type == R_386_PLT32
1399 && splt != NULL
1400 && h->plt.offset != (bfd_vma) -1)
1401 || (r_type == R_386_GOT32
1402 && elf_hash_table (info)->dynamic_sections_created
1403 && (! info->shared
1404 || (! info->symbolic && h->dynindx != -1)
1405 || (h->elf_link_hash_flags
1406 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1407 || (info->shared
1408 && ((! info->symbolic && h->dynindx != -1)
1409 || (h->elf_link_hash_flags
1410 & ELF_LINK_HASH_DEF_REGULAR) == 0)
1411 && (r_type == R_386_32
1412 || r_type == R_386_PC32)
1413 && ((input_section->flags & SEC_ALLOC) != 0
1414 /* DWARF will emit R_386_32 relocations in its
1415 sections against symbols defined externally
1416 in shared libraries. We can't do anything
1417 with them here. */
1418 || ((input_section->flags & SEC_DEBUGGING) != 0
1419 && (h->elf_link_hash_flags
1420 & ELF_LINK_HASH_DEF_DYNAMIC) != 0))))
1422 /* In these cases, we don't need the relocation
1423 value. We check specially because in some
1424 obscure cases sec->output_section will be NULL. */
1425 relocation = 0;
1427 else if (sec->output_section == NULL)
1429 (*_bfd_error_handler)
1430 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1431 bfd_get_filename (input_bfd), h->root.root.string,
1432 bfd_get_section_name (input_bfd, input_section));
1433 relocation = 0;
1435 else
1436 relocation = (h->root.u.def.value
1437 + sec->output_section->vma
1438 + sec->output_offset);
1440 else if (h->root.type == bfd_link_hash_undefweak)
1441 relocation = 0;
1442 else if (info->shared && !info->symbolic
1443 && !info->no_undefined
1444 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1445 relocation = 0;
1446 else
1448 if (! ((*info->callbacks->undefined_symbol)
1449 (info, h->root.root.string, input_bfd,
1450 input_section, rel->r_offset,
1451 (!info->shared || info->no_undefined
1452 || ELF_ST_VISIBILITY (h->other)))))
1453 return false;
1454 relocation = 0;
1458 switch (r_type)
1460 case R_386_GOT32:
1461 /* Relocation is to the entry for this symbol in the global
1462 offset table. */
1463 BFD_ASSERT (sgot != NULL);
1465 if (h != NULL)
1467 bfd_vma off;
1469 off = h->got.offset;
1470 BFD_ASSERT (off != (bfd_vma) -1);
1472 if (! elf_hash_table (info)->dynamic_sections_created
1473 || (info->shared
1474 && (info->symbolic || h->dynindx == -1)
1475 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1477 /* This is actually a static link, or it is a
1478 -Bsymbolic link and the symbol is defined
1479 locally, or the symbol was forced to be local
1480 because of a version file. We must initialize
1481 this entry in the global offset table. Since the
1482 offset must always be a multiple of 4, we use the
1483 least significant bit to record whether we have
1484 initialized it already.
1486 When doing a dynamic link, we create a .rel.got
1487 relocation entry to initialize the value. This
1488 is done in the finish_dynamic_symbol routine. */
1489 if ((off & 1) != 0)
1490 off &= ~1;
1491 else
1493 bfd_put_32 (output_bfd, relocation,
1494 sgot->contents + off);
1495 h->got.offset |= 1;
1499 relocation = sgot->output_offset + off;
1501 else
1503 bfd_vma off;
1505 BFD_ASSERT (local_got_offsets != NULL
1506 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1508 off = local_got_offsets[r_symndx];
1510 /* The offset must always be a multiple of 4. We use
1511 the least significant bit to record whether we have
1512 already generated the necessary reloc. */
1513 if ((off & 1) != 0)
1514 off &= ~1;
1515 else
1517 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1519 if (info->shared)
1521 asection *srelgot;
1522 Elf_Internal_Rel outrel;
1524 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
1525 BFD_ASSERT (srelgot != NULL);
1527 outrel.r_offset = (sgot->output_section->vma
1528 + sgot->output_offset
1529 + off);
1530 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1531 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1532 (((Elf32_External_Rel *)
1533 srelgot->contents)
1534 + srelgot->reloc_count));
1535 ++srelgot->reloc_count;
1538 local_got_offsets[r_symndx] |= 1;
1541 relocation = sgot->output_offset + off;
1544 break;
1546 case R_386_GOTOFF:
1547 /* Relocation is relative to the start of the global offset
1548 table. */
1550 if (sgot == NULL)
1552 sgot = bfd_get_section_by_name (dynobj, ".got");
1553 BFD_ASSERT (sgot != NULL);
1556 /* Note that sgot->output_offset is not involved in this
1557 calculation. We always want the start of .got. If we
1558 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1559 permitted by the ABI, we might have to change this
1560 calculation. */
1561 relocation -= sgot->output_section->vma;
1563 break;
1565 case R_386_GOTPC:
1566 /* Use global offset table as symbol value. */
1568 if (sgot == NULL)
1570 sgot = bfd_get_section_by_name (dynobj, ".got");
1571 BFD_ASSERT (sgot != NULL);
1574 relocation = sgot->output_section->vma;
1576 break;
1578 case R_386_PLT32:
1579 /* Relocation is to the entry for this symbol in the
1580 procedure linkage table. */
1582 /* Resolve a PLT32 reloc against a local symbol directly,
1583 without using the procedure linkage table. */
1584 if (h == NULL)
1585 break;
1587 if (h->plt.offset == (bfd_vma) -1
1588 || splt == NULL)
1590 /* We didn't make a PLT entry for this symbol. This
1591 happens when statically linking PIC code, or when
1592 using -Bsymbolic. */
1593 break;
1596 relocation = (splt->output_section->vma
1597 + splt->output_offset
1598 + h->plt.offset);
1600 break;
1602 case R_386_32:
1603 case R_386_PC32:
1604 if (info->shared
1605 && (input_section->flags & SEC_ALLOC) != 0
1606 && (r_type != R_386_PC32
1607 || (h != NULL
1608 && h->dynindx != -1
1609 && (! info->symbolic
1610 || (h->elf_link_hash_flags
1611 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1613 Elf_Internal_Rel outrel;
1614 boolean skip, relocate;
1616 /* When generating a shared object, these relocations
1617 are copied into the output file to be resolved at run
1618 time. */
1620 if (sreloc == NULL)
1622 const char *name;
1624 name = (bfd_elf_string_from_elf_section
1625 (input_bfd,
1626 elf_elfheader (input_bfd)->e_shstrndx,
1627 elf_section_data (input_section)->rel_hdr.sh_name));
1628 if (name == NULL)
1629 return false;
1631 BFD_ASSERT (strncmp (name, ".rel", 4) == 0
1632 && strcmp (bfd_get_section_name (input_bfd,
1633 input_section),
1634 name + 4) == 0);
1636 sreloc = bfd_get_section_by_name (dynobj, name);
1637 BFD_ASSERT (sreloc != NULL);
1640 skip = false;
1642 if (elf_section_data (input_section)->stab_info == NULL)
1643 outrel.r_offset = rel->r_offset;
1644 else
1646 bfd_vma off;
1648 off = (_bfd_stab_section_offset
1649 (output_bfd, &elf_hash_table (info)->stab_info,
1650 input_section,
1651 &elf_section_data (input_section)->stab_info,
1652 rel->r_offset));
1653 if (off == (bfd_vma) -1)
1654 skip = true;
1655 outrel.r_offset = off;
1658 outrel.r_offset += (input_section->output_section->vma
1659 + input_section->output_offset);
1661 if (skip)
1663 memset (&outrel, 0, sizeof outrel);
1664 relocate = false;
1666 else if (r_type == R_386_PC32)
1668 BFD_ASSERT (h != NULL && h->dynindx != -1);
1669 relocate = false;
1670 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_PC32);
1672 else
1674 /* h->dynindx may be -1 if this symbol was marked to
1675 become local. */
1676 if (h == NULL
1677 || ((info->symbolic || h->dynindx == -1)
1678 && (h->elf_link_hash_flags
1679 & ELF_LINK_HASH_DEF_REGULAR) != 0))
1681 relocate = true;
1682 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1684 else
1686 BFD_ASSERT (h->dynindx != -1);
1687 relocate = false;
1688 outrel.r_info = ELF32_R_INFO (h->dynindx, R_386_32);
1692 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1693 (((Elf32_External_Rel *)
1694 sreloc->contents)
1695 + sreloc->reloc_count));
1696 ++sreloc->reloc_count;
1698 /* If this reloc is against an external symbol, we do
1699 not want to fiddle with the addend. Otherwise, we
1700 need to include the symbol value so that it becomes
1701 an addend for the dynamic reloc. */
1702 if (! relocate)
1703 continue;
1706 break;
1708 default:
1709 break;
1712 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1713 contents, rel->r_offset,
1714 relocation, (bfd_vma) 0);
1716 if (r != bfd_reloc_ok)
1718 switch (r)
1720 default:
1721 case bfd_reloc_outofrange:
1722 abort ();
1723 case bfd_reloc_overflow:
1725 const char *name;
1727 if (h != NULL)
1728 name = h->root.root.string;
1729 else
1731 name = bfd_elf_string_from_elf_section (input_bfd,
1732 symtab_hdr->sh_link,
1733 sym->st_name);
1734 if (name == NULL)
1735 return false;
1736 if (*name == '\0')
1737 name = bfd_section_name (input_bfd, sec);
1739 if (! ((*info->callbacks->reloc_overflow)
1740 (info, name, howto->name, (bfd_vma) 0,
1741 input_bfd, input_section, rel->r_offset)))
1742 return false;
1744 break;
1749 return true;
1752 /* Finish up dynamic symbol handling. We set the contents of various
1753 dynamic sections here. */
1755 static boolean
1756 elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
1757 bfd *output_bfd;
1758 struct bfd_link_info *info;
1759 struct elf_link_hash_entry *h;
1760 Elf_Internal_Sym *sym;
1762 bfd *dynobj;
1764 dynobj = elf_hash_table (info)->dynobj;
1766 if (h->plt.offset != (bfd_vma) -1)
1768 asection *splt;
1769 asection *sgot;
1770 asection *srel;
1771 bfd_vma plt_index;
1772 bfd_vma got_offset;
1773 Elf_Internal_Rel rel;
1775 /* This symbol has an entry in the procedure linkage table. Set
1776 it up. */
1778 BFD_ASSERT (h->dynindx != -1);
1780 splt = bfd_get_section_by_name (dynobj, ".plt");
1781 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1782 srel = bfd_get_section_by_name (dynobj, ".rel.plt");
1783 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
1785 /* Get the index in the procedure linkage table which
1786 corresponds to this symbol. This is the index of this symbol
1787 in all the symbols for which we are making plt entries. The
1788 first entry in the procedure linkage table is reserved. */
1789 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1791 /* Get the offset into the .got table of the entry that
1792 corresponds to this function. Each .got entry is 4 bytes.
1793 The first three are reserved. */
1794 got_offset = (plt_index + 3) * 4;
1796 /* Fill in the entry in the procedure linkage table. */
1797 if (! info->shared)
1799 memcpy (splt->contents + h->plt.offset, elf_i386_plt_entry,
1800 PLT_ENTRY_SIZE);
1801 bfd_put_32 (output_bfd,
1802 (sgot->output_section->vma
1803 + sgot->output_offset
1804 + got_offset),
1805 splt->contents + h->plt.offset + 2);
1807 else
1809 memcpy (splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
1810 PLT_ENTRY_SIZE);
1811 bfd_put_32 (output_bfd, got_offset,
1812 splt->contents + h->plt.offset + 2);
1815 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
1816 splt->contents + h->plt.offset + 7);
1817 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
1818 splt->contents + h->plt.offset + 12);
1820 /* Fill in the entry in the global offset table. */
1821 bfd_put_32 (output_bfd,
1822 (splt->output_section->vma
1823 + splt->output_offset
1824 + h->plt.offset
1825 + 6),
1826 sgot->contents + got_offset);
1828 /* Fill in the entry in the .rel.plt section. */
1829 rel.r_offset = (sgot->output_section->vma
1830 + sgot->output_offset
1831 + got_offset);
1832 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
1833 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1834 ((Elf32_External_Rel *) srel->contents
1835 + plt_index));
1837 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1839 /* Mark the symbol as undefined, rather than as defined in
1840 the .plt section. Leave the value alone. */
1841 sym->st_shndx = SHN_UNDEF;
1845 if (h->got.offset != (bfd_vma) -1)
1847 asection *sgot;
1848 asection *srel;
1849 Elf_Internal_Rel rel;
1851 /* This symbol has an entry in the global offset table. Set it
1852 up. */
1854 sgot = bfd_get_section_by_name (dynobj, ".got");
1855 srel = bfd_get_section_by_name (dynobj, ".rel.got");
1856 BFD_ASSERT (sgot != NULL && srel != NULL);
1858 rel.r_offset = (sgot->output_section->vma
1859 + sgot->output_offset
1860 + (h->got.offset &~ 1));
1862 /* If this is a static link, or it is a -Bsymbolic link and the
1863 symbol is defined locally or was forced to be local because
1864 of a version file, we just want to emit a RELATIVE reloc.
1865 The entry in the global offset table will already have been
1866 initialized in the relocate_section function. */
1867 if (! elf_hash_table (info)->dynamic_sections_created
1868 || (info->shared
1869 && (info->symbolic || h->dynindx == -1)
1870 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1872 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
1874 else
1876 BFD_ASSERT((h->got.offset & 1) == 0);
1877 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1878 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
1881 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1882 ((Elf32_External_Rel *) srel->contents
1883 + srel->reloc_count));
1884 ++srel->reloc_count;
1887 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1889 asection *s;
1890 Elf_Internal_Rel rel;
1892 /* This symbol needs a copy reloc. Set it up. */
1894 BFD_ASSERT (h->dynindx != -1
1895 && (h->root.type == bfd_link_hash_defined
1896 || h->root.type == bfd_link_hash_defweak));
1898 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1899 ".rel.bss");
1900 BFD_ASSERT (s != NULL);
1902 rel.r_offset = (h->root.u.def.value
1903 + h->root.u.def.section->output_section->vma
1904 + h->root.u.def.section->output_offset);
1905 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
1906 bfd_elf32_swap_reloc_out (output_bfd, &rel,
1907 ((Elf32_External_Rel *) s->contents
1908 + s->reloc_count));
1909 ++s->reloc_count;
1912 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1913 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1914 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1915 sym->st_shndx = SHN_ABS;
1917 return true;
1920 /* Finish up the dynamic sections. */
1922 static boolean
1923 elf_i386_finish_dynamic_sections (output_bfd, info)
1924 bfd *output_bfd;
1925 struct bfd_link_info *info;
1927 bfd *dynobj;
1928 asection *sgot;
1929 asection *sdyn;
1931 dynobj = elf_hash_table (info)->dynobj;
1933 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1934 BFD_ASSERT (sgot != NULL);
1935 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1937 if (elf_hash_table (info)->dynamic_sections_created)
1939 asection *splt;
1940 Elf32_External_Dyn *dyncon, *dynconend;
1942 BFD_ASSERT (sdyn != NULL);
1944 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1945 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1946 for (; dyncon < dynconend; dyncon++)
1948 Elf_Internal_Dyn dyn;
1949 const char *name;
1950 asection *s;
1952 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1954 switch (dyn.d_tag)
1956 default:
1957 break;
1959 case DT_PLTGOT:
1960 name = ".got";
1961 goto get_vma;
1962 case DT_JMPREL:
1963 name = ".rel.plt";
1964 get_vma:
1965 s = bfd_get_section_by_name (output_bfd, name);
1966 BFD_ASSERT (s != NULL);
1967 dyn.d_un.d_ptr = s->vma;
1968 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1969 break;
1971 case DT_PLTRELSZ:
1972 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
1973 BFD_ASSERT (s != NULL);
1974 if (s->_cooked_size != 0)
1975 dyn.d_un.d_val = s->_cooked_size;
1976 else
1977 dyn.d_un.d_val = s->_raw_size;
1978 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1979 break;
1981 case DT_RELSZ:
1982 /* My reading of the SVR4 ABI indicates that the
1983 procedure linkage table relocs (DT_JMPREL) should be
1984 included in the overall relocs (DT_REL). This is
1985 what Solaris does. However, UnixWare can not handle
1986 that case. Therefore, we override the DT_RELSZ entry
1987 here to make it not include the JMPREL relocs. Since
1988 the linker script arranges for .rel.plt to follow all
1989 other relocation sections, we don't have to worry
1990 about changing the DT_REL entry. */
1991 s = bfd_get_section_by_name (output_bfd, ".rel.plt");
1992 if (s != NULL)
1994 if (s->_cooked_size != 0)
1995 dyn.d_un.d_val -= s->_cooked_size;
1996 else
1997 dyn.d_un.d_val -= s->_raw_size;
1999 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2000 break;
2004 /* Fill in the first entry in the procedure linkage table. */
2005 splt = bfd_get_section_by_name (dynobj, ".plt");
2006 if (splt && splt->_raw_size > 0)
2008 if (info->shared)
2009 memcpy (splt->contents, elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
2010 else
2012 memcpy (splt->contents, elf_i386_plt0_entry, PLT_ENTRY_SIZE);
2013 bfd_put_32 (output_bfd,
2014 sgot->output_section->vma + sgot->output_offset + 4,
2015 splt->contents + 2);
2016 bfd_put_32 (output_bfd,
2017 sgot->output_section->vma + sgot->output_offset + 8,
2018 splt->contents + 8);
2021 /* UnixWare sets the entsize of .plt to 4, although that doesn't
2022 really seem like the right value. */
2023 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
2027 /* Fill in the first three entries in the global offset table. */
2028 if (sgot->_raw_size > 0)
2030 if (sdyn == NULL)
2031 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2032 else
2033 bfd_put_32 (output_bfd,
2034 sdyn->output_section->vma + sdyn->output_offset,
2035 sgot->contents);
2036 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
2037 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
2040 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2042 return true;
2045 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
2046 #define TARGET_LITTLE_NAME "elf32-i386"
2047 #define ELF_ARCH bfd_arch_i386
2048 #define ELF_MACHINE_CODE EM_386
2049 #define ELF_MAXPAGESIZE 0x1000
2051 #define elf_backend_can_gc_sections 1
2052 #define elf_backend_want_got_plt 1
2053 #define elf_backend_plt_readonly 1
2054 #define elf_backend_want_plt_sym 0
2055 #define elf_backend_got_header_size 12
2056 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
2058 #define elf_info_to_howto elf_i386_info_to_howto
2059 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
2061 #define bfd_elf32_bfd_final_link _bfd_elf32_gc_common_final_link
2062 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
2063 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
2064 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
2066 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
2067 #define elf_backend_check_relocs elf_i386_check_relocs
2068 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
2069 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
2070 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
2071 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
2072 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
2073 #define elf_backend_relocate_section elf_i386_relocate_section
2074 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
2076 #include "elf32-target.h"