1 /* Intel 80386/80486-specific support for 32-bit ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
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
34 PARAMS ((bfd *, const char *));
35 static boolean elf_i386_grok_prstatus
36 PARAMS ((bfd *abfd, Elf_Internal_Note *note));
37 static boolean elf_i386_grok_psinfo
38 PARAMS ((bfd *abfd, Elf_Internal_Note *note));
39 static struct bfd_hash_entry *link_hash_newfunc
40 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
41 static struct bfd_link_hash_table *elf_i386_link_hash_table_create
43 static boolean create_got_section
44 PARAMS((bfd *, struct bfd_link_info *));
45 static boolean elf_i386_create_dynamic_sections
46 PARAMS((bfd *, struct bfd_link_info *));
47 static void elf_i386_copy_indirect_symbol
48 PARAMS ((struct elf_link_hash_entry *, struct elf_link_hash_entry *));
49 static int elf_i386_tls_transition
50 PARAMS ((struct bfd_link_info *, int, int));
52 static boolean elf_i386_mkobject
54 static boolean elf_i386_object_p
56 static boolean elf_i386_check_relocs
57 PARAMS ((bfd *, struct bfd_link_info *, asection *,
58 const Elf_Internal_Rela *));
59 static asection *elf_i386_gc_mark_hook
60 PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *,
61 struct elf_link_hash_entry *, Elf_Internal_Sym *));
62 static boolean elf_i386_gc_sweep_hook
63 PARAMS ((bfd *, struct bfd_link_info *, asection *,
64 const Elf_Internal_Rela *));
65 static boolean elf_i386_adjust_dynamic_symbol
66 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
67 static boolean allocate_dynrelocs
68 PARAMS ((struct elf_link_hash_entry *, PTR));
69 static boolean readonly_dynrelocs
70 PARAMS ((struct elf_link_hash_entry *, PTR));
71 static boolean elf_i386_fake_sections
72 PARAMS ((bfd *, Elf32_Internal_Shdr *, asection *));
73 static boolean elf_i386_size_dynamic_sections
74 PARAMS ((bfd *, struct bfd_link_info *));
75 static bfd_vma dtpoff_base
76 PARAMS ((struct bfd_link_info *));
78 PARAMS ((struct bfd_link_info *, bfd_vma));
79 static boolean elf_i386_relocate_section
80 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
81 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
82 static boolean elf_i386_finish_dynamic_symbol
83 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
85 static enum elf_reloc_type_class elf_i386_reloc_type_class
86 PARAMS ((const Elf_Internal_Rela *));
87 static boolean elf_i386_finish_dynamic_sections
88 PARAMS ((bfd *, struct bfd_link_info *));
90 #define USE_REL 1 /* 386 uses REL relocations instead of RELA */
94 static reloc_howto_type elf_howto_table[]=
96 HOWTO(R_386_NONE, 0, 0, 0, false, 0, complain_overflow_bitfield,
97 bfd_elf_generic_reloc, "R_386_NONE",
98 true, 0x00000000, 0x00000000, false),
99 HOWTO(R_386_32, 0, 2, 32, false, 0, complain_overflow_bitfield,
100 bfd_elf_generic_reloc, "R_386_32",
101 true, 0xffffffff, 0xffffffff, false),
102 HOWTO(R_386_PC32, 0, 2, 32, true, 0, complain_overflow_bitfield,
103 bfd_elf_generic_reloc, "R_386_PC32",
104 true, 0xffffffff, 0xffffffff, true),
105 HOWTO(R_386_GOT32, 0, 2, 32, false, 0, complain_overflow_bitfield,
106 bfd_elf_generic_reloc, "R_386_GOT32",
107 true, 0xffffffff, 0xffffffff, false),
108 HOWTO(R_386_PLT32, 0, 2, 32, true, 0, complain_overflow_bitfield,
109 bfd_elf_generic_reloc, "R_386_PLT32",
110 true, 0xffffffff, 0xffffffff, true),
111 HOWTO(R_386_COPY, 0, 2, 32, false, 0, complain_overflow_bitfield,
112 bfd_elf_generic_reloc, "R_386_COPY",
113 true, 0xffffffff, 0xffffffff, false),
114 HOWTO(R_386_GLOB_DAT, 0, 2, 32, false, 0, complain_overflow_bitfield,
115 bfd_elf_generic_reloc, "R_386_GLOB_DAT",
116 true, 0xffffffff, 0xffffffff, false),
117 HOWTO(R_386_JUMP_SLOT, 0, 2, 32, false, 0, complain_overflow_bitfield,
118 bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
119 true, 0xffffffff, 0xffffffff, false),
120 HOWTO(R_386_RELATIVE, 0, 2, 32, false, 0, complain_overflow_bitfield,
121 bfd_elf_generic_reloc, "R_386_RELATIVE",
122 true, 0xffffffff, 0xffffffff, false),
123 HOWTO(R_386_GOTOFF, 0, 2, 32, false, 0, complain_overflow_bitfield,
124 bfd_elf_generic_reloc, "R_386_GOTOFF",
125 true, 0xffffffff, 0xffffffff, false),
126 HOWTO(R_386_GOTPC, 0, 2, 32, true, 0, complain_overflow_bitfield,
127 bfd_elf_generic_reloc, "R_386_GOTPC",
128 true, 0xffffffff, 0xffffffff, true),
130 /* We have a gap in the reloc numbers here.
131 R_386_standard counts the number up to this point, and
132 R_386_ext_offset is the value to subtract from a reloc type of
133 R_386_16 thru R_386_PC8 to form an index into this table. */
134 #define R_386_standard ((unsigned int) R_386_GOTPC + 1)
135 #define R_386_ext_offset ((unsigned int) R_386_TLS_LE - R_386_standard)
137 /* The remaining relocs are a GNU extension. */
138 HOWTO(R_386_TLS_LE, 0, 2, 32, false, 0, complain_overflow_bitfield,
139 bfd_elf_generic_reloc, "R_386_TLS_LE",
140 true, 0xffffffff, 0xffffffff, false),
141 HOWTO(R_386_TLS_GD, 0, 2, 32, false, 0, complain_overflow_bitfield,
142 bfd_elf_generic_reloc, "R_386_TLS_GD",
143 true, 0xffffffff, 0xffffffff, false),
144 HOWTO(R_386_TLS_LDM, 0, 2, 32, false, 0, complain_overflow_bitfield,
145 bfd_elf_generic_reloc, "R_386_TLS_LDM",
146 true, 0xffffffff, 0xffffffff, false),
147 HOWTO(R_386_16, 0, 1, 16, false, 0, complain_overflow_bitfield,
148 bfd_elf_generic_reloc, "R_386_16",
149 true, 0xffff, 0xffff, false),
150 HOWTO(R_386_PC16, 0, 1, 16, true, 0, complain_overflow_bitfield,
151 bfd_elf_generic_reloc, "R_386_PC16",
152 true, 0xffff, 0xffff, true),
153 HOWTO(R_386_8, 0, 0, 8, false, 0, complain_overflow_bitfield,
154 bfd_elf_generic_reloc, "R_386_8",
155 true, 0xff, 0xff, false),
156 HOWTO(R_386_PC8, 0, 0, 8, true, 0, complain_overflow_signed,
157 bfd_elf_generic_reloc, "R_386_PC8",
158 true, 0xff, 0xff, true),
160 #define R_386_ext ((unsigned int) R_386_PC8 + 1 - R_386_ext_offset)
161 #define R_386_tls_offset ((unsigned int) R_386_TLS_LDO_32 - R_386_ext)
162 /* These are common with Solaris TLS implementation. */
163 HOWTO(R_386_TLS_LDO_32, 0, 2, 32, false, 0, complain_overflow_bitfield,
164 bfd_elf_generic_reloc, "R_386_TLS_LDO_32",
165 true, 0xffffffff, 0xffffffff, false),
166 HOWTO(R_386_TLS_IE_32, 0, 2, 32, false, 0, complain_overflow_bitfield,
167 bfd_elf_generic_reloc, "R_386_TLS_IE_32",
168 true, 0xffffffff, 0xffffffff, false),
169 HOWTO(R_386_TLS_LE_32, 0, 2, 32, false, 0, complain_overflow_bitfield,
170 bfd_elf_generic_reloc, "R_386_TLS_LE_32",
171 true, 0xffffffff, 0xffffffff, false),
172 HOWTO(R_386_TLS_DTPMOD32, 0, 2, 32, false, 0, complain_overflow_bitfield,
173 bfd_elf_generic_reloc, "R_386_TLS_DTPMOD32",
174 true, 0xffffffff, 0xffffffff, false),
175 HOWTO(R_386_TLS_DTPOFF32, 0, 2, 32, false, 0, complain_overflow_bitfield,
176 bfd_elf_generic_reloc, "R_386_TLS_DTPOFF32",
177 true, 0xffffffff, 0xffffffff, false),
178 HOWTO(R_386_TLS_TPOFF32, 0, 2, 32, false, 0, complain_overflow_bitfield,
179 bfd_elf_generic_reloc, "R_386_TLS_TPOFF32",
180 true, 0xffffffff, 0xffffffff, false),
183 #define R_386_tls ((unsigned int) R_386_TLS_TPOFF32 + 1 - R_386_tls_offset)
184 #define R_386_vt_offset ((unsigned int) R_386_GNU_VTINHERIT - R_386_tls)
186 /* GNU extension to record C++ vtable hierarchy. */
187 HOWTO (R_386_GNU_VTINHERIT, /* type */
189 2, /* size (0 = byte, 1 = short, 2 = long) */
191 false, /* pc_relative */
193 complain_overflow_dont, /* complain_on_overflow */
194 NULL, /* special_function */
195 "R_386_GNU_VTINHERIT", /* name */
196 false, /* partial_inplace */
199 false), /* pcrel_offset */
201 /* GNU extension to record C++ vtable member usage. */
202 HOWTO (R_386_GNU_VTENTRY, /* type */
204 2, /* size (0 = byte, 1 = short, 2 = long) */
206 false, /* pc_relative */
208 complain_overflow_dont, /* complain_on_overflow */
209 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
210 "R_386_GNU_VTENTRY", /* name */
211 false, /* partial_inplace */
214 false) /* pcrel_offset */
216 #define R_386_vt ((unsigned int) R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
220 #ifdef DEBUG_GEN_RELOC
221 #define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
226 static reloc_howto_type *
227 elf_i386_reloc_type_lookup (abfd, code)
228 bfd *abfd ATTRIBUTE_UNUSED;
229 bfd_reloc_code_real_type code;
234 TRACE ("BFD_RELOC_NONE");
235 return &elf_howto_table[(unsigned int) R_386_NONE ];
238 TRACE ("BFD_RELOC_32");
239 return &elf_howto_table[(unsigned int) R_386_32 ];
242 TRACE ("BFD_RELOC_CTOR");
243 return &elf_howto_table[(unsigned int) R_386_32 ];
245 case BFD_RELOC_32_PCREL:
246 TRACE ("BFD_RELOC_PC32");
247 return &elf_howto_table[(unsigned int) R_386_PC32 ];
249 case BFD_RELOC_386_GOT32:
250 TRACE ("BFD_RELOC_386_GOT32");
251 return &elf_howto_table[(unsigned int) R_386_GOT32 ];
253 case BFD_RELOC_386_PLT32:
254 TRACE ("BFD_RELOC_386_PLT32");
255 return &elf_howto_table[(unsigned int) R_386_PLT32 ];
257 case BFD_RELOC_386_COPY:
258 TRACE ("BFD_RELOC_386_COPY");
259 return &elf_howto_table[(unsigned int) R_386_COPY ];
261 case BFD_RELOC_386_GLOB_DAT:
262 TRACE ("BFD_RELOC_386_GLOB_DAT");
263 return &elf_howto_table[(unsigned int) R_386_GLOB_DAT ];
265 case BFD_RELOC_386_JUMP_SLOT:
266 TRACE ("BFD_RELOC_386_JUMP_SLOT");
267 return &elf_howto_table[(unsigned int) R_386_JUMP_SLOT ];
269 case BFD_RELOC_386_RELATIVE:
270 TRACE ("BFD_RELOC_386_RELATIVE");
271 return &elf_howto_table[(unsigned int) R_386_RELATIVE ];
273 case BFD_RELOC_386_GOTOFF:
274 TRACE ("BFD_RELOC_386_GOTOFF");
275 return &elf_howto_table[(unsigned int) R_386_GOTOFF ];
277 case BFD_RELOC_386_GOTPC:
278 TRACE ("BFD_RELOC_386_GOTPC");
279 return &elf_howto_table[(unsigned int) R_386_GOTPC ];
281 /* The remaining relocs are a GNU extension. */
282 case BFD_RELOC_386_TLS_LE:
283 TRACE ("BFD_RELOC_386_TLS_LE");
284 return &elf_howto_table[(unsigned int) R_386_TLS_LE - R_386_ext_offset];
286 case BFD_RELOC_386_TLS_GD:
287 TRACE ("BFD_RELOC_386_TLS_GD");
288 return &elf_howto_table[(unsigned int) R_386_TLS_GD - R_386_ext_offset];
290 case BFD_RELOC_386_TLS_LDM:
291 TRACE ("BFD_RELOC_386_TLS_LDM");
292 return &elf_howto_table[(unsigned int) R_386_TLS_LDM - R_386_ext_offset];
295 TRACE ("BFD_RELOC_16");
296 return &elf_howto_table[(unsigned int) R_386_16 - R_386_ext_offset];
298 case BFD_RELOC_16_PCREL:
299 TRACE ("BFD_RELOC_16_PCREL");
300 return &elf_howto_table[(unsigned int) R_386_PC16 - R_386_ext_offset];
303 TRACE ("BFD_RELOC_8");
304 return &elf_howto_table[(unsigned int) R_386_8 - R_386_ext_offset];
306 case BFD_RELOC_8_PCREL:
307 TRACE ("BFD_RELOC_8_PCREL");
308 return &elf_howto_table[(unsigned int) R_386_PC8 - R_386_ext_offset];
310 /* Common with Sun TLS implementation. */
311 case BFD_RELOC_386_TLS_LDO_32:
312 TRACE ("BFD_RELOC_386_TLS_LDO_32");
313 return &elf_howto_table[(unsigned int) R_386_TLS_LDO_32 - R_386_tls_offset];
315 case BFD_RELOC_386_TLS_IE_32:
316 TRACE ("BFD_RELOC_386_TLS_IE_32");
317 return &elf_howto_table[(unsigned int) R_386_TLS_IE_32 - R_386_tls_offset];
319 case BFD_RELOC_386_TLS_LE_32:
320 TRACE ("BFD_RELOC_386_TLS_LE_32");
321 return &elf_howto_table[(unsigned int) R_386_TLS_LE_32 - R_386_tls_offset];
323 case BFD_RELOC_386_TLS_DTPMOD32:
324 TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
325 return &elf_howto_table[(unsigned int) R_386_TLS_DTPMOD32 - R_386_tls_offset];
327 case BFD_RELOC_386_TLS_DTPOFF32:
328 TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
329 return &elf_howto_table[(unsigned int) R_386_TLS_DTPOFF32 - R_386_tls_offset];
331 case BFD_RELOC_386_TLS_TPOFF32:
332 TRACE ("BFD_RELOC_386_TLS_TPOFF32");
333 return &elf_howto_table[(unsigned int) R_386_TLS_TPOFF32 - R_386_tls_offset];
335 case BFD_RELOC_VTABLE_INHERIT:
336 TRACE ("BFD_RELOC_VTABLE_INHERIT");
337 return &elf_howto_table[(unsigned int) R_386_GNU_VTINHERIT
340 case BFD_RELOC_VTABLE_ENTRY:
341 TRACE ("BFD_RELOC_VTABLE_ENTRY");
342 return &elf_howto_table[(unsigned int) R_386_GNU_VTENTRY
354 elf_i386_info_to_howto (abfd, cache_ptr, dst)
355 bfd *abfd ATTRIBUTE_UNUSED;
356 arelent *cache_ptr ATTRIBUTE_UNUSED;
357 Elf32_Internal_Rela *dst ATTRIBUTE_UNUSED;
363 elf_i386_info_to_howto_rel (abfd, cache_ptr, dst)
364 bfd *abfd ATTRIBUTE_UNUSED;
366 Elf32_Internal_Rel *dst;
368 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
371 if ((indx = r_type) >= R_386_standard
372 && ((indx = r_type - R_386_ext_offset) - R_386_standard
373 >= R_386_ext - R_386_standard)
374 && ((indx = r_type - R_386_tls_offset) - R_386_ext
375 >= R_386_tls - R_386_ext)
376 && ((indx = r_type - R_386_vt_offset) - R_386_tls
377 >= R_386_vt - R_386_tls))
379 (*_bfd_error_handler) (_("%s: invalid relocation type %d"),
380 bfd_archive_filename (abfd), (int) r_type);
381 indx = (unsigned int) R_386_NONE;
383 cache_ptr->howto = &elf_howto_table[indx];
386 /* Return whether a symbol name implies a local label. The UnixWare
387 2.1 cc generates temporary symbols that start with .X, so we
388 recognize them here. FIXME: do other SVR4 compilers also use .X?.
389 If so, we should move the .X recognition into
390 _bfd_elf_is_local_label_name. */
393 elf_i386_is_local_label_name (abfd, name)
397 if (name[0] == '.' && name[1] == 'X')
400 return _bfd_elf_is_local_label_name (abfd, name);
403 /* Support for core dump NOTE sections. */
405 elf_i386_grok_prstatus (abfd, note)
407 Elf_Internal_Note *note;
412 switch (note->descsz)
417 case 144: /* Linux/i386 */
419 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
422 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
431 /* Make a ".reg/999" section. */
432 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
433 raw_size, note->descpos + offset);
437 elf_i386_grok_psinfo (abfd, note)
439 Elf_Internal_Note *note;
441 switch (note->descsz)
446 case 124: /* Linux/i386 elf_prpsinfo */
447 elf_tdata (abfd)->core_program
448 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
449 elf_tdata (abfd)->core_command
450 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
453 /* Note that for some reason, a spurious space is tacked
454 onto the end of the args in some (at least one anyway)
455 implementations, so strip it off if it exists. */
458 char *command = elf_tdata (abfd)->core_command;
459 int n = strlen (command);
461 if (0 < n && command[n - 1] == ' ')
462 command[n - 1] = '\0';
468 /* Functions for the i386 ELF linker.
470 In order to gain some understanding of code in this file without
471 knowing all the intricate details of the linker, note the
474 Functions named elf_i386_* are called by external routines, other
475 functions are only called locally. elf_i386_* functions appear
476 in this file more or less in the order in which they are called
477 from external routines. eg. elf_i386_check_relocs is called
478 early in the link process, elf_i386_finish_dynamic_sections is
479 one of the last functions. */
482 /* The name of the dynamic interpreter. This is put in the .interp
485 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
487 /* The size in bytes of an entry in the procedure linkage table. */
489 #define PLT_ENTRY_SIZE 16
491 /* The first entry in an absolute procedure linkage table looks like
492 this. See the SVR4 ABI i386 supplement to see how this works. */
494 static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] =
496 0xff, 0x35, /* pushl contents of address */
497 0, 0, 0, 0, /* replaced with address of .got + 4. */
498 0xff, 0x25, /* jmp indirect */
499 0, 0, 0, 0, /* replaced with address of .got + 8. */
500 0, 0, 0, 0 /* pad out to 16 bytes. */
503 /* Subsequent entries in an absolute procedure linkage table look like
506 static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
508 0xff, 0x25, /* jmp indirect */
509 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
510 0x68, /* pushl immediate */
511 0, 0, 0, 0, /* replaced with offset into relocation table. */
512 0xe9, /* jmp relative */
513 0, 0, 0, 0 /* replaced with offset to start of .plt. */
516 /* The first entry in a PIC procedure linkage table look like this. */
518 static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] =
520 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
521 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
522 0, 0, 0, 0 /* pad out to 16 bytes. */
525 /* Subsequent entries in a PIC procedure linkage table look like this. */
527 static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
529 0xff, 0xa3, /* jmp *offset(%ebx) */
530 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
531 0x68, /* pushl immediate */
532 0, 0, 0, 0, /* replaced with offset into relocation table. */
533 0xe9, /* jmp relative */
534 0, 0, 0, 0 /* replaced with offset to start of .plt. */
537 /* The i386 linker needs to keep track of the number of relocs that it
538 decides to copy as dynamic relocs in check_relocs for each symbol.
539 This is so that it can later discard them if they are found to be
540 unnecessary. We store the information in a field extending the
541 regular ELF linker hash table. */
543 struct elf_i386_dyn_relocs
545 struct elf_i386_dyn_relocs *next;
547 /* The input section of the reloc. */
550 /* Total number of relocs copied for the input section. */
553 /* Number of pc-relative relocs copied for the input section. */
554 bfd_size_type pc_count;
557 /* i386 ELF linker hash entry. */
559 struct elf_i386_link_hash_entry
561 struct elf_link_hash_entry elf;
563 /* Track dynamic relocs copied for this symbol. */
564 struct elf_i386_dyn_relocs *dyn_relocs;
567 GOT_UNKNOWN = 0, GOT_NORMAL, GOT_TLS_GD, GOT_TLS_IE
571 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
573 struct elf_i386_obj_tdata
575 struct elf_obj_tdata root;
577 /* tls_type for each local got entry. */
578 char *local_got_tls_type;
581 #define elf_i386_tdata(abfd) \
582 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
584 #define elf_i386_local_got_tls_type(abfd) \
585 (elf_i386_tdata (abfd)->local_got_tls_type)
588 elf_i386_mkobject (abfd)
591 bfd_size_type amt = sizeof (struct elf_i386_obj_tdata);
592 abfd->tdata.any = bfd_zalloc (abfd, amt);
593 if (abfd->tdata.any == NULL)
599 elf_i386_object_p (abfd)
602 /* Allocate our special target data. */
603 struct elf_i386_obj_tdata *new_tdata;
604 bfd_size_type amt = sizeof (struct elf_i386_obj_tdata);
605 new_tdata = bfd_zalloc (abfd, amt);
606 if (new_tdata == NULL)
608 new_tdata->root = *abfd->tdata.elf_obj_data;
609 abfd->tdata.any = new_tdata;
613 /* i386 ELF linker hash table. */
615 struct elf_i386_link_hash_table
617 struct elf_link_hash_table elf;
619 /* Short-cuts to get to dynamic linker sections. */
629 bfd_signed_vma refcount;
633 /* Small local sym to section mapping cache. */
634 struct sym_sec_cache sym_sec;
637 /* Get the i386 ELF linker hash table from a link_info structure. */
639 #define elf_i386_hash_table(p) \
640 ((struct elf_i386_link_hash_table *) ((p)->hash))
642 /* Create an entry in an i386 ELF linker hash table. */
644 static struct bfd_hash_entry *
645 link_hash_newfunc (entry, table, string)
646 struct bfd_hash_entry *entry;
647 struct bfd_hash_table *table;
650 /* Allocate the structure if it has not already been allocated by a
654 entry = bfd_hash_allocate (table,
655 sizeof (struct elf_i386_link_hash_entry));
660 /* Call the allocation method of the superclass. */
661 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
664 struct elf_i386_link_hash_entry *eh;
666 eh = (struct elf_i386_link_hash_entry *) entry;
667 eh->dyn_relocs = NULL;
668 eh->tls_type = GOT_UNKNOWN;
674 /* Create an i386 ELF linker hash table. */
676 static struct bfd_link_hash_table *
677 elf_i386_link_hash_table_create (abfd)
680 struct elf_i386_link_hash_table *ret;
681 bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
683 ret = (struct elf_i386_link_hash_table *) bfd_malloc (amt);
687 if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc))
700 ret->sym_sec.abfd = NULL;
702 return &ret->elf.root;
705 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
706 shortcuts to them in our hash table. */
709 create_got_section (dynobj, info)
711 struct bfd_link_info *info;
713 struct elf_i386_link_hash_table *htab;
715 if (! _bfd_elf_create_got_section (dynobj, info))
718 htab = elf_i386_hash_table (info);
719 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
720 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
721 if (!htab->sgot || !htab->sgotplt)
724 htab->srelgot = bfd_make_section (dynobj, ".rel.got");
725 if (htab->srelgot == NULL
726 || ! bfd_set_section_flags (dynobj, htab->srelgot,
727 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
728 | SEC_IN_MEMORY | SEC_LINKER_CREATED
730 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
735 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
736 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
740 elf_i386_create_dynamic_sections (dynobj, info)
742 struct bfd_link_info *info;
744 struct elf_i386_link_hash_table *htab;
746 htab = elf_i386_hash_table (info);
747 if (!htab->sgot && !create_got_section (dynobj, info))
750 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
753 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
754 htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
755 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
757 htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
759 if (!htab->splt || !htab->srelplt || !htab->sdynbss
760 || (!info->shared && !htab->srelbss))
766 /* Copy the extra info we tack onto an elf_link_hash_entry. */
769 elf_i386_copy_indirect_symbol (dir, ind)
770 struct elf_link_hash_entry *dir, *ind;
772 struct elf_i386_link_hash_entry *edir, *eind;
774 edir = (struct elf_i386_link_hash_entry *) dir;
775 eind = (struct elf_i386_link_hash_entry *) ind;
777 if (eind->dyn_relocs != NULL)
779 if (edir->dyn_relocs != NULL)
781 struct elf_i386_dyn_relocs **pp;
782 struct elf_i386_dyn_relocs *p;
784 if (ind->root.type == bfd_link_hash_indirect)
787 /* Add reloc counts against the weak sym to the strong sym
788 list. Merge any entries against the same section. */
789 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
791 struct elf_i386_dyn_relocs *q;
793 for (q = edir->dyn_relocs; q != NULL; q = q->next)
794 if (q->sec == p->sec)
796 q->pc_count += p->pc_count;
797 q->count += p->count;
804 *pp = edir->dyn_relocs;
807 edir->dyn_relocs = eind->dyn_relocs;
808 eind->dyn_relocs = NULL;
811 _bfd_elf_link_hash_copy_indirect (dir, ind);
815 elf_i386_tls_transition (info, r_type, is_local)
816 struct bfd_link_info *info;
826 case R_386_TLS_IE_32:
828 return R_386_TLS_LE_32;
829 return R_386_TLS_IE_32;
831 return R_386_TLS_LE_32;
837 /* Look through the relocs for a section during the first phase, and
838 calculate needed space in the global offset table, procedure linkage
839 table, and dynamic reloc sections. */
842 elf_i386_check_relocs (abfd, info, sec, relocs)
844 struct bfd_link_info *info;
846 const Elf_Internal_Rela *relocs;
848 struct elf_i386_link_hash_table *htab;
849 Elf_Internal_Shdr *symtab_hdr;
850 struct elf_link_hash_entry **sym_hashes;
851 const Elf_Internal_Rela *rel;
852 const Elf_Internal_Rela *rel_end;
855 if (info->relocateable)
858 htab = elf_i386_hash_table (info);
859 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
860 sym_hashes = elf_sym_hashes (abfd);
864 rel_end = relocs + sec->reloc_count;
865 for (rel = relocs; rel < rel_end; rel++)
868 unsigned long r_symndx;
869 struct elf_link_hash_entry *h;
871 r_symndx = ELF32_R_SYM (rel->r_info);
872 r_type = ELF32_R_TYPE (rel->r_info);
874 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
876 (*_bfd_error_handler) (_("%s: bad symbol index: %d"),
877 bfd_archive_filename (abfd),
882 if (r_symndx < symtab_hdr->sh_info)
885 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
887 r_type = elf_i386_tls_transition (info, r_type, h == NULL);
891 case R_386_TLS_IE_32:
893 info->flags |= DF_STATIC_TLS;
897 /* This symbol requires a global offset table entry. */
899 int tls_type, old_tls_type;
904 case R_386_GOT32: tls_type = GOT_NORMAL; break;
905 case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
906 case R_386_TLS_IE_32: tls_type = GOT_TLS_IE; break;
911 h->got.refcount += 1;
912 old_tls_type = elf_i386_hash_entry(h)->tls_type;
916 bfd_signed_vma *local_got_refcounts;
918 /* This is a global offset table entry for a local symbol. */
919 local_got_refcounts = elf_local_got_refcounts (abfd);
920 if (local_got_refcounts == NULL)
924 size = symtab_hdr->sh_info;
925 size *= (sizeof (bfd_signed_vma) + sizeof(char));
926 local_got_refcounts = ((bfd_signed_vma *)
927 bfd_zalloc (abfd, size));
928 if (local_got_refcounts == NULL)
930 elf_local_got_refcounts (abfd) = local_got_refcounts;
931 elf_i386_local_got_tls_type (abfd)
932 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
934 local_got_refcounts[r_symndx] += 1;
935 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
938 /* If a TLS symbol is accessed using IE at least once,
939 there is no point to use dynamic model for it. */
940 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
941 && (old_tls_type != GOT_TLS_GD || tls_type != GOT_TLS_IE))
943 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
944 tls_type = GOT_TLS_IE;
947 (*_bfd_error_handler)
948 (_("%s: `%s' accessed both as normal and thread local symbol"),
949 bfd_archive_filename (abfd), h->root.root.string);
954 if (old_tls_type != tls_type)
957 elf_i386_hash_entry (h)->tls_type = tls_type;
959 elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
967 if (htab->sgot == NULL)
969 if (htab->elf.dynobj == NULL)
970 htab->elf.dynobj = abfd;
971 if (!create_got_section (htab->elf.dynobj, info))
977 htab->tls_ldm_got.refcount += 1;
981 /* This symbol requires a procedure linkage table entry. We
982 actually build the entry in adjust_dynamic_symbol,
983 because this might be a case of linking PIC code which is
984 never referenced by a dynamic object, in which case we
985 don't need to generate a procedure linkage table entry
988 /* If this is a local symbol, we resolve it directly without
989 creating a procedure linkage table entry. */
993 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
994 h->plt.refcount += 1;
999 if (h != NULL && !info->shared)
1001 /* If this reloc is in a read-only section, we might
1002 need a copy reloc. We can't check reliably at this
1003 stage whether the section is read-only, as input
1004 sections have not yet been mapped to output sections.
1005 Tentatively set the flag for now, and correct in
1006 adjust_dynamic_symbol. */
1007 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
1009 /* We may need a .plt entry if the function this reloc
1010 refers to is in a shared lib. */
1011 h->plt.refcount += 1;
1014 /* If we are creating a shared library, and this is a reloc
1015 against a global symbol, or a non PC relative reloc
1016 against a local symbol, then we need to copy the reloc
1017 into the shared library. However, if we are linking with
1018 -Bsymbolic, we do not need to copy a reloc against a
1019 global symbol which is defined in an object we are
1020 including in the link (i.e., DEF_REGULAR is set). At
1021 this point we have not seen all the input files, so it is
1022 possible that DEF_REGULAR is not set now but will be set
1023 later (it is never cleared). In case of a weak definition,
1024 DEF_REGULAR may be cleared later by a strong definition in
1025 a shared library. We account for that possibility below by
1026 storing information in the relocs_copied field of the hash
1027 table entry. A similar situation occurs when creating
1028 shared libraries and symbol visibility changes render the
1031 If on the other hand, we are creating an executable, we
1032 may need to keep relocations for symbols satisfied by a
1033 dynamic library if we manage to avoid copy relocs for the
1036 && (sec->flags & SEC_ALLOC) != 0
1037 && (r_type != R_386_PC32
1039 && (! info->symbolic
1040 || h->root.type == bfd_link_hash_defweak
1041 || (h->elf_link_hash_flags
1042 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1044 && (sec->flags & SEC_ALLOC) != 0
1046 && (h->root.type == bfd_link_hash_defweak
1047 || (h->elf_link_hash_flags
1048 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
1050 struct elf_i386_dyn_relocs *p;
1051 struct elf_i386_dyn_relocs **head;
1053 /* We must copy these reloc types into the output file.
1054 Create a reloc section in dynobj and make room for
1060 unsigned int strndx = elf_elfheader (abfd)->e_shstrndx;
1061 unsigned int shnam = elf_section_data (sec)->rel_hdr.sh_name;
1063 name = bfd_elf_string_from_elf_section (abfd, strndx, shnam);
1067 if (strncmp (name, ".rel", 4) != 0
1068 || strcmp (bfd_get_section_name (abfd, sec),
1071 (*_bfd_error_handler)
1072 (_("%s: bad relocation section name `%s\'"),
1073 bfd_archive_filename (abfd), name);
1076 if (htab->elf.dynobj == NULL)
1077 htab->elf.dynobj = abfd;
1079 dynobj = htab->elf.dynobj;
1080 sreloc = bfd_get_section_by_name (dynobj, name);
1085 sreloc = bfd_make_section (dynobj, name);
1086 flags = (SEC_HAS_CONTENTS | SEC_READONLY
1087 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1088 if ((sec->flags & SEC_ALLOC) != 0)
1089 flags |= SEC_ALLOC | SEC_LOAD;
1091 || ! bfd_set_section_flags (dynobj, sreloc, flags)
1092 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
1095 elf_section_data (sec)->sreloc = sreloc;
1098 /* If this is a global symbol, we count the number of
1099 relocations we need for this symbol. */
1102 head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs;
1106 /* Track dynamic relocs needed for local syms too.
1107 We really need local syms available to do this
1111 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1116 head = ((struct elf_i386_dyn_relocs **)
1117 &elf_section_data (s)->local_dynrel);
1121 if (p == NULL || p->sec != sec)
1123 bfd_size_type amt = sizeof *p;
1124 p = ((struct elf_i386_dyn_relocs *)
1125 bfd_alloc (htab->elf.dynobj, amt));
1136 if (r_type == R_386_PC32)
1141 /* This relocation describes the C++ object vtable hierarchy.
1142 Reconstruct it for later use during GC. */
1143 case R_386_GNU_VTINHERIT:
1144 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1148 /* This relocation describes which C++ vtable entries are actually
1149 used. Record for later use during GC. */
1150 case R_386_GNU_VTENTRY:
1151 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
1155 case R_386_TLS_LE_32:
1159 (*_bfd_error_handler) (_("%s: TLS local exec code cannot be linked into shared objects"),
1160 bfd_archive_filename (abfd));
1173 /* Return the section that should be marked against GC for a given
1177 elf_i386_gc_mark_hook (abfd, info, rel, h, sym)
1179 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1180 Elf_Internal_Rela *rel;
1181 struct elf_link_hash_entry *h;
1182 Elf_Internal_Sym *sym;
1186 switch (ELF32_R_TYPE (rel->r_info))
1188 case R_386_GNU_VTINHERIT:
1189 case R_386_GNU_VTENTRY:
1193 switch (h->root.type)
1195 case bfd_link_hash_defined:
1196 case bfd_link_hash_defweak:
1197 return h->root.u.def.section;
1199 case bfd_link_hash_common:
1200 return h->root.u.c.p->section;
1209 return bfd_section_from_elf_index (abfd, sym->st_shndx);
1215 /* Update the got entry reference counts for the section being removed. */
1218 elf_i386_gc_sweep_hook (abfd, info, sec, relocs)
1220 struct bfd_link_info *info;
1222 const Elf_Internal_Rela *relocs;
1224 Elf_Internal_Shdr *symtab_hdr;
1225 struct elf_link_hash_entry **sym_hashes;
1226 bfd_signed_vma *local_got_refcounts;
1227 const Elf_Internal_Rela *rel, *relend;
1228 unsigned long r_symndx;
1229 struct elf_link_hash_entry *h;
1231 elf_section_data (sec)->local_dynrel = NULL;
1233 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1234 sym_hashes = elf_sym_hashes (abfd);
1235 local_got_refcounts = elf_local_got_refcounts (abfd);
1237 relend = relocs + sec->reloc_count;
1238 for (rel = relocs; rel < relend; rel++)
1239 switch (elf_i386_tls_transition (info, ELF32_R_TYPE (rel->r_info),
1240 ELF32_R_SYM (rel->r_info)
1241 >= symtab_hdr->sh_info))
1244 if (elf_i386_hash_table (info)->tls_ldm_got.refcount > 0)
1245 elf_i386_hash_table (info)->tls_ldm_got.refcount -= 1;
1249 case R_386_TLS_IE_32:
1251 r_symndx = ELF32_R_SYM (rel->r_info);
1252 if (r_symndx >= symtab_hdr->sh_info)
1254 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1255 if (h->got.refcount > 0)
1256 h->got.refcount -= 1;
1258 else if (local_got_refcounts != NULL)
1260 if (local_got_refcounts[r_symndx] > 0)
1261 local_got_refcounts[r_symndx] -= 1;
1267 r_symndx = ELF32_R_SYM (rel->r_info);
1268 if (r_symndx >= symtab_hdr->sh_info)
1270 struct elf_i386_link_hash_entry *eh;
1271 struct elf_i386_dyn_relocs **pp;
1272 struct elf_i386_dyn_relocs *p;
1274 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1276 if (!info->shared && h->plt.refcount > 0)
1277 h->plt.refcount -= 1;
1279 eh = (struct elf_i386_link_hash_entry *) h;
1281 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1284 if (ELF32_R_TYPE (rel->r_info) == R_386_PC32)
1295 r_symndx = ELF32_R_SYM (rel->r_info);
1296 if (r_symndx >= symtab_hdr->sh_info)
1298 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1299 if (h->plt.refcount > 0)
1300 h->plt.refcount -= 1;
1311 /* Adjust a symbol defined by a dynamic object and referenced by a
1312 regular object. The current definition is in some section of the
1313 dynamic object, but we're not including those sections. We have to
1314 change the definition to something the rest of the link can
1318 elf_i386_adjust_dynamic_symbol (info, h)
1319 struct bfd_link_info *info;
1320 struct elf_link_hash_entry *h;
1322 struct elf_i386_link_hash_table *htab;
1323 struct elf_i386_link_hash_entry * eh;
1324 struct elf_i386_dyn_relocs *p;
1326 unsigned int power_of_two;
1328 /* If this is a function, put it in the procedure linkage table. We
1329 will fill in the contents of the procedure linkage table later,
1330 when we know the address of the .got section. */
1331 if (h->type == STT_FUNC
1332 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
1334 if (h->plt.refcount <= 0
1336 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
1337 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
1338 && h->root.type != bfd_link_hash_undefweak
1339 && h->root.type != bfd_link_hash_undefined))
1341 /* This case can occur if we saw a PLT32 reloc in an input
1342 file, but the symbol was never referred to by a dynamic
1343 object, or if all references were garbage collected. In
1344 such a case, we don't actually need to build a procedure
1345 linkage table, and we can just do a PC32 reloc instead. */
1346 h->plt.offset = (bfd_vma) -1;
1347 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1353 /* It's possible that we incorrectly decided a .plt reloc was
1354 needed for an R_386_PC32 reloc to a non-function sym in
1355 check_relocs. We can't decide accurately between function and
1356 non-function syms in check-relocs; Objects loaded later in
1357 the link may change h->type. So fix it now. */
1358 h->plt.offset = (bfd_vma) -1;
1360 /* If this is a weak symbol, and there is a real definition, the
1361 processor independent code will have arranged for us to see the
1362 real definition first, and we can just use the same value. */
1363 if (h->weakdef != NULL)
1365 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1366 || h->weakdef->root.type == bfd_link_hash_defweak);
1367 h->root.u.def.section = h->weakdef->root.u.def.section;
1368 h->root.u.def.value = h->weakdef->root.u.def.value;
1372 /* This is a reference to a symbol defined by a dynamic object which
1373 is not a function. */
1375 /* If we are creating a shared library, we must presume that the
1376 only references to the symbol are via the global offset table.
1377 For such cases we need not do anything here; the relocations will
1378 be handled correctly by relocate_section. */
1382 /* If there are no references to this symbol that do not use the
1383 GOT, we don't need to generate a copy reloc. */
1384 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
1387 /* If -z nocopyreloc was given, we won't generate them either. */
1388 if (info->nocopyreloc)
1390 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1394 eh = (struct elf_i386_link_hash_entry *) h;
1395 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1397 s = p->sec->output_section;
1398 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1402 /* If we didn't find any dynamic relocs in read-only sections, then
1403 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1406 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1410 /* We must allocate the symbol in our .dynbss section, which will
1411 become part of the .bss section of the executable. There will be
1412 an entry for this symbol in the .dynsym section. The dynamic
1413 object will contain position independent code, so all references
1414 from the dynamic object to this symbol will go through the global
1415 offset table. The dynamic linker will use the .dynsym entry to
1416 determine the address it must put in the global offset table, so
1417 both the dynamic object and the regular object will refer to the
1418 same memory location for the variable. */
1420 htab = elf_i386_hash_table (info);
1422 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1423 copy the initial value out of the dynamic object and into the
1424 runtime process image. */
1425 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1427 htab->srelbss->_raw_size += sizeof (Elf32_External_Rel);
1428 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1431 /* We need to figure out the alignment required for this symbol. I
1432 have no idea how ELF linkers handle this. */
1433 power_of_two = bfd_log2 (h->size);
1434 if (power_of_two > 3)
1437 /* Apply the required alignment. */
1439 s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
1440 if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
1442 if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
1446 /* Define the symbol as being at this point in the section. */
1447 h->root.u.def.section = s;
1448 h->root.u.def.value = s->_raw_size;
1450 /* Increment the section size to make room for the symbol. */
1451 s->_raw_size += h->size;
1456 /* This is the condition under which elf_i386_finish_dynamic_symbol
1457 will be called from elflink.h. If elflink.h doesn't call our
1458 finish_dynamic_symbol routine, we'll need to do something about
1459 initializing any .plt and .got entries in elf_i386_relocate_section. */
1460 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1462 && ((INFO)->shared \
1463 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1464 && ((H)->dynindx != -1 \
1465 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1467 /* Allocate space in .plt, .got and associated reloc sections for
1471 allocate_dynrelocs (h, inf)
1472 struct elf_link_hash_entry *h;
1475 struct bfd_link_info *info;
1476 struct elf_i386_link_hash_table *htab;
1477 struct elf_i386_link_hash_entry *eh;
1478 struct elf_i386_dyn_relocs *p;
1480 if (h->root.type == bfd_link_hash_indirect)
1483 if (h->root.type == bfd_link_hash_warning)
1484 /* When warning symbols are created, they **replace** the "real"
1485 entry in the hash table, thus we never get to see the real
1486 symbol in a hash traversal. So look at it now. */
1487 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1489 info = (struct bfd_link_info *) inf;
1490 htab = elf_i386_hash_table (info);
1492 if (htab->elf.dynamic_sections_created
1493 && h->plt.refcount > 0)
1495 /* Make sure this symbol is output as a dynamic symbol.
1496 Undefined weak syms won't yet be marked as dynamic. */
1497 if (h->dynindx == -1
1498 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1500 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1504 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
1506 asection *s = htab->splt;
1508 /* If this is the first .plt entry, make room for the special
1510 if (s->_raw_size == 0)
1511 s->_raw_size += PLT_ENTRY_SIZE;
1513 h->plt.offset = s->_raw_size;
1515 /* If this symbol is not defined in a regular file, and we are
1516 not generating a shared library, then set the symbol to this
1517 location in the .plt. This is required to make function
1518 pointers compare as equal between the normal executable and
1519 the shared library. */
1521 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1523 h->root.u.def.section = s;
1524 h->root.u.def.value = h->plt.offset;
1527 /* Make room for this entry. */
1528 s->_raw_size += PLT_ENTRY_SIZE;
1530 /* We also need to make an entry in the .got.plt section, which
1531 will be placed in the .got section by the linker script. */
1532 htab->sgotplt->_raw_size += 4;
1534 /* We also need to make an entry in the .rel.plt section. */
1535 htab->srelplt->_raw_size += sizeof (Elf32_External_Rel);
1539 h->plt.offset = (bfd_vma) -1;
1540 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1545 h->plt.offset = (bfd_vma) -1;
1546 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1549 /* If R_386_TLS_IE_32 symbol is now local to the binary,
1550 make it a R_386_TLS_LE_32 requiring no TLS entry. */
1551 if (h->got.refcount > 0
1554 && elf_i386_hash_entry(h)->tls_type == GOT_TLS_IE)
1555 h->got.offset = (bfd_vma) -1;
1556 else if (h->got.refcount > 0)
1560 int tls_type = elf_i386_hash_entry(h)->tls_type;
1562 /* Make sure this symbol is output as a dynamic symbol.
1563 Undefined weak syms won't yet be marked as dynamic. */
1564 if (h->dynindx == -1
1565 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1567 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1572 h->got.offset = s->_raw_size;
1574 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
1575 if (tls_type == GOT_TLS_GD)
1577 dyn = htab->elf.dynamic_sections_created;
1578 /* R_386_TLS_IE_32 needs one dynamic relocation,
1579 R_386_TLS_GD needs one if local symbol and two if global. */
1580 if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1581 || tls_type == GOT_TLS_IE)
1582 htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1583 else if (tls_type == GOT_TLS_GD)
1584 htab->srelgot->_raw_size += 2 * sizeof (Elf32_External_Rel);
1585 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
1586 htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1589 h->got.offset = (bfd_vma) -1;
1591 eh = (struct elf_i386_link_hash_entry *) h;
1592 if (eh->dyn_relocs == NULL)
1595 /* In the shared -Bsymbolic case, discard space allocated for
1596 dynamic pc-relative relocs against symbols which turn out to be
1597 defined in regular objects. For the normal shared case, discard
1598 space for pc-relative relocs that have become local due to symbol
1599 visibility changes. */
1603 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1604 && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1607 struct elf_i386_dyn_relocs **pp;
1609 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1611 p->count -= p->pc_count;
1622 /* For the non-shared case, discard space for relocs against
1623 symbols which turn out to need copy relocs or are not
1626 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1627 && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1628 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1629 || (htab->elf.dynamic_sections_created
1630 && (h->root.type == bfd_link_hash_undefweak
1631 || h->root.type == bfd_link_hash_undefined))))
1633 /* Make sure this symbol is output as a dynamic symbol.
1634 Undefined weak syms won't yet be marked as dynamic. */
1635 if (h->dynindx == -1
1636 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1638 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1642 /* If that succeeded, we know we'll be keeping all the
1644 if (h->dynindx != -1)
1648 eh->dyn_relocs = NULL;
1653 /* Finally, allocate space. */
1654 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1656 asection *sreloc = elf_section_data (p->sec)->sreloc;
1657 sreloc->_raw_size += p->count * sizeof (Elf32_External_Rel);
1663 /* Find any dynamic relocs that apply to read-only sections. */
1666 readonly_dynrelocs (h, inf)
1667 struct elf_link_hash_entry *h;
1670 struct elf_i386_link_hash_entry *eh;
1671 struct elf_i386_dyn_relocs *p;
1673 if (h->root.type == bfd_link_hash_warning)
1674 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1676 eh = (struct elf_i386_link_hash_entry *) h;
1677 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1679 asection *s = p->sec->output_section;
1681 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1683 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1685 info->flags |= DF_TEXTREL;
1687 /* Not an error, just cut short the traversal. */
1694 /* Set the sizes of the dynamic sections. */
1697 elf_i386_size_dynamic_sections (output_bfd, info)
1698 bfd *output_bfd ATTRIBUTE_UNUSED;
1699 struct bfd_link_info *info;
1701 struct elf_i386_link_hash_table *htab;
1707 htab = elf_i386_hash_table (info);
1708 dynobj = htab->elf.dynobj;
1712 if (htab->elf.dynamic_sections_created)
1714 /* Set the contents of the .interp section to the interpreter. */
1717 s = bfd_get_section_by_name (dynobj, ".interp");
1720 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1721 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1725 /* Set up .got offsets for local syms, and space for local dynamic
1727 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1729 bfd_signed_vma *local_got;
1730 bfd_signed_vma *end_local_got;
1731 char *local_tls_type;
1732 bfd_size_type locsymcount;
1733 Elf_Internal_Shdr *symtab_hdr;
1736 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1739 for (s = ibfd->sections; s != NULL; s = s->next)
1741 struct elf_i386_dyn_relocs *p;
1743 for (p = *((struct elf_i386_dyn_relocs **)
1744 &elf_section_data (s)->local_dynrel);
1748 if (!bfd_is_abs_section (p->sec)
1749 && bfd_is_abs_section (p->sec->output_section))
1751 /* Input section has been discarded, either because
1752 it is a copy of a linkonce section or due to
1753 linker script /DISCARD/, so we'll be discarding
1756 else if (p->count != 0)
1758 srel = elf_section_data (p->sec)->sreloc;
1759 srel->_raw_size += p->count * sizeof (Elf32_External_Rel);
1760 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1761 info->flags |= DF_TEXTREL;
1766 local_got = elf_local_got_refcounts (ibfd);
1770 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1771 locsymcount = symtab_hdr->sh_info;
1772 end_local_got = local_got + locsymcount;
1773 local_tls_type = elf_i386_local_got_tls_type (ibfd);
1775 srel = htab->srelgot;
1776 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
1780 *local_got = s->_raw_size;
1782 if (*local_tls_type == GOT_TLS_GD)
1785 || *local_tls_type == GOT_TLS_GD
1786 || *local_tls_type == GOT_TLS_IE)
1787 srel->_raw_size += sizeof (Elf32_External_Rel);
1790 *local_got = (bfd_vma) -1;
1794 if (htab->tls_ldm_got.refcount > 0)
1796 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1798 htab->tls_ldm_got.offset = htab->sgot->_raw_size;
1799 htab->sgot->_raw_size += 8;
1800 htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1803 htab->tls_ldm_got.offset = -1;
1805 /* Allocate global sym .plt and .got entries, and space for global
1806 sym dynamic relocs. */
1807 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
1809 /* We now have determined the sizes of the various dynamic sections.
1810 Allocate memory for them. */
1812 for (s = dynobj->sections; s != NULL; s = s->next)
1814 if ((s->flags & SEC_LINKER_CREATED) == 0)
1819 || s == htab->sgotplt)
1821 /* Strip this section if we don't need it; see the
1824 else if (strncmp (bfd_get_section_name (dynobj, s), ".rel", 4) == 0)
1826 if (s->_raw_size != 0 && s != htab->srelplt)
1829 /* We use the reloc_count field as a counter if we need
1830 to copy relocs into the output file. */
1835 /* It's not one of our sections, so don't allocate space. */
1839 if (s->_raw_size == 0)
1841 /* If we don't need this section, strip it from the
1842 output file. This is mostly to handle .rel.bss and
1843 .rel.plt. We must create both sections in
1844 create_dynamic_sections, because they must be created
1845 before the linker maps input sections to output
1846 sections. The linker does that before
1847 adjust_dynamic_symbol is called, and it is that
1848 function which decides whether anything needs to go
1849 into these sections. */
1851 _bfd_strip_section_from_output (info, s);
1855 /* Allocate memory for the section contents. We use bfd_zalloc
1856 here in case unused entries are not reclaimed before the
1857 section's contents are written out. This should not happen,
1858 but this way if it does, we get a R_386_NONE reloc instead
1860 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1861 if (s->contents == NULL)
1865 if (htab->elf.dynamic_sections_created)
1867 /* Add some entries to the .dynamic section. We fill in the
1868 values later, in elf_i386_finish_dynamic_sections, but we
1869 must add the entries now so that we get the correct size for
1870 the .dynamic section. The DT_DEBUG entry is filled in by the
1871 dynamic linker and used by the debugger. */
1872 #define add_dynamic_entry(TAG, VAL) \
1873 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1877 if (!add_dynamic_entry (DT_DEBUG, 0))
1881 if (htab->splt->_raw_size != 0)
1883 if (!add_dynamic_entry (DT_PLTGOT, 0)
1884 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1885 || !add_dynamic_entry (DT_PLTREL, DT_REL)
1886 || !add_dynamic_entry (DT_JMPREL, 0))
1892 if (!add_dynamic_entry (DT_REL, 0)
1893 || !add_dynamic_entry (DT_RELSZ, 0)
1894 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
1897 /* If any dynamic relocs apply to a read-only section,
1898 then we need a DT_TEXTREL entry. */
1899 if ((info->flags & DF_TEXTREL) == 0)
1900 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
1903 if ((info->flags & DF_TEXTREL) != 0)
1905 if (!add_dynamic_entry (DT_TEXTREL, 0))
1910 #undef add_dynamic_entry
1915 /* Set the correct type for an x86 ELF section. We do this by the
1916 section name, which is a hack, but ought to work. */
1919 elf_i386_fake_sections (abfd, hdr, sec)
1920 bfd *abfd ATTRIBUTE_UNUSED;
1921 Elf32_Internal_Shdr *hdr;
1924 register const char *name;
1926 name = bfd_get_section_name (abfd, sec);
1928 /* This is an ugly, but unfortunately necessary hack that is
1929 needed when producing EFI binaries on x86. It tells
1930 elf.c:elf_fake_sections() not to consider ".reloc" as a section
1931 containing ELF relocation info. We need this hack in order to
1932 be able to generate ELF binaries that can be translated into
1933 EFI applications (which are essentially COFF objects). Those
1934 files contain a COFF ".reloc" section inside an ELFNN object,
1935 which would normally cause BFD to segfault because it would
1936 attempt to interpret this section as containing relocation
1937 entries for section "oc". With this hack enabled, ".reloc"
1938 will be treated as a normal data section, which will avoid the
1939 segfault. However, you won't be able to create an ELFNN binary
1940 with a section named "oc" that needs relocations, but that's
1941 the kind of ugly side-effects you get when detecting section
1942 types based on their names... In practice, this limitation is
1943 unlikely to bite. */
1944 if (strcmp (name, ".reloc") == 0)
1945 hdr->sh_type = SHT_PROGBITS;
1950 /* Return the base VMA address which should be subtracted from real addresses
1951 when resolving @dtpoff relocation.
1952 This is PT_TLS segment p_vaddr. */
1956 struct bfd_link_info *info;
1958 BFD_ASSERT (elf_hash_table (info)->tls_segment != NULL);
1959 return elf_hash_table (info)->tls_segment->start;
1962 /* Return the relocation value for @tpoff relocation
1963 if STT_TLS virtual address is ADDRESS. */
1966 tpoff (info, address)
1967 struct bfd_link_info *info;
1970 struct elf_link_tls_segment *tls_segment
1971 = elf_hash_table (info)->tls_segment;
1973 BFD_ASSERT (tls_segment != NULL);
1974 return (align_power (tls_segment->size, tls_segment->align)
1975 + tls_segment->start - address);
1978 /* Relocate an i386 ELF section. */
1981 elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
1982 contents, relocs, local_syms, local_sections)
1984 struct bfd_link_info *info;
1986 asection *input_section;
1988 Elf_Internal_Rela *relocs;
1989 Elf_Internal_Sym *local_syms;
1990 asection **local_sections;
1992 struct elf_i386_link_hash_table *htab;
1993 Elf_Internal_Shdr *symtab_hdr;
1994 struct elf_link_hash_entry **sym_hashes;
1995 bfd_vma *local_got_offsets;
1996 Elf_Internal_Rela *rel;
1997 Elf_Internal_Rela *relend;
1999 htab = elf_i386_hash_table (info);
2000 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2001 sym_hashes = elf_sym_hashes (input_bfd);
2002 local_got_offsets = elf_local_got_offsets (input_bfd);
2005 relend = relocs + input_section->reloc_count;
2006 for (; rel < relend; rel++)
2008 unsigned int r_type;
2009 reloc_howto_type *howto;
2010 unsigned long r_symndx;
2011 struct elf_link_hash_entry *h;
2012 Elf_Internal_Sym *sym;
2016 boolean unresolved_reloc;
2017 bfd_reloc_status_type r;
2021 r_type = ELF32_R_TYPE (rel->r_info);
2022 if (r_type == (int) R_386_GNU_VTINHERIT
2023 || r_type == (int) R_386_GNU_VTENTRY)
2026 if ((indx = (unsigned) r_type) >= R_386_standard
2027 && ((indx = r_type - R_386_ext_offset) - R_386_standard
2028 >= R_386_ext - R_386_standard)
2029 && ((indx = r_type - R_386_tls_offset) - R_386_ext
2030 >= R_386_tls - R_386_ext))
2032 bfd_set_error (bfd_error_bad_value);
2035 howto = elf_howto_table + indx;
2037 r_symndx = ELF32_R_SYM (rel->r_info);
2039 if (info->relocateable)
2044 /* This is a relocatable link. We don't have to change
2045 anything, unless the reloc is against a section symbol,
2046 in which case we have to adjust according to where the
2047 section symbol winds up in the output section. */
2048 if (r_symndx >= symtab_hdr->sh_info)
2051 sym = local_syms + r_symndx;
2052 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2055 sec = local_sections[r_symndx];
2056 val = sec->output_offset;
2060 where = contents + rel->r_offset;
2061 switch (howto->size)
2063 /* FIXME: overflow checks. */
2065 val += bfd_get_8 (input_bfd, where);
2066 bfd_put_8 (input_bfd, val, where);
2069 val += bfd_get_16 (input_bfd, where);
2070 bfd_put_16 (input_bfd, val, where);
2073 val += bfd_get_32 (input_bfd, where);
2074 bfd_put_32 (input_bfd, val, where);
2082 /* This is a final link. */
2086 unresolved_reloc = false;
2087 if (r_symndx < symtab_hdr->sh_info)
2089 sym = local_syms + r_symndx;
2090 sec = local_sections[r_symndx];
2091 relocation = (sec->output_section->vma
2092 + sec->output_offset
2094 if ((sec->flags & SEC_MERGE)
2095 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2099 bfd_byte *where = contents + rel->r_offset;
2101 switch (howto->size)
2104 addend = bfd_get_8 (input_bfd, where);
2105 if (howto->pc_relative)
2107 addend = (addend ^ 0x80) - 0x80;
2112 addend = bfd_get_16 (input_bfd, where);
2113 if (howto->pc_relative)
2115 addend = (addend ^ 0x8000) - 0x8000;
2120 addend = bfd_get_32 (input_bfd, where);
2121 if (howto->pc_relative)
2123 addend = (addend ^ 0x80000000) - 0x80000000;
2132 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2133 addend -= relocation;
2134 addend += msec->output_section->vma + msec->output_offset;
2136 switch (howto->size)
2139 /* FIXME: overflow checks. */
2140 if (howto->pc_relative)
2142 bfd_put_8 (input_bfd, addend, where);
2145 if (howto->pc_relative)
2147 bfd_put_16 (input_bfd, addend, where);
2150 if (howto->pc_relative)
2152 bfd_put_32 (input_bfd, addend, where);
2159 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2160 while (h->root.type == bfd_link_hash_indirect
2161 || h->root.type == bfd_link_hash_warning)
2162 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2165 if (h->root.type == bfd_link_hash_defined
2166 || h->root.type == bfd_link_hash_defweak)
2168 sec = h->root.u.def.section;
2169 if (sec->output_section == NULL)
2170 /* Set a flag that will be cleared later if we find a
2171 relocation value for this symbol. output_section
2172 is typically NULL for symbols satisfied by a shared
2174 unresolved_reloc = true;
2176 relocation = (h->root.u.def.value
2177 + sec->output_section->vma
2178 + sec->output_offset);
2180 else if (h->root.type == bfd_link_hash_undefweak)
2182 else if (info->shared
2183 && (!info->symbolic || info->allow_shlib_undefined)
2184 && !info->no_undefined
2185 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2189 if (! ((*info->callbacks->undefined_symbol)
2190 (info, h->root.root.string, input_bfd,
2191 input_section, rel->r_offset,
2192 (!info->shared || info->no_undefined
2193 || ELF_ST_VISIBILITY (h->other)))))
2201 /* Relocation is to the entry for this symbol in the global
2203 if (htab->sgot == NULL)
2210 off = h->got.offset;
2211 dyn = htab->elf.dynamic_sections_created;
2212 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
2216 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2217 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
2219 /* This is actually a static link, or it is a
2220 -Bsymbolic link and the symbol is defined
2221 locally, or the symbol was forced to be local
2222 because of a version file. We must initialize
2223 this entry in the global offset table. Since the
2224 offset must always be a multiple of 4, we use the
2225 least significant bit to record whether we have
2226 initialized it already.
2228 When doing a dynamic link, we create a .rel.got
2229 relocation entry to initialize the value. This
2230 is done in the finish_dynamic_symbol routine. */
2235 bfd_put_32 (output_bfd, relocation,
2236 htab->sgot->contents + off);
2241 unresolved_reloc = false;
2245 if (local_got_offsets == NULL)
2248 off = local_got_offsets[r_symndx];
2250 /* The offset must always be a multiple of 4. We use
2251 the least significant bit to record whether we have
2252 already generated the necessary reloc. */
2257 bfd_put_32 (output_bfd, relocation,
2258 htab->sgot->contents + off);
2263 Elf_Internal_Rel outrel;
2264 Elf32_External_Rel *loc;
2266 srelgot = htab->srelgot;
2267 if (srelgot == NULL)
2270 outrel.r_offset = (htab->sgot->output_section->vma
2271 + htab->sgot->output_offset
2273 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2274 loc = (Elf32_External_Rel *) srelgot->contents;
2275 loc += srelgot->reloc_count++;
2276 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2279 local_got_offsets[r_symndx] |= 1;
2283 if (off >= (bfd_vma) -2)
2286 relocation = htab->sgot->output_offset + off;
2290 /* Relocation is relative to the start of the global offset
2293 /* Note that sgot->output_offset is not involved in this
2294 calculation. We always want the start of .got. If we
2295 defined _GLOBAL_OFFSET_TABLE in a different way, as is
2296 permitted by the ABI, we might have to change this
2298 relocation -= htab->sgot->output_section->vma;
2302 /* Use global offset table as symbol value. */
2303 relocation = htab->sgot->output_section->vma;
2304 unresolved_reloc = false;
2308 /* Relocation is to the entry for this symbol in the
2309 procedure linkage table. */
2311 /* Resolve a PLT32 reloc against a local symbol directly,
2312 without using the procedure linkage table. */
2316 if (h->plt.offset == (bfd_vma) -1
2317 || htab->splt == NULL)
2319 /* We didn't make a PLT entry for this symbol. This
2320 happens when statically linking PIC code, or when
2321 using -Bsymbolic. */
2325 relocation = (htab->splt->output_section->vma
2326 + htab->splt->output_offset
2328 unresolved_reloc = false;
2333 /* r_symndx will be zero only for relocs against symbols
2334 from removed linkonce sections, or sections discarded by
2337 || (input_section->flags & SEC_ALLOC) == 0)
2341 && (r_type != R_386_PC32
2344 && (! info->symbolic
2345 || (h->elf_link_hash_flags
2346 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2350 && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
2351 && (((h->elf_link_hash_flags
2352 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2353 && (h->elf_link_hash_flags
2354 & ELF_LINK_HASH_DEF_REGULAR) == 0)
2355 || h->root.type == bfd_link_hash_undefweak
2356 || h->root.type == bfd_link_hash_undefined)))
2358 Elf_Internal_Rel outrel;
2359 boolean skip, relocate;
2361 Elf32_External_Rel *loc;
2363 /* When generating a shared object, these relocations
2364 are copied into the output file to be resolved at run
2371 _bfd_elf_section_offset (output_bfd, info, input_section,
2373 if (outrel.r_offset == (bfd_vma) -1)
2375 else if (outrel.r_offset == (bfd_vma) -2)
2376 skip = true, relocate = true;
2377 outrel.r_offset += (input_section->output_section->vma
2378 + input_section->output_offset);
2381 memset (&outrel, 0, sizeof outrel);
2384 && (r_type == R_386_PC32
2387 || (h->elf_link_hash_flags
2388 & ELF_LINK_HASH_DEF_REGULAR) == 0))
2389 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2392 /* This symbol is local, or marked to become local. */
2394 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2397 sreloc = elf_section_data (input_section)->sreloc;
2401 loc = (Elf32_External_Rel *) sreloc->contents;
2402 loc += sreloc->reloc_count++;
2403 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2405 /* If this reloc is against an external symbol, we do
2406 not want to fiddle with the addend. Otherwise, we
2407 need to include the symbol value so that it becomes
2408 an addend for the dynamic reloc. */
2415 case R_386_TLS_IE_32:
2416 r_type = elf_i386_tls_transition (info, r_type, h == NULL);
2417 tls_type = GOT_UNKNOWN;
2418 if (h == NULL && local_got_offsets)
2419 tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
2422 tls_type = elf_i386_hash_entry(h)->tls_type;
2423 if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
2424 r_type = R_386_TLS_LE_32;
2426 if (r_type == R_386_TLS_GD && tls_type == GOT_TLS_IE)
2427 r_type = R_386_TLS_IE_32;
2429 if (r_type == R_386_TLS_LE_32)
2431 BFD_ASSERT (unresolved_reloc == false);
2432 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
2434 unsigned int val, type;
2437 /* GD->LE transition. */
2438 BFD_ASSERT (rel->r_offset >= 2);
2439 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2440 BFD_ASSERT (type == 0x8d || type == 0x04);
2441 BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2442 BFD_ASSERT (bfd_get_8 (input_bfd,
2443 contents + rel->r_offset + 4)
2445 BFD_ASSERT (rel + 1 < relend);
2446 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2447 roff = rel->r_offset + 5;
2448 val = bfd_get_8 (input_bfd,
2449 contents + rel->r_offset - 1);
2452 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2454 movl %gs:0, %eax; subl $foo@tpoff, %eax
2455 (6 byte form of subl). */
2456 BFD_ASSERT (rel->r_offset >= 3);
2457 BFD_ASSERT (bfd_get_8 (input_bfd,
2458 contents + rel->r_offset - 3)
2460 BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2461 memcpy (contents + rel->r_offset - 3,
2462 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2466 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2467 if (rel->r_offset + 10 <= input_section->_raw_size
2468 && bfd_get_8 (input_bfd,
2469 contents + rel->r_offset + 9) == 0x90)
2471 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2473 movl %gs:0, %eax; subl $foo@tpoff, %eax
2474 (6 byte form of subl). */
2475 memcpy (contents + rel->r_offset - 2,
2476 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2477 roff = rel->r_offset + 6;
2481 /* leal foo(%reg), %eax; call ___tls_get_addr
2483 movl %gs:0, %eax; subl $foo@tpoff, %eax
2484 (5 byte form of subl). */
2485 memcpy (contents + rel->r_offset - 2,
2486 "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2489 bfd_put_32 (output_bfd, tpoff (info, relocation),
2491 /* Skip R_386_PLT32. */
2497 unsigned int val, type;
2499 /* IE->LE transition:
2500 Originally it can be either:
2501 subl foo(%reg1), %reg2
2503 movl foo(%reg1), %reg2
2507 movl $foo, %reg2 (6 byte form) */
2508 BFD_ASSERT (rel->r_offset >= 2);
2509 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2510 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2511 BFD_ASSERT (rel->r_offset + 4 <= input_section->_raw_size);
2515 BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
2516 bfd_put_8 (output_bfd, 0xc7,
2517 contents + rel->r_offset - 2);
2518 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2519 contents + rel->r_offset - 1);
2521 else if (type == 0x2b)
2524 BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
2525 bfd_put_8 (output_bfd, 0x81,
2526 contents + rel->r_offset - 2);
2527 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
2528 contents + rel->r_offset - 1);
2532 bfd_put_32 (output_bfd, tpoff (info, relocation),
2533 contents + rel->r_offset);
2538 if (htab->sgot == NULL)
2542 off = h->got.offset;
2545 if (local_got_offsets == NULL)
2548 off = local_got_offsets[r_symndx];
2555 Elf_Internal_Rel outrel;
2556 Elf32_External_Rel *loc;
2559 if (htab->srelgot == NULL)
2562 outrel.r_offset = (htab->sgot->output_section->vma
2563 + htab->sgot->output_offset + off);
2565 bfd_put_32 (output_bfd, 0,
2566 htab->sgot->contents + off);
2567 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2568 if (r_type == R_386_TLS_GD)
2569 dr_type = R_386_TLS_DTPMOD32;
2571 dr_type = R_386_TLS_TPOFF32;
2572 outrel.r_info = ELF32_R_INFO (indx, dr_type);
2573 loc = (Elf32_External_Rel *) htab->srelgot->contents;
2574 loc += htab->srelgot->reloc_count++;
2575 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2577 if (r_type == R_386_TLS_GD)
2581 BFD_ASSERT (unresolved_reloc == false);
2582 bfd_put_32 (output_bfd,
2583 relocation - dtpoff_base (info),
2584 htab->sgot->contents + off + 4);
2588 bfd_put_32 (output_bfd, 0,
2589 htab->sgot->contents + off + 4);
2590 outrel.r_info = ELF32_R_INFO (indx,
2591 R_386_TLS_DTPOFF32);
2592 outrel.r_offset += 4;
2593 htab->srelgot->reloc_count++;
2595 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
2603 local_got_offsets[r_symndx] |= 1;
2606 if (off >= (bfd_vma) -2)
2608 if (r_type == ELF32_R_TYPE (rel->r_info))
2610 relocation = htab->sgot->output_offset + off;
2611 unresolved_reloc = false;
2615 unsigned int val, type;
2618 /* GD->IE transition. */
2619 BFD_ASSERT (rel->r_offset >= 2);
2620 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2621 BFD_ASSERT (type == 0x8d || type == 0x04);
2622 BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2623 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2625 BFD_ASSERT (rel + 1 < relend);
2626 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2627 roff = rel->r_offset - 3;
2628 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2631 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2633 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
2634 BFD_ASSERT (rel->r_offset >= 3);
2635 BFD_ASSERT (bfd_get_8 (input_bfd,
2636 contents + rel->r_offset - 3)
2638 BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2643 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2645 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
2646 BFD_ASSERT (rel->r_offset + 10 <= input_section->_raw_size);
2647 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2648 BFD_ASSERT (bfd_get_8 (input_bfd,
2649 contents + rel->r_offset + 9)
2651 roff = rel->r_offset - 2;
2653 memcpy (contents + roff,
2654 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
2655 contents[roff + 7] = 0x80 | (val & 7);
2656 bfd_put_32 (output_bfd, htab->sgot->output_offset + off,
2657 contents + roff + 8);
2658 /* Skip R_386_PLT32. */
2669 /* LD->LE transition:
2671 leal foo(%reg), %eax; call ___tls_get_addr.
2673 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
2674 BFD_ASSERT (rel->r_offset >= 2);
2675 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 2)
2677 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2678 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2679 BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2680 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2682 BFD_ASSERT (rel + 1 < relend);
2683 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2684 memcpy (contents + rel->r_offset - 2,
2685 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
2686 /* Skip R_386_PLT32. */
2691 if (htab->sgot == NULL)
2694 off = htab->tls_ldm_got.offset;
2699 Elf_Internal_Rel outrel;
2700 Elf32_External_Rel *loc;
2702 if (htab->srelgot == NULL)
2705 outrel.r_offset = (htab->sgot->output_section->vma
2706 + htab->sgot->output_offset + off);
2708 bfd_put_32 (output_bfd, 0,
2709 htab->sgot->contents + off);
2710 bfd_put_32 (output_bfd, 0,
2711 htab->sgot->contents + off + 4);
2712 outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
2713 loc = (Elf32_External_Rel *) htab->srelgot->contents;
2714 loc += htab->srelgot->reloc_count++;
2715 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2716 htab->tls_ldm_got.offset |= 1;
2718 relocation = htab->sgot->output_offset + off;
2719 unresolved_reloc = false;
2722 case R_386_TLS_LDO_32:
2724 relocation -= dtpoff_base (info);
2726 /* When converting LDO to LE, we must negate. */
2727 relocation = -tpoff (info, relocation);
2730 case R_386_TLS_LE_32:
2731 relocation = tpoff (info, relocation);
2735 relocation = -tpoff (info, relocation);
2742 /* FIXME: Why do we allow debugging sections to escape this error?
2743 More importantly, why do we not emit dynamic relocs for
2744 R_386_32 above in debugging sections (which are ! SEC_ALLOC)?
2745 If we had emitted the dynamic reloc, we could remove the
2747 if (unresolved_reloc
2749 && (input_section->flags & SEC_DEBUGGING) != 0
2750 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
2751 (*_bfd_error_handler)
2752 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2753 bfd_archive_filename (input_bfd),
2754 bfd_get_section_name (input_bfd, input_section),
2755 (long) rel->r_offset,
2756 h->root.root.string);
2758 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2759 contents, rel->r_offset,
2760 relocation, (bfd_vma) 0);
2762 if (r != bfd_reloc_ok)
2767 name = h->root.root.string;
2770 name = bfd_elf_string_from_elf_section (input_bfd,
2771 symtab_hdr->sh_link,
2776 name = bfd_section_name (input_bfd, sec);
2779 if (r == bfd_reloc_overflow)
2781 if (! ((*info->callbacks->reloc_overflow)
2782 (info, name, howto->name, (bfd_vma) 0,
2783 input_bfd, input_section, rel->r_offset)))
2788 (*_bfd_error_handler)
2789 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
2790 bfd_archive_filename (input_bfd),
2791 bfd_get_section_name (input_bfd, input_section),
2792 (long) rel->r_offset, name, (int) r);
2801 /* Finish up dynamic symbol handling. We set the contents of various
2802 dynamic sections here. */
2805 elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
2807 struct bfd_link_info *info;
2808 struct elf_link_hash_entry *h;
2809 Elf_Internal_Sym *sym;
2811 struct elf_i386_link_hash_table *htab;
2813 htab = elf_i386_hash_table (info);
2815 if (h->plt.offset != (bfd_vma) -1)
2819 Elf_Internal_Rel rel;
2820 Elf32_External_Rel *loc;
2822 /* This symbol has an entry in the procedure linkage table. Set
2825 if (h->dynindx == -1
2826 || htab->splt == NULL
2827 || htab->sgotplt == NULL
2828 || htab->srelplt == NULL)
2831 /* Get the index in the procedure linkage table which
2832 corresponds to this symbol. This is the index of this symbol
2833 in all the symbols for which we are making plt entries. The
2834 first entry in the procedure linkage table is reserved. */
2835 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2837 /* Get the offset into the .got table of the entry that
2838 corresponds to this function. Each .got entry is 4 bytes.
2839 The first three are reserved. */
2840 got_offset = (plt_index + 3) * 4;
2842 /* Fill in the entry in the procedure linkage table. */
2845 memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
2847 bfd_put_32 (output_bfd,
2848 (htab->sgotplt->output_section->vma
2849 + htab->sgotplt->output_offset
2851 htab->splt->contents + h->plt.offset + 2);
2855 memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
2857 bfd_put_32 (output_bfd, got_offset,
2858 htab->splt->contents + h->plt.offset + 2);
2861 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
2862 htab->splt->contents + h->plt.offset + 7);
2863 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
2864 htab->splt->contents + h->plt.offset + 12);
2866 /* Fill in the entry in the global offset table. */
2867 bfd_put_32 (output_bfd,
2868 (htab->splt->output_section->vma
2869 + htab->splt->output_offset
2872 htab->sgotplt->contents + got_offset);
2874 /* Fill in the entry in the .rel.plt section. */
2875 rel.r_offset = (htab->sgotplt->output_section->vma
2876 + htab->sgotplt->output_offset
2878 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
2879 loc = (Elf32_External_Rel *) htab->srelplt->contents + plt_index;
2880 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
2882 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2884 /* Mark the symbol as undefined, rather than as defined in
2885 the .plt section. Leave the value alone. This is a clue
2886 for the dynamic linker, to make function pointer
2887 comparisons work between an application and shared
2889 sym->st_shndx = SHN_UNDEF;
2893 if (h->got.offset != (bfd_vma) -1
2894 && elf_i386_hash_entry(h)->tls_type != GOT_TLS_GD
2895 && elf_i386_hash_entry(h)->tls_type != GOT_TLS_IE)
2897 Elf_Internal_Rel rel;
2898 Elf32_External_Rel *loc;
2900 /* This symbol has an entry in the global offset table. Set it
2903 if (htab->sgot == NULL || htab->srelgot == NULL)
2906 rel.r_offset = (htab->sgot->output_section->vma
2907 + htab->sgot->output_offset
2908 + (h->got.offset & ~(bfd_vma) 1));
2910 /* If this is a static link, or it is a -Bsymbolic link and the
2911 symbol is defined locally or was forced to be local because
2912 of a version file, we just want to emit a RELATIVE reloc.
2913 The entry in the global offset table will already have been
2914 initialized in the relocate_section function. */
2918 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2919 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
2921 BFD_ASSERT((h->got.offset & 1) != 0);
2922 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2926 BFD_ASSERT((h->got.offset & 1) == 0);
2927 bfd_put_32 (output_bfd, (bfd_vma) 0,
2928 htab->sgot->contents + h->got.offset);
2929 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
2932 loc = (Elf32_External_Rel *) htab->srelgot->contents;
2933 loc += htab->srelgot->reloc_count++;
2934 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
2937 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2939 Elf_Internal_Rel rel;
2940 Elf32_External_Rel *loc;
2942 /* This symbol needs a copy reloc. Set it up. */
2944 if (h->dynindx == -1
2945 || (h->root.type != bfd_link_hash_defined
2946 && h->root.type != bfd_link_hash_defweak)
2947 || htab->srelbss == NULL)
2950 rel.r_offset = (h->root.u.def.value
2951 + h->root.u.def.section->output_section->vma
2952 + h->root.u.def.section->output_offset);
2953 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
2954 loc = (Elf32_External_Rel *) htab->srelbss->contents;
2955 loc += htab->srelbss->reloc_count++;
2956 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
2959 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2960 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2961 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2962 sym->st_shndx = SHN_ABS;
2967 /* Used to decide how to sort relocs in an optimal manner for the
2968 dynamic linker, before writing them out. */
2970 static enum elf_reloc_type_class
2971 elf_i386_reloc_type_class (rela)
2972 const Elf_Internal_Rela *rela;
2974 switch ((int) ELF32_R_TYPE (rela->r_info))
2976 case R_386_RELATIVE:
2977 return reloc_class_relative;
2978 case R_386_JUMP_SLOT:
2979 return reloc_class_plt;
2981 return reloc_class_copy;
2983 return reloc_class_normal;
2987 /* Finish up the dynamic sections. */
2990 elf_i386_finish_dynamic_sections (output_bfd, info)
2992 struct bfd_link_info *info;
2994 struct elf_i386_link_hash_table *htab;
2998 htab = elf_i386_hash_table (info);
2999 dynobj = htab->elf.dynobj;
3000 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3002 if (htab->elf.dynamic_sections_created)
3004 Elf32_External_Dyn *dyncon, *dynconend;
3006 if (sdyn == NULL || htab->sgot == NULL)
3009 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3010 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3011 for (; dyncon < dynconend; dyncon++)
3013 Elf_Internal_Dyn dyn;
3016 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3024 dyn.d_un.d_ptr = htab->sgot->output_section->vma;
3028 dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
3032 s = htab->srelplt->output_section;
3033 if (s->_cooked_size != 0)
3034 dyn.d_un.d_val = s->_cooked_size;
3036 dyn.d_un.d_val = s->_raw_size;
3040 /* My reading of the SVR4 ABI indicates that the
3041 procedure linkage table relocs (DT_JMPREL) should be
3042 included in the overall relocs (DT_REL). This is
3043 what Solaris does. However, UnixWare can not handle
3044 that case. Therefore, we override the DT_RELSZ entry
3045 here to make it not include the JMPREL relocs. Since
3046 the linker script arranges for .rel.plt to follow all
3047 other relocation sections, we don't have to worry
3048 about changing the DT_REL entry. */
3049 if (htab->srelplt != NULL)
3051 s = htab->srelplt->output_section;
3052 if (s->_cooked_size != 0)
3053 dyn.d_un.d_val -= s->_cooked_size;
3055 dyn.d_un.d_val -= s->_raw_size;
3060 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3063 /* Fill in the first entry in the procedure linkage table. */
3064 if (htab->splt && htab->splt->_raw_size > 0)
3067 memcpy (htab->splt->contents,
3068 elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
3071 memcpy (htab->splt->contents,
3072 elf_i386_plt0_entry, PLT_ENTRY_SIZE);
3073 bfd_put_32 (output_bfd,
3074 (htab->sgotplt->output_section->vma
3075 + htab->sgotplt->output_offset
3077 htab->splt->contents + 2);
3078 bfd_put_32 (output_bfd,
3079 (htab->sgotplt->output_section->vma
3080 + htab->sgotplt->output_offset
3082 htab->splt->contents + 8);
3085 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3086 really seem like the right value. */
3087 elf_section_data (htab->splt->output_section)
3088 ->this_hdr.sh_entsize = 4;
3094 /* Fill in the first three entries in the global offset table. */
3095 if (htab->sgotplt->_raw_size > 0)
3097 bfd_put_32 (output_bfd,
3098 (sdyn == NULL ? (bfd_vma) 0
3099 : sdyn->output_section->vma + sdyn->output_offset),
3100 htab->sgotplt->contents);
3101 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 4);
3102 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8);
3105 elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
3110 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
3111 #define TARGET_LITTLE_NAME "elf32-i386"
3112 #define ELF_ARCH bfd_arch_i386
3113 #define ELF_MACHINE_CODE EM_386
3114 #define ELF_MAXPAGESIZE 0x1000
3116 #define elf_backend_can_gc_sections 1
3117 #define elf_backend_can_refcount 1
3118 #define elf_backend_want_got_plt 1
3119 #define elf_backend_plt_readonly 1
3120 #define elf_backend_want_plt_sym 0
3121 #define elf_backend_got_header_size 12
3122 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
3124 #define elf_info_to_howto elf_i386_info_to_howto
3125 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
3127 #define bfd_elf32_mkobject elf_i386_mkobject
3128 #define elf_backend_object_p elf_i386_object_p
3130 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
3131 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
3132 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
3134 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
3135 #define elf_backend_check_relocs elf_i386_check_relocs
3136 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
3137 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
3138 #define elf_backend_fake_sections elf_i386_fake_sections
3139 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
3140 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
3141 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
3142 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
3143 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
3144 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
3145 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
3146 #define elf_backend_relocate_section elf_i386_relocate_section
3147 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
3149 #ifndef ELF32_I386_C_INCLUDED
3150 #include "elf32-target.h"