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 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
*,
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 */
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),
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 */
122 2, /* size (0 = byte, 1 = short, 2 = long) */
124 false, /* pc_relative */
126 complain_overflow_dont
, /* complain_on_overflow */
127 NULL
, /* special_function */
128 "R_386_GNU_VTINHERIT", /* name */
129 false, /* partial_inplace */
134 /* GNU extension to record C++ vtable member usage. */
135 HOWTO (R_386_GNU_VTENTRY
, /* type */
137 2, /* size (0 = byte, 1 = short, 2 = long) */
139 false, /* pc_relative */
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 */
149 #define R_386_vt ((unsigned int) R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
153 #ifdef DEBUG_GEN_RELOC
154 #define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
159 static reloc_howto_type
*
160 elf_i386_reloc_type_lookup (abfd
, code
)
161 bfd
*abfd ATTRIBUTE_UNUSED
;
162 bfd_reloc_code_real_type code
;
167 TRACE ("BFD_RELOC_NONE");
168 return &elf_howto_table
[(unsigned int) R_386_NONE
];
171 TRACE ("BFD_RELOC_32");
172 return &elf_howto_table
[(unsigned int) R_386_32
];
175 TRACE ("BFD_RELOC_CTOR");
176 return &elf_howto_table
[(unsigned int) R_386_32
];
178 case BFD_RELOC_32_PCREL
:
179 TRACE ("BFD_RELOC_PC32");
180 return &elf_howto_table
[(unsigned int) R_386_PC32
];
182 case BFD_RELOC_386_GOT32
:
183 TRACE ("BFD_RELOC_386_GOT32");
184 return &elf_howto_table
[(unsigned int) R_386_GOT32
];
186 case BFD_RELOC_386_PLT32
:
187 TRACE ("BFD_RELOC_386_PLT32");
188 return &elf_howto_table
[(unsigned int) R_386_PLT32
];
190 case BFD_RELOC_386_COPY
:
191 TRACE ("BFD_RELOC_386_COPY");
192 return &elf_howto_table
[(unsigned int) R_386_COPY
];
194 case BFD_RELOC_386_GLOB_DAT
:
195 TRACE ("BFD_RELOC_386_GLOB_DAT");
196 return &elf_howto_table
[(unsigned int) R_386_GLOB_DAT
];
198 case BFD_RELOC_386_JUMP_SLOT
:
199 TRACE ("BFD_RELOC_386_JUMP_SLOT");
200 return &elf_howto_table
[(unsigned int) R_386_JUMP_SLOT
];
202 case BFD_RELOC_386_RELATIVE
:
203 TRACE ("BFD_RELOC_386_RELATIVE");
204 return &elf_howto_table
[(unsigned int) R_386_RELATIVE
];
206 case BFD_RELOC_386_GOTOFF
:
207 TRACE ("BFD_RELOC_386_GOTOFF");
208 return &elf_howto_table
[(unsigned int) R_386_GOTOFF
];
210 case BFD_RELOC_386_GOTPC
:
211 TRACE ("BFD_RELOC_386_GOTPC");
212 return &elf_howto_table
[(unsigned int) R_386_GOTPC
];
214 /* The remaining relocs are a GNU extension. */
216 TRACE ("BFD_RELOC_16");
217 return &elf_howto_table
[(unsigned int) R_386_16
- R_386_ext_offset
];
219 case BFD_RELOC_16_PCREL
:
220 TRACE ("BFD_RELOC_16_PCREL");
221 return &elf_howto_table
[(unsigned int) R_386_PC16
- R_386_ext_offset
];
224 TRACE ("BFD_RELOC_8");
225 return &elf_howto_table
[(unsigned int) R_386_8
- R_386_ext_offset
];
227 case BFD_RELOC_8_PCREL
:
228 TRACE ("BFD_RELOC_8_PCREL");
229 return &elf_howto_table
[(unsigned int) R_386_PC8
- R_386_ext_offset
];
231 case BFD_RELOC_VTABLE_INHERIT
:
232 TRACE ("BFD_RELOC_VTABLE_INHERIT");
233 return &elf_howto_table
[(unsigned int) R_386_GNU_VTINHERIT
236 case BFD_RELOC_VTABLE_ENTRY
:
237 TRACE ("BFD_RELOC_VTABLE_ENTRY");
238 return &elf_howto_table
[(unsigned int) R_386_GNU_VTENTRY
250 elf_i386_info_to_howto (abfd
, cache_ptr
, dst
)
251 bfd
*abfd ATTRIBUTE_UNUSED
;
252 arelent
*cache_ptr ATTRIBUTE_UNUSED
;
253 Elf32_Internal_Rela
*dst ATTRIBUTE_UNUSED
;
259 elf_i386_info_to_howto_rel (abfd
, cache_ptr
, dst
)
260 bfd
*abfd ATTRIBUTE_UNUSED
;
262 Elf32_Internal_Rel
*dst
;
264 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
267 if ((indx
= r_type
) >= R_386_standard
268 && ((indx
= r_type
- R_386_ext_offset
) - R_386_standard
269 >= R_386_ext
- R_386_standard
)
270 && ((indx
= r_type
- R_386_vt_offset
) - R_386_ext
271 >= R_386_vt
- R_386_ext
))
273 (*_bfd_error_handler
) (_("%s: invalid relocation type %d"),
274 bfd_get_filename (abfd
), (int) r_type
);
275 indx
= (unsigned int) R_386_NONE
;
277 cache_ptr
->howto
= &elf_howto_table
[indx
];
280 /* Return whether a symbol name implies a local label. The UnixWare
281 2.1 cc generates temporary symbols that start with .X, so we
282 recognize them here. FIXME: do other SVR4 compilers also use .X?.
283 If so, we should move the .X recognition into
284 _bfd_elf_is_local_label_name. */
287 elf_i386_is_local_label_name (abfd
, name
)
291 if (name
[0] == '.' && name
[1] == 'X')
294 return _bfd_elf_is_local_label_name (abfd
, name
);
297 /* Functions for the i386 ELF linker. */
299 /* The name of the dynamic interpreter. This is put in the .interp
302 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
304 /* The size in bytes of an entry in the procedure linkage table. */
306 #define PLT_ENTRY_SIZE 16
308 /* The first entry in an absolute procedure linkage table looks like
309 this. See the SVR4 ABI i386 supplement to see how this works. */
311 static const bfd_byte elf_i386_plt0_entry
[PLT_ENTRY_SIZE
] =
313 0xff, 0x35, /* pushl contents of address */
314 0, 0, 0, 0, /* replaced with address of .got + 4. */
315 0xff, 0x25, /* jmp indirect */
316 0, 0, 0, 0, /* replaced with address of .got + 8. */
317 0, 0, 0, 0 /* pad out to 16 bytes. */
320 /* Subsequent entries in an absolute procedure linkage table look like
323 static const bfd_byte elf_i386_plt_entry
[PLT_ENTRY_SIZE
] =
325 0xff, 0x25, /* jmp indirect */
326 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
327 0x68, /* pushl immediate */
328 0, 0, 0, 0, /* replaced with offset into relocation table. */
329 0xe9, /* jmp relative */
330 0, 0, 0, 0 /* replaced with offset to start of .plt. */
333 /* The first entry in a PIC procedure linkage table look like this. */
335 static const bfd_byte elf_i386_pic_plt0_entry
[PLT_ENTRY_SIZE
] =
337 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
338 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
339 0, 0, 0, 0 /* pad out to 16 bytes. */
342 /* Subsequent entries in a PIC procedure linkage table look like this. */
344 static const bfd_byte elf_i386_pic_plt_entry
[PLT_ENTRY_SIZE
] =
346 0xff, 0xa3, /* jmp *offset(%ebx) */
347 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
348 0x68, /* pushl immediate */
349 0, 0, 0, 0, /* replaced with offset into relocation table. */
350 0xe9, /* jmp relative */
351 0, 0, 0, 0 /* replaced with offset to start of .plt. */
354 /* The i386 linker needs to keep track of the number of relocs that it
355 decides to copy in check_relocs for each symbol. This is so that
356 it can discard PC relative relocs if it doesn't need them when
357 linking with -Bsymbolic. We store the information in a field
358 extending the regular ELF linker hash table. */
360 /* This structure keeps track of the number of PC relative relocs we
361 have copied for a given symbol. */
363 struct elf_i386_pcrel_relocs_copied
366 struct elf_i386_pcrel_relocs_copied
*next
;
367 /* A section in dynobj. */
369 /* Number of relocs copied in this section. */
373 /* i386 ELF linker hash entry. */
375 struct elf_i386_link_hash_entry
377 struct elf_link_hash_entry root
;
379 /* Number of PC relative relocs copied for this symbol. */
380 struct elf_i386_pcrel_relocs_copied
*pcrel_relocs_copied
;
383 /* i386 ELF linker hash table. */
385 struct elf_i386_link_hash_table
387 struct elf_link_hash_table root
;
390 /* Declare this now that the above structures are defined. */
392 static boolean elf_i386_discard_copies
393 PARAMS ((struct elf_i386_link_hash_entry
*, PTR
));
395 /* Traverse an i386 ELF linker hash table. */
397 #define elf_i386_link_hash_traverse(table, func, info) \
398 (elf_link_hash_traverse \
400 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
403 /* Get the i386 ELF linker hash table from a link_info structure. */
405 #define elf_i386_hash_table(p) \
406 ((struct elf_i386_link_hash_table *) ((p)->hash))
408 /* Create an entry in an i386 ELF linker hash table. */
410 static struct bfd_hash_entry
*
411 elf_i386_link_hash_newfunc (entry
, table
, string
)
412 struct bfd_hash_entry
*entry
;
413 struct bfd_hash_table
*table
;
416 struct elf_i386_link_hash_entry
*ret
=
417 (struct elf_i386_link_hash_entry
*) entry
;
419 /* Allocate the structure if it has not already been allocated by a
421 if (ret
== (struct elf_i386_link_hash_entry
*) NULL
)
422 ret
= ((struct elf_i386_link_hash_entry
*)
423 bfd_hash_allocate (table
,
424 sizeof (struct elf_i386_link_hash_entry
)));
425 if (ret
== (struct elf_i386_link_hash_entry
*) NULL
)
426 return (struct bfd_hash_entry
*) ret
;
428 /* Call the allocation method of the superclass. */
429 ret
= ((struct elf_i386_link_hash_entry
*)
430 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
432 if (ret
!= (struct elf_i386_link_hash_entry
*) NULL
)
434 ret
->pcrel_relocs_copied
= NULL
;
437 return (struct bfd_hash_entry
*) ret
;
440 /* Create an i386 ELF linker hash table. */
442 static struct bfd_link_hash_table
*
443 elf_i386_link_hash_table_create (abfd
)
446 struct elf_i386_link_hash_table
*ret
;
448 ret
= ((struct elf_i386_link_hash_table
*)
449 bfd_alloc (abfd
, sizeof (struct elf_i386_link_hash_table
)));
450 if (ret
== (struct elf_i386_link_hash_table
*) NULL
)
453 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
454 elf_i386_link_hash_newfunc
))
456 bfd_release (abfd
, ret
);
460 return &ret
->root
.root
;
463 /* Look through the relocs for a section during the first phase, and
464 allocate space in the global offset table or procedure linkage
468 elf_i386_check_relocs (abfd
, info
, sec
, relocs
)
470 struct bfd_link_info
*info
;
472 const Elf_Internal_Rela
*relocs
;
475 Elf_Internal_Shdr
*symtab_hdr
;
476 struct elf_link_hash_entry
**sym_hashes
;
477 bfd_signed_vma
*local_got_refcounts
;
478 const Elf_Internal_Rela
*rel
;
479 const Elf_Internal_Rela
*rel_end
;
484 if (info
->relocateable
)
487 dynobj
= elf_hash_table (info
)->dynobj
;
488 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
489 sym_hashes
= elf_sym_hashes (abfd
);
490 local_got_refcounts
= elf_local_got_refcounts (abfd
);
496 rel_end
= relocs
+ sec
->reloc_count
;
497 for (rel
= relocs
; rel
< rel_end
; rel
++)
499 unsigned long r_symndx
;
500 struct elf_link_hash_entry
*h
;
502 r_symndx
= ELF32_R_SYM (rel
->r_info
);
504 if (r_symndx
>= symtab_hdr
->sh_size
/ symtab_hdr
->sh_entsize
)
506 if (abfd
->my_archive
)
507 (*_bfd_error_handler
) (_("%s(%s): bad symbol index: %d"),
508 bfd_get_filename (abfd
->my_archive
),
509 bfd_get_filename (abfd
),
512 (*_bfd_error_handler
) (_("%s: bad symbol index: %d"),
513 bfd_get_filename (abfd
),
518 if (r_symndx
< symtab_hdr
->sh_info
)
521 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
523 /* Some relocs require a global offset table. */
526 switch (ELF32_R_TYPE (rel
->r_info
))
531 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
532 if (! _bfd_elf_create_got_section (dynobj
, info
))
541 switch (ELF32_R_TYPE (rel
->r_info
))
544 /* This symbol requires a global offset table entry. */
548 sgot
= bfd_get_section_by_name (dynobj
, ".got");
549 BFD_ASSERT (sgot
!= NULL
);
553 && (h
!= NULL
|| info
->shared
))
555 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
558 srelgot
= bfd_make_section (dynobj
, ".rel.got");
560 || ! bfd_set_section_flags (dynobj
, srelgot
,
567 || ! bfd_set_section_alignment (dynobj
, srelgot
, 2))
574 if (h
->got
.refcount
== -1)
578 /* Make sure this symbol is output as a dynamic symbol. */
579 if (h
->dynindx
== -1)
581 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
585 sgot
->_raw_size
+= 4;
586 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
589 h
->got
.refcount
+= 1;
593 /* This is a global offset table entry for a local symbol. */
594 if (local_got_refcounts
== NULL
)
598 size
= symtab_hdr
->sh_info
* sizeof (bfd_signed_vma
);
599 local_got_refcounts
= ((bfd_signed_vma
*)
600 bfd_alloc (abfd
, size
));
601 if (local_got_refcounts
== NULL
)
603 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
604 memset (local_got_refcounts
, -1, size
);
606 if (local_got_refcounts
[r_symndx
] == -1)
608 local_got_refcounts
[r_symndx
] = 1;
610 sgot
->_raw_size
+= 4;
613 /* If we are generating a shared object, we need to
614 output a R_386_RELATIVE reloc so that the dynamic
615 linker can adjust this GOT entry. */
616 srelgot
->_raw_size
+= sizeof (Elf32_External_Rel
);
620 local_got_refcounts
[r_symndx
] += 1;
625 /* This symbol requires a procedure linkage table entry. We
626 actually build the entry in adjust_dynamic_symbol,
627 because this might be a case of linking PIC code which is
628 never referenced by a dynamic object, in which case we
629 don't need to generate a procedure linkage table entry
632 /* If this is a local symbol, we resolve it directly without
633 creating a procedure linkage table entry. */
637 if (h
->plt
.refcount
== -1)
640 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
643 h
->plt
.refcount
+= 1;
649 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
651 /* If we are creating a shared library, and this is a reloc
652 against a global symbol, or a non PC relative reloc
653 against a local symbol, then we need to copy the reloc
654 into the shared library. However, if we are linking with
655 -Bsymbolic, we do not need to copy a reloc against a
656 global symbol which is defined in an object we are
657 including in the link (i.e., DEF_REGULAR is set). At
658 this point we have not seen all the input files, so it is
659 possible that DEF_REGULAR is not set now but will be set
660 later (it is never cleared). In case of a weak definition,
661 DEF_REGULAR may be cleared later by a strong definition in
662 a shared library. We account for that possibility below by
663 storing information in the relocs_copied field of the hash
664 table entry. A similar situation occurs when creating
665 shared libraries and symbol visibility changes render the
668 && (sec
->flags
& SEC_ALLOC
) != 0
669 && (ELF32_R_TYPE (rel
->r_info
) != R_386_PC32
672 || h
->root
.type
== bfd_link_hash_defweak
673 || (h
->elf_link_hash_flags
674 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
676 /* When creating a shared object, we must copy these
677 reloc types into the output file. We create a reloc
678 section in dynobj and make room for this reloc. */
683 name
= (bfd_elf_string_from_elf_section
685 elf_elfheader (abfd
)->e_shstrndx
,
686 elf_section_data (sec
)->rel_hdr
.sh_name
));
690 if (strncmp (name
, ".rel", 4) != 0
691 || strcmp (bfd_get_section_name (abfd
, sec
),
694 if (abfd
->my_archive
)
695 (*_bfd_error_handler
) (_("%s(%s): bad relocation section name `%s\'"),
696 bfd_get_filename (abfd
->my_archive
),
697 bfd_get_filename (abfd
),
700 (*_bfd_error_handler
) (_("%s: bad relocation section name `%s\'"),
701 bfd_get_filename (abfd
),
705 sreloc
= bfd_get_section_by_name (dynobj
, name
);
710 sreloc
= bfd_make_section (dynobj
, name
);
711 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
712 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
713 if ((sec
->flags
& SEC_ALLOC
) != 0)
714 flags
|= SEC_ALLOC
| SEC_LOAD
;
716 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
717 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
722 sreloc
->_raw_size
+= sizeof (Elf32_External_Rel
);
724 /* If this is a global symbol, we count the number of PC
725 relative relocations we have entered for this symbol,
726 so that we can discard them later as necessary. Note
727 that this function is only called if we are using an
728 elf_i386 linker hash table, which means that h is
729 really a pointer to an elf_i386_link_hash_entry. */
731 && ELF32_R_TYPE (rel
->r_info
) == R_386_PC32
)
733 struct elf_i386_link_hash_entry
*eh
;
734 struct elf_i386_pcrel_relocs_copied
*p
;
736 eh
= (struct elf_i386_link_hash_entry
*) h
;
738 for (p
= eh
->pcrel_relocs_copied
; p
!= NULL
; p
= p
->next
)
739 if (p
->section
== sreloc
)
744 p
= ((struct elf_i386_pcrel_relocs_copied
*)
745 bfd_alloc (dynobj
, sizeof *p
));
748 p
->next
= eh
->pcrel_relocs_copied
;
749 eh
->pcrel_relocs_copied
= p
;
760 /* This relocation describes the C++ object vtable hierarchy.
761 Reconstruct it for later use during GC. */
762 case R_386_GNU_VTINHERIT
:
763 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
767 /* This relocation describes which C++ vtable entries are actually
768 used. Record for later use during GC. */
769 case R_386_GNU_VTENTRY
:
770 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
782 /* Return the section that should be marked against GC for a given
786 elf_i386_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
788 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
789 Elf_Internal_Rela
*rel
;
790 struct elf_link_hash_entry
*h
;
791 Elf_Internal_Sym
*sym
;
795 switch (ELF32_R_TYPE (rel
->r_info
))
797 case R_386_GNU_VTINHERIT
:
798 case R_386_GNU_VTENTRY
:
802 switch (h
->root
.type
)
804 case bfd_link_hash_defined
:
805 case bfd_link_hash_defweak
:
806 return h
->root
.u
.def
.section
;
808 case bfd_link_hash_common
:
809 return h
->root
.u
.c
.p
->section
;
818 if (!(elf_bad_symtab (abfd
)
819 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
820 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
821 && sym
->st_shndx
!= SHN_COMMON
))
823 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
830 /* Update the got entry reference counts for the section being removed. */
833 elf_i386_gc_sweep_hook (abfd
, info
, sec
, relocs
)
835 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
837 const Elf_Internal_Rela
*relocs
;
839 Elf_Internal_Shdr
*symtab_hdr
;
840 struct elf_link_hash_entry
**sym_hashes
;
841 bfd_signed_vma
*local_got_refcounts
;
842 const Elf_Internal_Rela
*rel
, *relend
;
843 unsigned long r_symndx
;
844 struct elf_link_hash_entry
*h
;
849 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
850 sym_hashes
= elf_sym_hashes (abfd
);
851 local_got_refcounts
= elf_local_got_refcounts (abfd
);
853 dynobj
= elf_hash_table (info
)->dynobj
;
857 sgot
= bfd_get_section_by_name (dynobj
, ".got");
858 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
860 relend
= relocs
+ sec
->reloc_count
;
861 for (rel
= relocs
; rel
< relend
; rel
++)
862 switch (ELF32_R_TYPE (rel
->r_info
))
867 r_symndx
= ELF32_R_SYM (rel
->r_info
);
868 if (r_symndx
>= symtab_hdr
->sh_info
)
870 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
871 if (h
->got
.refcount
> 0)
873 h
->got
.refcount
-= 1;
874 if (h
->got
.refcount
== 0)
876 sgot
->_raw_size
-= 4;
877 srelgot
->_raw_size
-= sizeof (Elf32_External_Rel
);
881 else if (local_got_refcounts
!= NULL
)
883 if (local_got_refcounts
[r_symndx
] > 0)
885 local_got_refcounts
[r_symndx
] -= 1;
886 if (local_got_refcounts
[r_symndx
] == 0)
888 sgot
->_raw_size
-= 4;
890 srelgot
->_raw_size
-= sizeof (Elf32_External_Rel
);
897 r_symndx
= ELF32_R_SYM (rel
->r_info
);
898 if (r_symndx
>= symtab_hdr
->sh_info
)
900 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
901 if (h
->plt
.refcount
> 0)
902 h
->plt
.refcount
-= 1;
913 /* Adjust a symbol defined by a dynamic object and referenced by a
914 regular object. The current definition is in some section of the
915 dynamic object, but we're not including those sections. We have to
916 change the definition to something the rest of the link can
920 elf_i386_adjust_dynamic_symbol (info
, h
)
921 struct bfd_link_info
*info
;
922 struct elf_link_hash_entry
*h
;
926 unsigned int power_of_two
;
928 dynobj
= elf_hash_table (info
)->dynobj
;
930 /* Make sure we know what is going on here. */
931 BFD_ASSERT (dynobj
!= NULL
932 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
933 || h
->weakdef
!= NULL
934 || ((h
->elf_link_hash_flags
935 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
936 && (h
->elf_link_hash_flags
937 & ELF_LINK_HASH_REF_REGULAR
) != 0
938 && (h
->elf_link_hash_flags
939 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
941 /* If this is a function, put it in the procedure linkage table. We
942 will fill in the contents of the procedure linkage table later,
943 when we know the address of the .got section. */
944 if (h
->type
== STT_FUNC
945 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
948 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
949 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0)
950 || (info
->shared
&& h
->plt
.refcount
<= 0))
952 /* This case can occur if we saw a PLT32 reloc in an input
953 file, but the symbol was never referred to by a dynamic
954 object, or if all references were garbage collected. In
955 such a case, we don't actually need to build a procedure
956 linkage table, and we can just do a PC32 reloc instead. */
957 h
->plt
.offset
= (bfd_vma
) -1;
958 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
962 /* Make sure this symbol is output as a dynamic symbol. */
963 if (h
->dynindx
== -1)
965 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
969 s
= bfd_get_section_by_name (dynobj
, ".plt");
970 BFD_ASSERT (s
!= NULL
);
972 /* If this is the first .plt entry, make room for the special
974 if (s
->_raw_size
== 0)
975 s
->_raw_size
+= PLT_ENTRY_SIZE
;
977 /* If this symbol is not defined in a regular file, and we are
978 not generating a shared library, then set the symbol to this
979 location in the .plt. This is required to make function
980 pointers compare as equal between the normal executable and
981 the shared library. */
983 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
985 h
->root
.u
.def
.section
= s
;
986 h
->root
.u
.def
.value
= s
->_raw_size
;
989 h
->plt
.offset
= s
->_raw_size
;
991 /* Make room for this entry. */
992 s
->_raw_size
+= PLT_ENTRY_SIZE
;
994 /* We also need to make an entry in the .got.plt section, which
995 will be placed in the .got section by the linker script. */
996 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
997 BFD_ASSERT (s
!= NULL
);
1000 /* We also need to make an entry in the .rel.plt section. */
1001 s
= bfd_get_section_by_name (dynobj
, ".rel.plt");
1002 BFD_ASSERT (s
!= NULL
);
1003 s
->_raw_size
+= sizeof (Elf32_External_Rel
);
1008 /* If this is a weak symbol, and there is a real definition, the
1009 processor independent code will have arranged for us to see the
1010 real definition first, and we can just use the same value. */
1011 if (h
->weakdef
!= NULL
)
1013 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
1014 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
1015 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
1016 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
1020 /* This is a reference to a symbol defined by a dynamic object which
1021 is not a function. */
1023 /* If we are creating a shared library, we must presume that the
1024 only references to the symbol are via the global offset table.
1025 For such cases we need not do anything here; the relocations will
1026 be handled correctly by relocate_section. */
1030 /* If there are no references to this symbol that do not use the
1031 GOT, we don't need to generate a copy reloc. */
1032 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0)
1035 /* We must allocate the symbol in our .dynbss section, which will
1036 become part of the .bss section of the executable. There will be
1037 an entry for this symbol in the .dynsym section. The dynamic
1038 object will contain position independent code, so all references
1039 from the dynamic object to this symbol will go through the global
1040 offset table. The dynamic linker will use the .dynsym entry to
1041 determine the address it must put in the global offset table, so
1042 both the dynamic object and the regular object will refer to the
1043 same memory location for the variable. */
1045 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
1046 BFD_ASSERT (s
!= NULL
);
1048 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1049 copy the initial value out of the dynamic object and into the
1050 runtime process image. We need to remember the offset into the
1051 .rel.bss section we are going to use. */
1052 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1056 srel
= bfd_get_section_by_name (dynobj
, ".rel.bss");
1057 BFD_ASSERT (srel
!= NULL
);
1058 srel
->_raw_size
+= sizeof (Elf32_External_Rel
);
1059 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
1062 /* We need to figure out the alignment required for this symbol. I
1063 have no idea how ELF linkers handle this. */
1064 power_of_two
= bfd_log2 (h
->size
);
1065 if (power_of_two
> 3)
1068 /* Apply the required alignment. */
1069 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
1070 (bfd_size_type
) (1 << power_of_two
));
1071 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
1073 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
1077 /* Define the symbol as being at this point in the section. */
1078 h
->root
.u
.def
.section
= s
;
1079 h
->root
.u
.def
.value
= s
->_raw_size
;
1081 /* Increment the section size to make room for the symbol. */
1082 s
->_raw_size
+= h
->size
;
1087 /* Set the sizes of the dynamic sections. */
1090 elf_i386_size_dynamic_sections (output_bfd
, info
)
1092 struct bfd_link_info
*info
;
1100 dynobj
= elf_hash_table (info
)->dynobj
;
1101 BFD_ASSERT (dynobj
!= NULL
);
1103 if (elf_hash_table (info
)->dynamic_sections_created
)
1105 /* Set the contents of the .interp section to the interpreter. */
1108 s
= bfd_get_section_by_name (dynobj
, ".interp");
1109 BFD_ASSERT (s
!= NULL
);
1110 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1111 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1116 /* We may have created entries in the .rel.got section.
1117 However, if we are not creating the dynamic sections, we will
1118 not actually use these entries. Reset the size of .rel.got,
1119 which will cause it to get stripped from the output file
1121 s
= bfd_get_section_by_name (dynobj
, ".rel.got");
1126 /* If this is a -Bsymbolic shared link, then we need to discard all
1127 PC relative relocs against symbols defined in a regular object.
1128 We allocated space for them in the check_relocs routine, but we
1129 will not fill them in in the relocate_section routine. */
1131 elf_i386_link_hash_traverse (elf_i386_hash_table (info
),
1132 elf_i386_discard_copies
,
1135 /* The check_relocs and adjust_dynamic_symbol entry points have
1136 determined the sizes of the various dynamic sections. Allocate
1141 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1146 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1149 /* It's OK to base decisions on the section name, because none
1150 of the dynobj section names depend upon the input files. */
1151 name
= bfd_get_section_name (dynobj
, s
);
1155 if (strcmp (name
, ".plt") == 0)
1157 if (s
->_raw_size
== 0)
1159 /* Strip this section if we don't need it; see the
1165 /* Remember whether there is a PLT. */
1169 else if (strncmp (name
, ".rel", 4) == 0)
1171 if (s
->_raw_size
== 0)
1173 /* If we don't need this section, strip it from the
1174 output file. This is mostly to handle .rel.bss and
1175 .rel.plt. We must create both sections in
1176 create_dynamic_sections, because they must be created
1177 before the linker maps input sections to output
1178 sections. The linker does that before
1179 adjust_dynamic_symbol is called, and it is that
1180 function which decides whether anything needs to go
1181 into these sections. */
1188 /* Remember whether there are any reloc sections other
1190 if (strcmp (name
, ".rel.plt") != 0)
1192 const char *outname
;
1196 /* If this relocation section applies to a read only
1197 section, then we probably need a DT_TEXTREL
1198 entry. The entries in the .rel.plt section
1199 really apply to the .got section, which we
1200 created ourselves and so know is not readonly. */
1201 outname
= bfd_get_section_name (output_bfd
,
1203 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
1205 && (target
->flags
& SEC_READONLY
) != 0
1206 && (target
->flags
& SEC_ALLOC
) != 0)
1210 /* We use the reloc_count field as a counter if we need
1211 to copy relocs into the output file. */
1215 else if (strncmp (name
, ".got", 4) != 0)
1217 /* It's not one of our sections, so don't allocate space. */
1223 _bfd_strip_section_from_output (info
, s
);
1227 /* Allocate memory for the section contents. We use bfd_zalloc
1228 here in case unused entries are not reclaimed before the
1229 section's contents are written out. This should not happen,
1230 but this way if it does, we get a R_386_NONE reloc instead
1232 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1233 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
1237 if (elf_hash_table (info
)->dynamic_sections_created
)
1239 /* Add some entries to the .dynamic section. We fill in the
1240 values later, in elf_i386_finish_dynamic_sections, but we
1241 must add the entries now so that we get the correct size for
1242 the .dynamic section. The DT_DEBUG entry is filled in by the
1243 dynamic linker and used by the debugger. */
1246 if (! bfd_elf32_add_dynamic_entry (info
, DT_DEBUG
, 0))
1252 if (! bfd_elf32_add_dynamic_entry (info
, DT_PLTGOT
, 0)
1253 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
1254 || ! bfd_elf32_add_dynamic_entry (info
, DT_PLTREL
, DT_REL
)
1255 || ! bfd_elf32_add_dynamic_entry (info
, DT_JMPREL
, 0))
1261 if (! bfd_elf32_add_dynamic_entry (info
, DT_REL
, 0)
1262 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELSZ
, 0)
1263 || ! bfd_elf32_add_dynamic_entry (info
, DT_RELENT
,
1264 sizeof (Elf32_External_Rel
)))
1270 if (! bfd_elf32_add_dynamic_entry (info
, DT_TEXTREL
, 0))
1272 info
->flags
|= DF_TEXTREL
;
1279 /* This function is called via elf_i386_link_hash_traverse if we are
1280 creating a shared object. In the -Bsymbolic case, it discards the
1281 space allocated to copy PC relative relocs against symbols which
1282 are defined in regular objects. For the normal non-symbolic case,
1283 we also discard space for relocs that have become local due to
1284 symbol visibility changes. We allocated space for them in the
1285 check_relocs routine, but we won't fill them in in the
1286 relocate_section routine. */
1289 elf_i386_discard_copies (h
, inf
)
1290 struct elf_i386_link_hash_entry
*h
;
1293 struct elf_i386_pcrel_relocs_copied
*s
;
1294 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
1296 /* If a symbol has been forced local or we have found a regular
1297 definition for the symbolic link case, then we won't be needing
1299 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1300 && ((h
->root
.elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0
1303 for (s
= h
->pcrel_relocs_copied
; s
!= NULL
; s
= s
->next
)
1304 s
->section
->_raw_size
-= s
->count
* sizeof (Elf32_External_Rel
);
1310 /* Relocate an i386 ELF section. */
1313 elf_i386_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1314 contents
, relocs
, local_syms
, local_sections
)
1316 struct bfd_link_info
*info
;
1318 asection
*input_section
;
1320 Elf_Internal_Rela
*relocs
;
1321 Elf_Internal_Sym
*local_syms
;
1322 asection
**local_sections
;
1325 Elf_Internal_Shdr
*symtab_hdr
;
1326 struct elf_link_hash_entry
**sym_hashes
;
1327 bfd_vma
*local_got_offsets
;
1331 Elf_Internal_Rela
*rel
;
1332 Elf_Internal_Rela
*relend
;
1334 dynobj
= elf_hash_table (info
)->dynobj
;
1335 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1336 sym_hashes
= elf_sym_hashes (input_bfd
);
1337 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1344 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1345 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1349 relend
= relocs
+ input_section
->reloc_count
;
1350 for (; rel
< relend
; rel
++)
1353 reloc_howto_type
*howto
;
1354 unsigned long r_symndx
;
1355 struct elf_link_hash_entry
*h
;
1356 Elf_Internal_Sym
*sym
;
1359 bfd_reloc_status_type r
;
1362 r_type
= ELF32_R_TYPE (rel
->r_info
);
1363 if (r_type
== (int) R_386_GNU_VTINHERIT
1364 || r_type
== (int) R_386_GNU_VTENTRY
)
1367 if ((indx
= (unsigned) r_type
) >= R_386_standard
1368 && ((indx
= (unsigned) r_type
- R_386_ext_offset
) - R_386_standard
1369 >= R_386_ext
- R_386_standard
))
1371 bfd_set_error (bfd_error_bad_value
);
1374 howto
= elf_howto_table
+ indx
;
1376 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1378 if (info
->relocateable
)
1380 /* This is a relocateable link. We don't have to change
1381 anything, unless the reloc is against a section symbol,
1382 in which case we have to adjust according to where the
1383 section symbol winds up in the output section. */
1384 if (r_symndx
< symtab_hdr
->sh_info
)
1386 sym
= local_syms
+ r_symndx
;
1387 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1391 sec
= local_sections
[r_symndx
];
1392 val
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1393 val
+= sec
->output_offset
+ sym
->st_value
;
1394 bfd_put_32 (input_bfd
, val
, contents
+ rel
->r_offset
);
1401 /* This is a final link. */
1405 if (r_symndx
< symtab_hdr
->sh_info
)
1407 sym
= local_syms
+ r_symndx
;
1408 sec
= local_sections
[r_symndx
];
1409 relocation
= (sec
->output_section
->vma
1410 + sec
->output_offset
1415 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1416 while (h
->root
.type
== bfd_link_hash_indirect
1417 || h
->root
.type
== bfd_link_hash_warning
)
1418 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1419 if (h
->root
.type
== bfd_link_hash_defined
1420 || h
->root
.type
== bfd_link_hash_defweak
)
1422 sec
= h
->root
.u
.def
.section
;
1423 if (r_type
== R_386_GOTPC
1424 || (r_type
== R_386_PLT32
1426 && h
->plt
.offset
!= (bfd_vma
) -1)
1427 || (r_type
== R_386_GOT32
1428 && elf_hash_table (info
)->dynamic_sections_created
1430 || (! info
->symbolic
&& h
->dynindx
!= -1)
1431 || (h
->elf_link_hash_flags
1432 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1434 && ((! info
->symbolic
&& h
->dynindx
!= -1)
1435 || (h
->elf_link_hash_flags
1436 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
1437 && (r_type
== R_386_32
1438 || r_type
== R_386_PC32
)
1439 && ((input_section
->flags
& SEC_ALLOC
) != 0
1440 /* DWARF will emit R_386_32 relocations in its
1441 sections against symbols defined externally
1442 in shared libraries. We can't do anything
1444 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
1445 && (h
->elf_link_hash_flags
1446 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0))))
1448 /* In these cases, we don't need the relocation
1449 value. We check specially because in some
1450 obscure cases sec->output_section will be NULL. */
1453 else if (sec
->output_section
== NULL
)
1455 (*_bfd_error_handler
)
1456 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1457 bfd_get_filename (input_bfd
), h
->root
.root
.string
,
1458 bfd_get_section_name (input_bfd
, input_section
));
1462 relocation
= (h
->root
.u
.def
.value
1463 + sec
->output_section
->vma
1464 + sec
->output_offset
);
1466 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1468 else if (info
->shared
&& !info
->symbolic
1469 && !info
->no_undefined
1470 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1474 if (! ((*info
->callbacks
->undefined_symbol
)
1475 (info
, h
->root
.root
.string
, input_bfd
,
1476 input_section
, rel
->r_offset
,
1477 (!info
->shared
|| info
->no_undefined
1478 || ELF_ST_VISIBILITY (h
->other
)))))
1487 /* Relocation is to the entry for this symbol in the global
1489 BFD_ASSERT (sgot
!= NULL
);
1495 off
= h
->got
.offset
;
1496 BFD_ASSERT (off
!= (bfd_vma
) -1);
1498 if (! elf_hash_table (info
)->dynamic_sections_created
1500 && (info
->symbolic
|| h
->dynindx
== -1)
1501 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1503 /* This is actually a static link, or it is a
1504 -Bsymbolic link and the symbol is defined
1505 locally, or the symbol was forced to be local
1506 because of a version file. We must initialize
1507 this entry in the global offset table. Since the
1508 offset must always be a multiple of 4, we use the
1509 least significant bit to record whether we have
1510 initialized it already.
1512 When doing a dynamic link, we create a .rel.got
1513 relocation entry to initialize the value. This
1514 is done in the finish_dynamic_symbol routine. */
1519 bfd_put_32 (output_bfd
, relocation
,
1520 sgot
->contents
+ off
);
1525 relocation
= sgot
->output_offset
+ off
;
1531 BFD_ASSERT (local_got_offsets
!= NULL
1532 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1534 off
= local_got_offsets
[r_symndx
];
1536 /* The offset must always be a multiple of 4. We use
1537 the least significant bit to record whether we have
1538 already generated the necessary reloc. */
1543 bfd_put_32 (output_bfd
, relocation
, sgot
->contents
+ off
);
1548 Elf_Internal_Rel outrel
;
1550 srelgot
= bfd_get_section_by_name (dynobj
, ".rel.got");
1551 BFD_ASSERT (srelgot
!= NULL
);
1553 outrel
.r_offset
= (sgot
->output_section
->vma
1554 + sgot
->output_offset
1556 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1557 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1558 (((Elf32_External_Rel
*)
1560 + srelgot
->reloc_count
));
1561 ++srelgot
->reloc_count
;
1564 local_got_offsets
[r_symndx
] |= 1;
1567 relocation
= sgot
->output_offset
+ off
;
1573 /* Relocation is relative to the start of the global offset
1578 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1579 BFD_ASSERT (sgot
!= NULL
);
1582 /* Note that sgot->output_offset is not involved in this
1583 calculation. We always want the start of .got. If we
1584 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1585 permitted by the ABI, we might have to change this
1587 relocation
-= sgot
->output_section
->vma
;
1592 /* Use global offset table as symbol value. */
1596 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1597 BFD_ASSERT (sgot
!= NULL
);
1600 relocation
= sgot
->output_section
->vma
;
1605 /* Relocation is to the entry for this symbol in the
1606 procedure linkage table. */
1608 /* Resolve a PLT32 reloc against a local symbol directly,
1609 without using the procedure linkage table. */
1613 if (h
->plt
.offset
== (bfd_vma
) -1
1616 /* We didn't make a PLT entry for this symbol. This
1617 happens when statically linking PIC code, or when
1618 using -Bsymbolic. */
1622 relocation
= (splt
->output_section
->vma
1623 + splt
->output_offset
1631 && (input_section
->flags
& SEC_ALLOC
) != 0
1632 && (r_type
!= R_386_PC32
1635 && (! info
->symbolic
1636 || (h
->elf_link_hash_flags
1637 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1639 Elf_Internal_Rel outrel
;
1640 boolean skip
, relocate
;
1642 /* When generating a shared object, these relocations
1643 are copied into the output file to be resolved at run
1650 name
= (bfd_elf_string_from_elf_section
1652 elf_elfheader (input_bfd
)->e_shstrndx
,
1653 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1657 if (strncmp (name
, ".rel", 4) != 0
1658 || strcmp (bfd_get_section_name (input_bfd
,
1662 if (input_bfd
->my_archive
)
1663 (*_bfd_error_handler
) (_("%s(%s): bad relocation section name `%s\'"),
1664 bfd_get_filename (input_bfd
->my_archive
),
1665 bfd_get_filename (input_bfd
),
1668 (*_bfd_error_handler
) (_("%s: bad relocation section name `%s\'"),
1669 bfd_get_filename (input_bfd
),
1674 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1675 BFD_ASSERT (sreloc
!= NULL
);
1680 if (elf_section_data (input_section
)->stab_info
== NULL
)
1681 outrel
.r_offset
= rel
->r_offset
;
1686 off
= (_bfd_stab_section_offset
1687 (output_bfd
, &elf_hash_table (info
)->stab_info
,
1689 &elf_section_data (input_section
)->stab_info
,
1691 if (off
== (bfd_vma
) -1)
1693 outrel
.r_offset
= off
;
1696 outrel
.r_offset
+= (input_section
->output_section
->vma
1697 + input_section
->output_offset
);
1701 memset (&outrel
, 0, sizeof outrel
);
1704 else if (r_type
== R_386_PC32
)
1706 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
1708 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_PC32
);
1712 /* h->dynindx may be -1 if this symbol was marked to
1715 || ((info
->symbolic
|| h
->dynindx
== -1)
1716 && (h
->elf_link_hash_flags
1717 & ELF_LINK_HASH_DEF_REGULAR
) != 0))
1720 outrel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1724 BFD_ASSERT (h
->dynindx
!= -1);
1726 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_32
);
1730 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1731 (((Elf32_External_Rel
*)
1733 + sreloc
->reloc_count
));
1734 ++sreloc
->reloc_count
;
1736 /* If this reloc is against an external symbol, we do
1737 not want to fiddle with the addend. Otherwise, we
1738 need to include the symbol value so that it becomes
1739 an addend for the dynamic reloc. */
1750 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1751 contents
, rel
->r_offset
,
1752 relocation
, (bfd_vma
) 0);
1754 if (r
!= bfd_reloc_ok
)
1759 case bfd_reloc_outofrange
:
1761 case bfd_reloc_overflow
:
1766 name
= h
->root
.root
.string
;
1769 name
= bfd_elf_string_from_elf_section (input_bfd
,
1770 symtab_hdr
->sh_link
,
1775 name
= bfd_section_name (input_bfd
, sec
);
1777 if (! ((*info
->callbacks
->reloc_overflow
)
1778 (info
, name
, howto
->name
, (bfd_vma
) 0,
1779 input_bfd
, input_section
, rel
->r_offset
)))
1790 /* Finish up dynamic symbol handling. We set the contents of various
1791 dynamic sections here. */
1794 elf_i386_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
1796 struct bfd_link_info
*info
;
1797 struct elf_link_hash_entry
*h
;
1798 Elf_Internal_Sym
*sym
;
1802 dynobj
= elf_hash_table (info
)->dynobj
;
1804 if (h
->plt
.offset
!= (bfd_vma
) -1)
1811 Elf_Internal_Rel rel
;
1813 /* This symbol has an entry in the procedure linkage table. Set
1816 BFD_ASSERT (h
->dynindx
!= -1);
1818 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1819 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
1820 srel
= bfd_get_section_by_name (dynobj
, ".rel.plt");
1821 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
1823 /* Get the index in the procedure linkage table which
1824 corresponds to this symbol. This is the index of this symbol
1825 in all the symbols for which we are making plt entries. The
1826 first entry in the procedure linkage table is reserved. */
1827 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
1829 /* Get the offset into the .got table of the entry that
1830 corresponds to this function. Each .got entry is 4 bytes.
1831 The first three are reserved. */
1832 got_offset
= (plt_index
+ 3) * 4;
1834 /* Fill in the entry in the procedure linkage table. */
1837 memcpy (splt
->contents
+ h
->plt
.offset
, elf_i386_plt_entry
,
1839 bfd_put_32 (output_bfd
,
1840 (sgot
->output_section
->vma
1841 + sgot
->output_offset
1843 splt
->contents
+ h
->plt
.offset
+ 2);
1847 memcpy (splt
->contents
+ h
->plt
.offset
, elf_i386_pic_plt_entry
,
1849 bfd_put_32 (output_bfd
, got_offset
,
1850 splt
->contents
+ h
->plt
.offset
+ 2);
1853 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rel
),
1854 splt
->contents
+ h
->plt
.offset
+ 7);
1855 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
1856 splt
->contents
+ h
->plt
.offset
+ 12);
1858 /* Fill in the entry in the global offset table. */
1859 bfd_put_32 (output_bfd
,
1860 (splt
->output_section
->vma
1861 + splt
->output_offset
1864 sgot
->contents
+ got_offset
);
1866 /* Fill in the entry in the .rel.plt section. */
1867 rel
.r_offset
= (sgot
->output_section
->vma
1868 + sgot
->output_offset
1870 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_JUMP_SLOT
);
1871 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
1872 ((Elf32_External_Rel
*) srel
->contents
1875 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1877 /* Mark the symbol as undefined, rather than as defined in
1878 the .plt section. Leave the value alone. */
1879 sym
->st_shndx
= SHN_UNDEF
;
1883 if (h
->got
.offset
!= (bfd_vma
) -1)
1887 Elf_Internal_Rel rel
;
1889 /* This symbol has an entry in the global offset table. Set it
1892 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1893 srel
= bfd_get_section_by_name (dynobj
, ".rel.got");
1894 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
1896 rel
.r_offset
= (sgot
->output_section
->vma
1897 + sgot
->output_offset
1898 + (h
->got
.offset
&~ 1));
1900 /* If this is a static link, or it is a -Bsymbolic link and the
1901 symbol is defined locally or was forced to be local because
1902 of a version file, we just want to emit a RELATIVE reloc.
1903 The entry in the global offset table will already have been
1904 initialized in the relocate_section function. */
1905 if (! elf_hash_table (info
)->dynamic_sections_created
1907 && (info
->symbolic
|| h
->dynindx
== -1)
1908 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1910 rel
.r_info
= ELF32_R_INFO (0, R_386_RELATIVE
);
1914 BFD_ASSERT((h
->got
.offset
& 1) == 0);
1915 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
1916 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_GLOB_DAT
);
1919 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
1920 ((Elf32_External_Rel
*) srel
->contents
1921 + srel
->reloc_count
));
1922 ++srel
->reloc_count
;
1925 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
1928 Elf_Internal_Rel rel
;
1930 /* This symbol needs a copy reloc. Set it up. */
1932 BFD_ASSERT (h
->dynindx
!= -1
1933 && (h
->root
.type
== bfd_link_hash_defined
1934 || h
->root
.type
== bfd_link_hash_defweak
));
1936 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
1938 BFD_ASSERT (s
!= NULL
);
1940 rel
.r_offset
= (h
->root
.u
.def
.value
1941 + h
->root
.u
.def
.section
->output_section
->vma
1942 + h
->root
.u
.def
.section
->output_offset
);
1943 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_386_COPY
);
1944 bfd_elf32_swap_reloc_out (output_bfd
, &rel
,
1945 ((Elf32_External_Rel
*) s
->contents
1950 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1951 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
1952 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
1953 sym
->st_shndx
= SHN_ABS
;
1958 /* Finish up the dynamic sections. */
1961 elf_i386_finish_dynamic_sections (output_bfd
, info
)
1963 struct bfd_link_info
*info
;
1969 dynobj
= elf_hash_table (info
)->dynobj
;
1971 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
1972 BFD_ASSERT (sgot
!= NULL
);
1973 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
1975 if (elf_hash_table (info
)->dynamic_sections_created
)
1978 Elf32_External_Dyn
*dyncon
, *dynconend
;
1980 BFD_ASSERT (sdyn
!= NULL
);
1982 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
1983 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
1984 for (; dyncon
< dynconend
; dyncon
++)
1986 Elf_Internal_Dyn dyn
;
1990 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2003 s
= bfd_get_section_by_name (output_bfd
, name
);
2004 BFD_ASSERT (s
!= NULL
);
2005 dyn
.d_un
.d_ptr
= s
->vma
;
2006 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2010 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
2011 BFD_ASSERT (s
!= NULL
);
2012 if (s
->_cooked_size
!= 0)
2013 dyn
.d_un
.d_val
= s
->_cooked_size
;
2015 dyn
.d_un
.d_val
= s
->_raw_size
;
2016 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2020 /* My reading of the SVR4 ABI indicates that the
2021 procedure linkage table relocs (DT_JMPREL) should be
2022 included in the overall relocs (DT_REL). This is
2023 what Solaris does. However, UnixWare can not handle
2024 that case. Therefore, we override the DT_RELSZ entry
2025 here to make it not include the JMPREL relocs. Since
2026 the linker script arranges for .rel.plt to follow all
2027 other relocation sections, we don't have to worry
2028 about changing the DT_REL entry. */
2029 s
= bfd_get_section_by_name (output_bfd
, ".rel.plt");
2032 if (s
->_cooked_size
!= 0)
2033 dyn
.d_un
.d_val
-= s
->_cooked_size
;
2035 dyn
.d_un
.d_val
-= s
->_raw_size
;
2037 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2042 /* Fill in the first entry in the procedure linkage table. */
2043 splt
= bfd_get_section_by_name (dynobj
, ".plt");
2044 if (splt
&& splt
->_raw_size
> 0)
2047 memcpy (splt
->contents
, elf_i386_pic_plt0_entry
, PLT_ENTRY_SIZE
);
2050 memcpy (splt
->contents
, elf_i386_plt0_entry
, PLT_ENTRY_SIZE
);
2051 bfd_put_32 (output_bfd
,
2052 sgot
->output_section
->vma
+ sgot
->output_offset
+ 4,
2053 splt
->contents
+ 2);
2054 bfd_put_32 (output_bfd
,
2055 sgot
->output_section
->vma
+ sgot
->output_offset
+ 8,
2056 splt
->contents
+ 8);
2059 /* UnixWare sets the entsize of .plt to 4, although that doesn't
2060 really seem like the right value. */
2061 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
2065 /* Fill in the first three entries in the global offset table. */
2066 if (sgot
->_raw_size
> 0)
2069 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
2071 bfd_put_32 (output_bfd
,
2072 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2074 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
2075 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
2078 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
2083 /* Set the correct type for an x86 ELF section. We do this by the
2084 section name, which is a hack, but ought to work. */
2087 elf_i386_fake_sections (abfd
, hdr
, sec
)
2088 bfd
*abfd ATTRIBUTE_UNUSED
;
2089 Elf32_Internal_Shdr
*hdr
;
2092 register const char *name
;
2094 name
= bfd_get_section_name (abfd
, sec
);
2096 if (strcmp (name
, ".reloc") == 0)
2098 * This is an ugly, but unfortunately necessary hack that is
2099 * needed when producing EFI binaries on x86. It tells
2100 * elf.c:elf_fake_sections() not to consider ".reloc" as a section
2101 * containing ELF relocation info. We need this hack in order to
2102 * be able to generate ELF binaries that can be translated into
2103 * EFI applications (which are essentially COFF objects). Those
2104 * files contain a COFF ".reloc" section inside an ELFNN object,
2105 * which would normally cause BFD to segfault because it would
2106 * attempt to interpret this section as containing relocation
2107 * entries for section "oc". With this hack enabled, ".reloc"
2108 * will be treated as a normal data section, which will avoid the
2109 * segfault. However, you won't be able to create an ELFNN binary
2110 * with a section named "oc" that needs relocations, but that's
2111 * the kind of ugly side-effects you get when detecting section
2112 * types based on their names... In practice, this limitation is
2115 hdr
->sh_type
= SHT_PROGBITS
;
2121 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
2122 #define TARGET_LITTLE_NAME "elf32-i386"
2123 #define ELF_ARCH bfd_arch_i386
2124 #define ELF_MACHINE_CODE EM_386
2125 #define ELF_MAXPAGESIZE 0x1000
2127 #define elf_backend_can_gc_sections 1
2128 #define elf_backend_want_got_plt 1
2129 #define elf_backend_plt_readonly 1
2130 #define elf_backend_want_plt_sym 0
2131 #define elf_backend_got_header_size 12
2132 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
2134 #define elf_info_to_howto elf_i386_info_to_howto
2135 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
2137 #define bfd_elf32_bfd_final_link _bfd_elf32_gc_common_final_link
2138 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
2139 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
2140 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
2142 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
2143 #define elf_backend_check_relocs elf_i386_check_relocs
2144 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
2145 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
2146 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
2147 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
2148 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
2149 #define elf_backend_relocate_section elf_i386_relocate_section
2150 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
2151 #define elf_backend_fake_sections elf_i386_fake_sections
2153 #include "elf32-target.h"