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_backend_data *, struct elf_link_hash_entry *,
49 struct elf_link_hash_entry *));
50 static int elf_i386_tls_transition
51 PARAMS ((struct bfd_link_info *, int, int));
53 static boolean elf_i386_mkobject
55 static boolean elf_i386_object_p
57 static boolean elf_i386_check_relocs
58 PARAMS ((bfd *, struct bfd_link_info *, asection *,
59 const Elf_Internal_Rela *));
60 static asection *elf_i386_gc_mark_hook
61 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
62 struct elf_link_hash_entry *, Elf_Internal_Sym *));
63 static boolean elf_i386_gc_sweep_hook
64 PARAMS ((bfd *, struct bfd_link_info *, asection *,
65 const Elf_Internal_Rela *));
66 static boolean elf_i386_adjust_dynamic_symbol
67 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
68 static boolean allocate_dynrelocs
69 PARAMS ((struct elf_link_hash_entry *, PTR));
70 static boolean readonly_dynrelocs
71 PARAMS ((struct elf_link_hash_entry *, PTR));
72 static boolean elf_i386_fake_sections
73 PARAMS ((bfd *, Elf32_Internal_Shdr *, asection *));
74 static boolean elf_i386_size_dynamic_sections
75 PARAMS ((bfd *, struct bfd_link_info *));
76 static bfd_vma dtpoff_base
77 PARAMS ((struct bfd_link_info *));
79 PARAMS ((struct bfd_link_info *, bfd_vma));
80 static boolean elf_i386_relocate_section
81 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
82 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
83 static boolean elf_i386_finish_dynamic_symbol
84 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
86 static enum elf_reloc_type_class elf_i386_reloc_type_class
87 PARAMS ((const Elf_Internal_Rela *));
88 static boolean elf_i386_finish_dynamic_sections
89 PARAMS ((bfd *, struct bfd_link_info *));
91 #define USE_REL 1 /* 386 uses REL relocations instead of RELA */
95 static reloc_howto_type elf_howto_table[]=
97 HOWTO(R_386_NONE, 0, 0, 0, false, 0, complain_overflow_bitfield,
98 bfd_elf_generic_reloc, "R_386_NONE",
99 true, 0x00000000, 0x00000000, false),
100 HOWTO(R_386_32, 0, 2, 32, false, 0, complain_overflow_bitfield,
101 bfd_elf_generic_reloc, "R_386_32",
102 true, 0xffffffff, 0xffffffff, false),
103 HOWTO(R_386_PC32, 0, 2, 32, true, 0, complain_overflow_bitfield,
104 bfd_elf_generic_reloc, "R_386_PC32",
105 true, 0xffffffff, 0xffffffff, true),
106 HOWTO(R_386_GOT32, 0, 2, 32, false, 0, complain_overflow_bitfield,
107 bfd_elf_generic_reloc, "R_386_GOT32",
108 true, 0xffffffff, 0xffffffff, false),
109 HOWTO(R_386_PLT32, 0, 2, 32, true, 0, complain_overflow_bitfield,
110 bfd_elf_generic_reloc, "R_386_PLT32",
111 true, 0xffffffff, 0xffffffff, true),
112 HOWTO(R_386_COPY, 0, 2, 32, false, 0, complain_overflow_bitfield,
113 bfd_elf_generic_reloc, "R_386_COPY",
114 true, 0xffffffff, 0xffffffff, false),
115 HOWTO(R_386_GLOB_DAT, 0, 2, 32, false, 0, complain_overflow_bitfield,
116 bfd_elf_generic_reloc, "R_386_GLOB_DAT",
117 true, 0xffffffff, 0xffffffff, false),
118 HOWTO(R_386_JUMP_SLOT, 0, 2, 32, false, 0, complain_overflow_bitfield,
119 bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
120 true, 0xffffffff, 0xffffffff, false),
121 HOWTO(R_386_RELATIVE, 0, 2, 32, false, 0, complain_overflow_bitfield,
122 bfd_elf_generic_reloc, "R_386_RELATIVE",
123 true, 0xffffffff, 0xffffffff, false),
124 HOWTO(R_386_GOTOFF, 0, 2, 32, false, 0, complain_overflow_bitfield,
125 bfd_elf_generic_reloc, "R_386_GOTOFF",
126 true, 0xffffffff, 0xffffffff, false),
127 HOWTO(R_386_GOTPC, 0, 2, 32, true, 0, complain_overflow_bitfield,
128 bfd_elf_generic_reloc, "R_386_GOTPC",
129 true, 0xffffffff, 0xffffffff, true),
131 /* We have a gap in the reloc numbers here.
132 R_386_standard counts the number up to this point, and
133 R_386_ext_offset is the value to subtract from a reloc type of
134 R_386_16 thru R_386_PC8 to form an index into this table. */
135 #define R_386_standard ((unsigned int) R_386_GOTPC + 1)
136 #define R_386_ext_offset ((unsigned int) R_386_TLS_LE - R_386_standard)
138 /* The remaining relocs are a GNU extension. */
139 HOWTO(R_386_TLS_LE, 0, 2, 32, false, 0, complain_overflow_bitfield,
140 bfd_elf_generic_reloc, "R_386_TLS_LE",
141 true, 0xffffffff, 0xffffffff, false),
142 HOWTO(R_386_TLS_GD, 0, 2, 32, false, 0, complain_overflow_bitfield,
143 bfd_elf_generic_reloc, "R_386_TLS_GD",
144 true, 0xffffffff, 0xffffffff, false),
145 HOWTO(R_386_TLS_LDM, 0, 2, 32, false, 0, complain_overflow_bitfield,
146 bfd_elf_generic_reloc, "R_386_TLS_LDM",
147 true, 0xffffffff, 0xffffffff, false),
148 HOWTO(R_386_16, 0, 1, 16, false, 0, complain_overflow_bitfield,
149 bfd_elf_generic_reloc, "R_386_16",
150 true, 0xffff, 0xffff, false),
151 HOWTO(R_386_PC16, 0, 1, 16, true, 0, complain_overflow_bitfield,
152 bfd_elf_generic_reloc, "R_386_PC16",
153 true, 0xffff, 0xffff, true),
154 HOWTO(R_386_8, 0, 0, 8, false, 0, complain_overflow_bitfield,
155 bfd_elf_generic_reloc, "R_386_8",
156 true, 0xff, 0xff, false),
157 HOWTO(R_386_PC8, 0, 0, 8, true, 0, complain_overflow_signed,
158 bfd_elf_generic_reloc, "R_386_PC8",
159 true, 0xff, 0xff, true),
161 #define R_386_ext ((unsigned int) R_386_PC8 + 1 - R_386_ext_offset)
162 #define R_386_tls_offset ((unsigned int) R_386_TLS_LDO_32 - R_386_ext)
163 /* These are common with Solaris TLS implementation. */
164 HOWTO(R_386_TLS_LDO_32, 0, 2, 32, false, 0, complain_overflow_bitfield,
165 bfd_elf_generic_reloc, "R_386_TLS_LDO_32",
166 true, 0xffffffff, 0xffffffff, false),
167 HOWTO(R_386_TLS_IE_32, 0, 2, 32, false, 0, complain_overflow_bitfield,
168 bfd_elf_generic_reloc, "R_386_TLS_IE_32",
169 true, 0xffffffff, 0xffffffff, false),
170 HOWTO(R_386_TLS_LE_32, 0, 2, 32, false, 0, complain_overflow_bitfield,
171 bfd_elf_generic_reloc, "R_386_TLS_LE_32",
172 true, 0xffffffff, 0xffffffff, false),
173 HOWTO(R_386_TLS_DTPMOD32, 0, 2, 32, false, 0, complain_overflow_bitfield,
174 bfd_elf_generic_reloc, "R_386_TLS_DTPMOD32",
175 true, 0xffffffff, 0xffffffff, false),
176 HOWTO(R_386_TLS_DTPOFF32, 0, 2, 32, false, 0, complain_overflow_bitfield,
177 bfd_elf_generic_reloc, "R_386_TLS_DTPOFF32",
178 true, 0xffffffff, 0xffffffff, false),
179 HOWTO(R_386_TLS_TPOFF32, 0, 2, 32, false, 0, complain_overflow_bitfield,
180 bfd_elf_generic_reloc, "R_386_TLS_TPOFF32",
181 true, 0xffffffff, 0xffffffff, false),
184 #define R_386_tls ((unsigned int) R_386_TLS_TPOFF32 + 1 - R_386_tls_offset)
185 #define R_386_vt_offset ((unsigned int) R_386_GNU_VTINHERIT - R_386_tls)
187 /* GNU extension to record C++ vtable hierarchy. */
188 HOWTO (R_386_GNU_VTINHERIT, /* type */
190 2, /* size (0 = byte, 1 = short, 2 = long) */
192 false, /* pc_relative */
194 complain_overflow_dont, /* complain_on_overflow */
195 NULL, /* special_function */
196 "R_386_GNU_VTINHERIT", /* name */
197 false, /* partial_inplace */
200 false), /* pcrel_offset */
202 /* GNU extension to record C++ vtable member usage. */
203 HOWTO (R_386_GNU_VTENTRY, /* type */
205 2, /* size (0 = byte, 1 = short, 2 = long) */
207 false, /* pc_relative */
209 complain_overflow_dont, /* complain_on_overflow */
210 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
211 "R_386_GNU_VTENTRY", /* name */
212 false, /* partial_inplace */
215 false) /* pcrel_offset */
217 #define R_386_vt ((unsigned int) R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
221 #ifdef DEBUG_GEN_RELOC
222 #define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
227 static reloc_howto_type *
228 elf_i386_reloc_type_lookup (abfd, code)
229 bfd *abfd ATTRIBUTE_UNUSED;
230 bfd_reloc_code_real_type code;
235 TRACE ("BFD_RELOC_NONE");
236 return &elf_howto_table[(unsigned int) R_386_NONE ];
239 TRACE ("BFD_RELOC_32");
240 return &elf_howto_table[(unsigned int) R_386_32 ];
243 TRACE ("BFD_RELOC_CTOR");
244 return &elf_howto_table[(unsigned int) R_386_32 ];
246 case BFD_RELOC_32_PCREL:
247 TRACE ("BFD_RELOC_PC32");
248 return &elf_howto_table[(unsigned int) R_386_PC32 ];
250 case BFD_RELOC_386_GOT32:
251 TRACE ("BFD_RELOC_386_GOT32");
252 return &elf_howto_table[(unsigned int) R_386_GOT32 ];
254 case BFD_RELOC_386_PLT32:
255 TRACE ("BFD_RELOC_386_PLT32");
256 return &elf_howto_table[(unsigned int) R_386_PLT32 ];
258 case BFD_RELOC_386_COPY:
259 TRACE ("BFD_RELOC_386_COPY");
260 return &elf_howto_table[(unsigned int) R_386_COPY ];
262 case BFD_RELOC_386_GLOB_DAT:
263 TRACE ("BFD_RELOC_386_GLOB_DAT");
264 return &elf_howto_table[(unsigned int) R_386_GLOB_DAT ];
266 case BFD_RELOC_386_JUMP_SLOT:
267 TRACE ("BFD_RELOC_386_JUMP_SLOT");
268 return &elf_howto_table[(unsigned int) R_386_JUMP_SLOT ];
270 case BFD_RELOC_386_RELATIVE:
271 TRACE ("BFD_RELOC_386_RELATIVE");
272 return &elf_howto_table[(unsigned int) R_386_RELATIVE ];
274 case BFD_RELOC_386_GOTOFF:
275 TRACE ("BFD_RELOC_386_GOTOFF");
276 return &elf_howto_table[(unsigned int) R_386_GOTOFF ];
278 case BFD_RELOC_386_GOTPC:
279 TRACE ("BFD_RELOC_386_GOTPC");
280 return &elf_howto_table[(unsigned int) R_386_GOTPC ];
282 /* The remaining relocs are a GNU extension. */
283 case BFD_RELOC_386_TLS_LE:
284 TRACE ("BFD_RELOC_386_TLS_LE");
285 return &elf_howto_table[(unsigned int) R_386_TLS_LE - R_386_ext_offset];
287 case BFD_RELOC_386_TLS_GD:
288 TRACE ("BFD_RELOC_386_TLS_GD");
289 return &elf_howto_table[(unsigned int) R_386_TLS_GD - R_386_ext_offset];
291 case BFD_RELOC_386_TLS_LDM:
292 TRACE ("BFD_RELOC_386_TLS_LDM");
293 return &elf_howto_table[(unsigned int) R_386_TLS_LDM - R_386_ext_offset];
296 TRACE ("BFD_RELOC_16");
297 return &elf_howto_table[(unsigned int) R_386_16 - R_386_ext_offset];
299 case BFD_RELOC_16_PCREL:
300 TRACE ("BFD_RELOC_16_PCREL");
301 return &elf_howto_table[(unsigned int) R_386_PC16 - R_386_ext_offset];
304 TRACE ("BFD_RELOC_8");
305 return &elf_howto_table[(unsigned int) R_386_8 - R_386_ext_offset];
307 case BFD_RELOC_8_PCREL:
308 TRACE ("BFD_RELOC_8_PCREL");
309 return &elf_howto_table[(unsigned int) R_386_PC8 - R_386_ext_offset];
311 /* Common with Sun TLS implementation. */
312 case BFD_RELOC_386_TLS_LDO_32:
313 TRACE ("BFD_RELOC_386_TLS_LDO_32");
314 return &elf_howto_table[(unsigned int) R_386_TLS_LDO_32 - R_386_tls_offset];
316 case BFD_RELOC_386_TLS_IE_32:
317 TRACE ("BFD_RELOC_386_TLS_IE_32");
318 return &elf_howto_table[(unsigned int) R_386_TLS_IE_32 - R_386_tls_offset];
320 case BFD_RELOC_386_TLS_LE_32:
321 TRACE ("BFD_RELOC_386_TLS_LE_32");
322 return &elf_howto_table[(unsigned int) R_386_TLS_LE_32 - R_386_tls_offset];
324 case BFD_RELOC_386_TLS_DTPMOD32:
325 TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
326 return &elf_howto_table[(unsigned int) R_386_TLS_DTPMOD32 - R_386_tls_offset];
328 case BFD_RELOC_386_TLS_DTPOFF32:
329 TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
330 return &elf_howto_table[(unsigned int) R_386_TLS_DTPOFF32 - R_386_tls_offset];
332 case BFD_RELOC_386_TLS_TPOFF32:
333 TRACE ("BFD_RELOC_386_TLS_TPOFF32");
334 return &elf_howto_table[(unsigned int) R_386_TLS_TPOFF32 - R_386_tls_offset];
336 case BFD_RELOC_VTABLE_INHERIT:
337 TRACE ("BFD_RELOC_VTABLE_INHERIT");
338 return &elf_howto_table[(unsigned int) R_386_GNU_VTINHERIT
341 case BFD_RELOC_VTABLE_ENTRY:
342 TRACE ("BFD_RELOC_VTABLE_ENTRY");
343 return &elf_howto_table[(unsigned int) R_386_GNU_VTENTRY
355 elf_i386_info_to_howto (abfd, cache_ptr, dst)
356 bfd *abfd ATTRIBUTE_UNUSED;
357 arelent *cache_ptr ATTRIBUTE_UNUSED;
358 Elf32_Internal_Rela *dst ATTRIBUTE_UNUSED;
364 elf_i386_info_to_howto_rel (abfd, cache_ptr, dst)
365 bfd *abfd ATTRIBUTE_UNUSED;
367 Elf32_Internal_Rel *dst;
369 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
372 if ((indx = r_type) >= R_386_standard
373 && ((indx = r_type - R_386_ext_offset) - R_386_standard
374 >= R_386_ext - R_386_standard)
375 && ((indx = r_type - R_386_tls_offset) - R_386_ext
376 >= R_386_tls - R_386_ext)
377 && ((indx = r_type - R_386_vt_offset) - R_386_tls
378 >= R_386_vt - R_386_tls))
380 (*_bfd_error_handler) (_("%s: invalid relocation type %d"),
381 bfd_archive_filename (abfd), (int) r_type);
382 indx = (unsigned int) R_386_NONE;
384 cache_ptr->howto = &elf_howto_table[indx];
387 /* Return whether a symbol name implies a local label. The UnixWare
388 2.1 cc generates temporary symbols that start with .X, so we
389 recognize them here. FIXME: do other SVR4 compilers also use .X?.
390 If so, we should move the .X recognition into
391 _bfd_elf_is_local_label_name. */
394 elf_i386_is_local_label_name (abfd, name)
398 if (name[0] == '.' && name[1] == 'X')
401 return _bfd_elf_is_local_label_name (abfd, name);
404 /* Support for core dump NOTE sections. */
406 elf_i386_grok_prstatus (abfd, note)
408 Elf_Internal_Note *note;
413 switch (note->descsz)
418 case 144: /* Linux/i386 */
420 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
423 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
432 /* Make a ".reg/999" section. */
433 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
434 raw_size, note->descpos + offset);
438 elf_i386_grok_psinfo (abfd, note)
440 Elf_Internal_Note *note;
442 switch (note->descsz)
447 case 124: /* Linux/i386 elf_prpsinfo */
448 elf_tdata (abfd)->core_program
449 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
450 elf_tdata (abfd)->core_command
451 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
454 /* Note that for some reason, a spurious space is tacked
455 onto the end of the args in some (at least one anyway)
456 implementations, so strip it off if it exists. */
459 char *command = elf_tdata (abfd)->core_command;
460 int n = strlen (command);
462 if (0 < n && command[n - 1] == ' ')
463 command[n - 1] = '\0';
469 /* Functions for the i386 ELF linker.
471 In order to gain some understanding of code in this file without
472 knowing all the intricate details of the linker, note the
475 Functions named elf_i386_* are called by external routines, other
476 functions are only called locally. elf_i386_* functions appear
477 in this file more or less in the order in which they are called
478 from external routines. eg. elf_i386_check_relocs is called
479 early in the link process, elf_i386_finish_dynamic_sections is
480 one of the last functions. */
483 /* The name of the dynamic interpreter. This is put in the .interp
486 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
488 /* The size in bytes of an entry in the procedure linkage table. */
490 #define PLT_ENTRY_SIZE 16
492 /* The first entry in an absolute procedure linkage table looks like
493 this. See the SVR4 ABI i386 supplement to see how this works. */
495 static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] =
497 0xff, 0x35, /* pushl contents of address */
498 0, 0, 0, 0, /* replaced with address of .got + 4. */
499 0xff, 0x25, /* jmp indirect */
500 0, 0, 0, 0, /* replaced with address of .got + 8. */
501 0, 0, 0, 0 /* pad out to 16 bytes. */
504 /* Subsequent entries in an absolute procedure linkage table look like
507 static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
509 0xff, 0x25, /* jmp indirect */
510 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
511 0x68, /* pushl immediate */
512 0, 0, 0, 0, /* replaced with offset into relocation table. */
513 0xe9, /* jmp relative */
514 0, 0, 0, 0 /* replaced with offset to start of .plt. */
517 /* The first entry in a PIC procedure linkage table look like this. */
519 static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] =
521 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
522 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
523 0, 0, 0, 0 /* pad out to 16 bytes. */
526 /* Subsequent entries in a PIC procedure linkage table look like this. */
528 static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
530 0xff, 0xa3, /* jmp *offset(%ebx) */
531 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
532 0x68, /* pushl immediate */
533 0, 0, 0, 0, /* replaced with offset into relocation table. */
534 0xe9, /* jmp relative */
535 0, 0, 0, 0 /* replaced with offset to start of .plt. */
538 /* The i386 linker needs to keep track of the number of relocs that it
539 decides to copy as dynamic relocs in check_relocs for each symbol.
540 This is so that it can later discard them if they are found to be
541 unnecessary. We store the information in a field extending the
542 regular ELF linker hash table. */
544 struct elf_i386_dyn_relocs
546 struct elf_i386_dyn_relocs *next;
548 /* The input section of the reloc. */
551 /* Total number of relocs copied for the input section. */
554 /* Number of pc-relative relocs copied for the input section. */
555 bfd_size_type pc_count;
558 /* i386 ELF linker hash entry. */
560 struct elf_i386_link_hash_entry
562 struct elf_link_hash_entry elf;
564 /* Track dynamic relocs copied for this symbol. */
565 struct elf_i386_dyn_relocs *dyn_relocs;
568 GOT_UNKNOWN = 0, GOT_NORMAL, GOT_TLS_GD, GOT_TLS_IE
572 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
574 struct elf_i386_obj_tdata
576 struct elf_obj_tdata root;
578 /* tls_type for each local got entry. */
579 char *local_got_tls_type;
582 #define elf_i386_tdata(abfd) \
583 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
585 #define elf_i386_local_got_tls_type(abfd) \
586 (elf_i386_tdata (abfd)->local_got_tls_type)
589 elf_i386_mkobject (abfd)
592 bfd_size_type amt = sizeof (struct elf_i386_obj_tdata);
593 abfd->tdata.any = bfd_zalloc (abfd, amt);
594 if (abfd->tdata.any == NULL)
600 elf_i386_object_p (abfd)
603 /* Allocate our special target data. */
604 struct elf_i386_obj_tdata *new_tdata;
605 bfd_size_type amt = sizeof (struct elf_i386_obj_tdata);
606 new_tdata = bfd_zalloc (abfd, amt);
607 if (new_tdata == NULL)
609 new_tdata->root = *abfd->tdata.elf_obj_data;
610 abfd->tdata.any = new_tdata;
614 /* i386 ELF linker hash table. */
616 struct elf_i386_link_hash_table
618 struct elf_link_hash_table elf;
620 /* Short-cuts to get to dynamic linker sections. */
630 bfd_signed_vma refcount;
634 /* Small local sym to section mapping cache. */
635 struct sym_sec_cache sym_sec;
638 /* Get the i386 ELF linker hash table from a link_info structure. */
640 #define elf_i386_hash_table(p) \
641 ((struct elf_i386_link_hash_table *) ((p)->hash))
643 /* Create an entry in an i386 ELF linker hash table. */
645 static struct bfd_hash_entry *
646 link_hash_newfunc (entry, table, string)
647 struct bfd_hash_entry *entry;
648 struct bfd_hash_table *table;
651 /* Allocate the structure if it has not already been allocated by a
655 entry = bfd_hash_allocate (table,
656 sizeof (struct elf_i386_link_hash_entry));
661 /* Call the allocation method of the superclass. */
662 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
665 struct elf_i386_link_hash_entry *eh;
667 eh = (struct elf_i386_link_hash_entry *) entry;
668 eh->dyn_relocs = NULL;
669 eh->tls_type = GOT_UNKNOWN;
675 /* Create an i386 ELF linker hash table. */
677 static struct bfd_link_hash_table *
678 elf_i386_link_hash_table_create (abfd)
681 struct elf_i386_link_hash_table *ret;
682 bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
684 ret = (struct elf_i386_link_hash_table *) bfd_malloc (amt);
688 if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc))
701 ret->tls_ldm_got.refcount = 0;
702 ret->sym_sec.abfd = NULL;
704 return &ret->elf.root;
707 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
708 shortcuts to them in our hash table. */
711 create_got_section (dynobj, info)
713 struct bfd_link_info *info;
715 struct elf_i386_link_hash_table *htab;
717 if (! _bfd_elf_create_got_section (dynobj, info))
720 htab = elf_i386_hash_table (info);
721 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
722 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
723 if (!htab->sgot || !htab->sgotplt)
726 htab->srelgot = bfd_make_section (dynobj, ".rel.got");
727 if (htab->srelgot == NULL
728 || ! bfd_set_section_flags (dynobj, htab->srelgot,
729 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
730 | SEC_IN_MEMORY | SEC_LINKER_CREATED
732 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
737 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
738 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
742 elf_i386_create_dynamic_sections (dynobj, info)
744 struct bfd_link_info *info;
746 struct elf_i386_link_hash_table *htab;
748 htab = elf_i386_hash_table (info);
749 if (!htab->sgot && !create_got_section (dynobj, info))
752 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
755 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
756 htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
757 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
759 htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
761 if (!htab->splt || !htab->srelplt || !htab->sdynbss
762 || (!info->shared && !htab->srelbss))
768 /* Copy the extra info we tack onto an elf_link_hash_entry. */
771 elf_i386_copy_indirect_symbol (bed, dir, ind)
772 struct elf_backend_data *bed;
773 struct elf_link_hash_entry *dir, *ind;
775 struct elf_i386_link_hash_entry *edir, *eind;
777 edir = (struct elf_i386_link_hash_entry *) dir;
778 eind = (struct elf_i386_link_hash_entry *) ind;
780 if (eind->dyn_relocs != NULL)
782 if (edir->dyn_relocs != NULL)
784 struct elf_i386_dyn_relocs **pp;
785 struct elf_i386_dyn_relocs *p;
787 if (ind->root.type == bfd_link_hash_indirect)
790 /* Add reloc counts against the weak sym to the strong sym
791 list. Merge any entries against the same section. */
792 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
794 struct elf_i386_dyn_relocs *q;
796 for (q = edir->dyn_relocs; q != NULL; q = q->next)
797 if (q->sec == p->sec)
799 q->pc_count += p->pc_count;
800 q->count += p->count;
807 *pp = edir->dyn_relocs;
810 edir->dyn_relocs = eind->dyn_relocs;
811 eind->dyn_relocs = NULL;
814 if (ind->root.type == bfd_link_hash_indirect
815 && dir->got.refcount <= 0)
817 edir->tls_type = eind->tls_type;
818 eind->tls_type = GOT_UNKNOWN;
820 _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
824 elf_i386_tls_transition (info, r_type, is_local)
825 struct bfd_link_info *info;
835 case R_386_TLS_IE_32:
837 return R_386_TLS_LE_32;
838 return R_386_TLS_IE_32;
840 return R_386_TLS_LE_32;
846 /* Look through the relocs for a section during the first phase, and
847 calculate needed space in the global offset table, procedure linkage
848 table, and dynamic reloc sections. */
851 elf_i386_check_relocs (abfd, info, sec, relocs)
853 struct bfd_link_info *info;
855 const Elf_Internal_Rela *relocs;
857 struct elf_i386_link_hash_table *htab;
858 Elf_Internal_Shdr *symtab_hdr;
859 struct elf_link_hash_entry **sym_hashes;
860 const Elf_Internal_Rela *rel;
861 const Elf_Internal_Rela *rel_end;
864 if (info->relocateable)
867 htab = elf_i386_hash_table (info);
868 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
869 sym_hashes = elf_sym_hashes (abfd);
873 rel_end = relocs + sec->reloc_count;
874 for (rel = relocs; rel < rel_end; rel++)
877 unsigned long r_symndx;
878 struct elf_link_hash_entry *h;
880 r_symndx = ELF32_R_SYM (rel->r_info);
881 r_type = ELF32_R_TYPE (rel->r_info);
883 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
885 (*_bfd_error_handler) (_("%s: bad symbol index: %d"),
886 bfd_archive_filename (abfd),
891 if (r_symndx < symtab_hdr->sh_info)
894 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
896 r_type = elf_i386_tls_transition (info, r_type, h == NULL);
900 case R_386_TLS_IE_32:
902 info->flags |= DF_STATIC_TLS;
906 /* This symbol requires a global offset table entry. */
908 int tls_type, old_tls_type;
913 case R_386_GOT32: tls_type = GOT_NORMAL; break;
914 case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
915 case R_386_TLS_IE_32: tls_type = GOT_TLS_IE; break;
920 h->got.refcount += 1;
921 old_tls_type = elf_i386_hash_entry(h)->tls_type;
925 bfd_signed_vma *local_got_refcounts;
927 /* This is a global offset table entry for a local symbol. */
928 local_got_refcounts = elf_local_got_refcounts (abfd);
929 if (local_got_refcounts == NULL)
933 size = symtab_hdr->sh_info;
934 size *= (sizeof (bfd_signed_vma) + sizeof(char));
935 local_got_refcounts = ((bfd_signed_vma *)
936 bfd_zalloc (abfd, size));
937 if (local_got_refcounts == NULL)
939 elf_local_got_refcounts (abfd) = local_got_refcounts;
940 elf_i386_local_got_tls_type (abfd)
941 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
943 local_got_refcounts[r_symndx] += 1;
944 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
947 /* If a TLS symbol is accessed using IE at least once,
948 there is no point to use dynamic model for it. */
949 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
950 && (old_tls_type != GOT_TLS_GD || tls_type != GOT_TLS_IE))
952 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
953 tls_type = GOT_TLS_IE;
956 (*_bfd_error_handler)
957 (_("%s: `%s' accessed both as normal and thread local symbol"),
958 bfd_archive_filename (abfd), h->root.root.string);
963 if (old_tls_type != tls_type)
966 elf_i386_hash_entry (h)->tls_type = tls_type;
968 elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
976 if (htab->sgot == NULL)
978 if (htab->elf.dynobj == NULL)
979 htab->elf.dynobj = abfd;
980 if (!create_got_section (htab->elf.dynobj, info))
986 htab->tls_ldm_got.refcount += 1;
990 /* This symbol requires a procedure linkage table entry. We
991 actually build the entry in adjust_dynamic_symbol,
992 because this might be a case of linking PIC code which is
993 never referenced by a dynamic object, in which case we
994 don't need to generate a procedure linkage table entry
997 /* If this is a local symbol, we resolve it directly without
998 creating a procedure linkage table entry. */
1002 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
1003 h->plt.refcount += 1;
1008 if (h != NULL && !info->shared)
1010 /* If this reloc is in a read-only section, we might
1011 need a copy reloc. We can't check reliably at this
1012 stage whether the section is read-only, as input
1013 sections have not yet been mapped to output sections.
1014 Tentatively set the flag for now, and correct in
1015 adjust_dynamic_symbol. */
1016 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
1018 /* We may need a .plt entry if the function this reloc
1019 refers to is in a shared lib. */
1020 h->plt.refcount += 1;
1023 /* If we are creating a shared library, and this is a reloc
1024 against a global symbol, or a non PC relative reloc
1025 against a local symbol, then we need to copy the reloc
1026 into the shared library. However, if we are linking with
1027 -Bsymbolic, we do not need to copy a reloc against a
1028 global symbol which is defined in an object we are
1029 including in the link (i.e., DEF_REGULAR is set). At
1030 this point we have not seen all the input files, so it is
1031 possible that DEF_REGULAR is not set now but will be set
1032 later (it is never cleared). In case of a weak definition,
1033 DEF_REGULAR may be cleared later by a strong definition in
1034 a shared library. We account for that possibility below by
1035 storing information in the relocs_copied field of the hash
1036 table entry. A similar situation occurs when creating
1037 shared libraries and symbol visibility changes render the
1040 If on the other hand, we are creating an executable, we
1041 may need to keep relocations for symbols satisfied by a
1042 dynamic library if we manage to avoid copy relocs for the
1045 && (sec->flags & SEC_ALLOC) != 0
1046 && (r_type != R_386_PC32
1048 && (! info->symbolic
1049 || h->root.type == bfd_link_hash_defweak
1050 || (h->elf_link_hash_flags
1051 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1053 && (sec->flags & SEC_ALLOC) != 0
1055 && (h->root.type == bfd_link_hash_defweak
1056 || (h->elf_link_hash_flags
1057 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
1059 struct elf_i386_dyn_relocs *p;
1060 struct elf_i386_dyn_relocs **head;
1062 /* We must copy these reloc types into the output file.
1063 Create a reloc section in dynobj and make room for
1069 unsigned int strndx = elf_elfheader (abfd)->e_shstrndx;
1070 unsigned int shnam = elf_section_data (sec)->rel_hdr.sh_name;
1072 name = bfd_elf_string_from_elf_section (abfd, strndx, shnam);
1076 if (strncmp (name, ".rel", 4) != 0
1077 || strcmp (bfd_get_section_name (abfd, sec),
1080 (*_bfd_error_handler)
1081 (_("%s: bad relocation section name `%s\'"),
1082 bfd_archive_filename (abfd), name);
1085 if (htab->elf.dynobj == NULL)
1086 htab->elf.dynobj = abfd;
1088 dynobj = htab->elf.dynobj;
1089 sreloc = bfd_get_section_by_name (dynobj, name);
1094 sreloc = bfd_make_section (dynobj, name);
1095 flags = (SEC_HAS_CONTENTS | SEC_READONLY
1096 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1097 if ((sec->flags & SEC_ALLOC) != 0)
1098 flags |= SEC_ALLOC | SEC_LOAD;
1100 || ! bfd_set_section_flags (dynobj, sreloc, flags)
1101 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
1104 elf_section_data (sec)->sreloc = sreloc;
1107 /* If this is a global symbol, we count the number of
1108 relocations we need for this symbol. */
1111 head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs;
1115 /* Track dynamic relocs needed for local syms too.
1116 We really need local syms available to do this
1120 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1125 head = ((struct elf_i386_dyn_relocs **)
1126 &elf_section_data (s)->local_dynrel);
1130 if (p == NULL || p->sec != sec)
1132 bfd_size_type amt = sizeof *p;
1133 p = ((struct elf_i386_dyn_relocs *)
1134 bfd_alloc (htab->elf.dynobj, amt));
1145 if (r_type == R_386_PC32)
1150 /* This relocation describes the C++ object vtable hierarchy.
1151 Reconstruct it for later use during GC. */
1152 case R_386_GNU_VTINHERIT:
1153 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1157 /* This relocation describes which C++ vtable entries are actually
1158 used. Record for later use during GC. */
1159 case R_386_GNU_VTENTRY:
1160 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
1164 case R_386_TLS_LE_32:
1168 (*_bfd_error_handler) (_("%s: TLS local exec code cannot be linked into shared objects"),
1169 bfd_archive_filename (abfd));
1182 /* Return the section that should be marked against GC for a given
1186 elf_i386_gc_mark_hook (sec, info, rel, h, sym)
1188 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1189 Elf_Internal_Rela *rel;
1190 struct elf_link_hash_entry *h;
1191 Elf_Internal_Sym *sym;
1195 switch (ELF32_R_TYPE (rel->r_info))
1197 case R_386_GNU_VTINHERIT:
1198 case R_386_GNU_VTENTRY:
1202 switch (h->root.type)
1204 case bfd_link_hash_defined:
1205 case bfd_link_hash_defweak:
1206 return h->root.u.def.section;
1208 case bfd_link_hash_common:
1209 return h->root.u.c.p->section;
1217 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1222 /* Update the got entry reference counts for the section being removed. */
1225 elf_i386_gc_sweep_hook (abfd, info, sec, relocs)
1227 struct bfd_link_info *info;
1229 const Elf_Internal_Rela *relocs;
1231 Elf_Internal_Shdr *symtab_hdr;
1232 struct elf_link_hash_entry **sym_hashes;
1233 bfd_signed_vma *local_got_refcounts;
1234 const Elf_Internal_Rela *rel, *relend;
1235 unsigned long r_symndx;
1236 struct elf_link_hash_entry *h;
1238 elf_section_data (sec)->local_dynrel = NULL;
1240 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1241 sym_hashes = elf_sym_hashes (abfd);
1242 local_got_refcounts = elf_local_got_refcounts (abfd);
1244 relend = relocs + sec->reloc_count;
1245 for (rel = relocs; rel < relend; rel++)
1246 switch (elf_i386_tls_transition (info, ELF32_R_TYPE (rel->r_info),
1247 ELF32_R_SYM (rel->r_info)
1248 >= symtab_hdr->sh_info))
1251 if (elf_i386_hash_table (info)->tls_ldm_got.refcount > 0)
1252 elf_i386_hash_table (info)->tls_ldm_got.refcount -= 1;
1256 case R_386_TLS_IE_32:
1258 r_symndx = ELF32_R_SYM (rel->r_info);
1259 if (r_symndx >= symtab_hdr->sh_info)
1261 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1262 if (h->got.refcount > 0)
1263 h->got.refcount -= 1;
1265 else if (local_got_refcounts != NULL)
1267 if (local_got_refcounts[r_symndx] > 0)
1268 local_got_refcounts[r_symndx] -= 1;
1274 r_symndx = ELF32_R_SYM (rel->r_info);
1275 if (r_symndx >= symtab_hdr->sh_info)
1277 struct elf_i386_link_hash_entry *eh;
1278 struct elf_i386_dyn_relocs **pp;
1279 struct elf_i386_dyn_relocs *p;
1281 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1283 if (!info->shared && h->plt.refcount > 0)
1284 h->plt.refcount -= 1;
1286 eh = (struct elf_i386_link_hash_entry *) h;
1288 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1291 if (ELF32_R_TYPE (rel->r_info) == R_386_PC32)
1302 r_symndx = ELF32_R_SYM (rel->r_info);
1303 if (r_symndx >= symtab_hdr->sh_info)
1305 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1306 if (h->plt.refcount > 0)
1307 h->plt.refcount -= 1;
1318 /* Adjust a symbol defined by a dynamic object and referenced by a
1319 regular object. The current definition is in some section of the
1320 dynamic object, but we're not including those sections. We have to
1321 change the definition to something the rest of the link can
1325 elf_i386_adjust_dynamic_symbol (info, h)
1326 struct bfd_link_info *info;
1327 struct elf_link_hash_entry *h;
1329 struct elf_i386_link_hash_table *htab;
1330 struct elf_i386_link_hash_entry * eh;
1331 struct elf_i386_dyn_relocs *p;
1333 unsigned int power_of_two;
1335 /* If this is a function, put it in the procedure linkage table. We
1336 will fill in the contents of the procedure linkage table later,
1337 when we know the address of the .got section. */
1338 if (h->type == STT_FUNC
1339 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
1341 if (h->plt.refcount <= 0
1343 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
1344 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
1345 && h->root.type != bfd_link_hash_undefweak
1346 && h->root.type != bfd_link_hash_undefined))
1348 /* This case can occur if we saw a PLT32 reloc in an input
1349 file, but the symbol was never referred to by a dynamic
1350 object, or if all references were garbage collected. In
1351 such a case, we don't actually need to build a procedure
1352 linkage table, and we can just do a PC32 reloc instead. */
1353 h->plt.offset = (bfd_vma) -1;
1354 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1360 /* It's possible that we incorrectly decided a .plt reloc was
1361 needed for an R_386_PC32 reloc to a non-function sym in
1362 check_relocs. We can't decide accurately between function and
1363 non-function syms in check-relocs; Objects loaded later in
1364 the link may change h->type. So fix it now. */
1365 h->plt.offset = (bfd_vma) -1;
1367 /* If this is a weak symbol, and there is a real definition, the
1368 processor independent code will have arranged for us to see the
1369 real definition first, and we can just use the same value. */
1370 if (h->weakdef != NULL)
1372 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1373 || h->weakdef->root.type == bfd_link_hash_defweak);
1374 h->root.u.def.section = h->weakdef->root.u.def.section;
1375 h->root.u.def.value = h->weakdef->root.u.def.value;
1379 /* This is a reference to a symbol defined by a dynamic object which
1380 is not a function. */
1382 /* If we are creating a shared library, we must presume that the
1383 only references to the symbol are via the global offset table.
1384 For such cases we need not do anything here; the relocations will
1385 be handled correctly by relocate_section. */
1389 /* If there are no references to this symbol that do not use the
1390 GOT, we don't need to generate a copy reloc. */
1391 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
1394 /* If -z nocopyreloc was given, we won't generate them either. */
1395 if (info->nocopyreloc)
1397 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1401 eh = (struct elf_i386_link_hash_entry *) h;
1402 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1404 s = p->sec->output_section;
1405 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1409 /* If we didn't find any dynamic relocs in read-only sections, then
1410 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1413 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1417 /* We must allocate the symbol in our .dynbss section, which will
1418 become part of the .bss section of the executable. There will be
1419 an entry for this symbol in the .dynsym section. The dynamic
1420 object will contain position independent code, so all references
1421 from the dynamic object to this symbol will go through the global
1422 offset table. The dynamic linker will use the .dynsym entry to
1423 determine the address it must put in the global offset table, so
1424 both the dynamic object and the regular object will refer to the
1425 same memory location for the variable. */
1427 htab = elf_i386_hash_table (info);
1429 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1430 copy the initial value out of the dynamic object and into the
1431 runtime process image. */
1432 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1434 htab->srelbss->_raw_size += sizeof (Elf32_External_Rel);
1435 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1438 /* We need to figure out the alignment required for this symbol. I
1439 have no idea how ELF linkers handle this. */
1440 power_of_two = bfd_log2 (h->size);
1441 if (power_of_two > 3)
1444 /* Apply the required alignment. */
1446 s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
1447 if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
1449 if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
1453 /* Define the symbol as being at this point in the section. */
1454 h->root.u.def.section = s;
1455 h->root.u.def.value = s->_raw_size;
1457 /* Increment the section size to make room for the symbol. */
1458 s->_raw_size += h->size;
1463 /* This is the condition under which elf_i386_finish_dynamic_symbol
1464 will be called from elflink.h. If elflink.h doesn't call our
1465 finish_dynamic_symbol routine, we'll need to do something about
1466 initializing any .plt and .got entries in elf_i386_relocate_section. */
1467 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1469 && ((INFO)->shared \
1470 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1471 && ((H)->dynindx != -1 \
1472 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1474 /* Allocate space in .plt, .got and associated reloc sections for
1478 allocate_dynrelocs (h, inf)
1479 struct elf_link_hash_entry *h;
1482 struct bfd_link_info *info;
1483 struct elf_i386_link_hash_table *htab;
1484 struct elf_i386_link_hash_entry *eh;
1485 struct elf_i386_dyn_relocs *p;
1487 if (h->root.type == bfd_link_hash_indirect)
1490 if (h->root.type == bfd_link_hash_warning)
1491 /* When warning symbols are created, they **replace** the "real"
1492 entry in the hash table, thus we never get to see the real
1493 symbol in a hash traversal. So look at it now. */
1494 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1496 info = (struct bfd_link_info *) inf;
1497 htab = elf_i386_hash_table (info);
1499 if (htab->elf.dynamic_sections_created
1500 && h->plt.refcount > 0)
1502 /* Make sure this symbol is output as a dynamic symbol.
1503 Undefined weak syms won't yet be marked as dynamic. */
1504 if (h->dynindx == -1
1505 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1507 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1511 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
1513 asection *s = htab->splt;
1515 /* If this is the first .plt entry, make room for the special
1517 if (s->_raw_size == 0)
1518 s->_raw_size += PLT_ENTRY_SIZE;
1520 h->plt.offset = s->_raw_size;
1522 /* If this symbol is not defined in a regular file, and we are
1523 not generating a shared library, then set the symbol to this
1524 location in the .plt. This is required to make function
1525 pointers compare as equal between the normal executable and
1526 the shared library. */
1528 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1530 h->root.u.def.section = s;
1531 h->root.u.def.value = h->plt.offset;
1534 /* Make room for this entry. */
1535 s->_raw_size += PLT_ENTRY_SIZE;
1537 /* We also need to make an entry in the .got.plt section, which
1538 will be placed in the .got section by the linker script. */
1539 htab->sgotplt->_raw_size += 4;
1541 /* We also need to make an entry in the .rel.plt section. */
1542 htab->srelplt->_raw_size += sizeof (Elf32_External_Rel);
1546 h->plt.offset = (bfd_vma) -1;
1547 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1552 h->plt.offset = (bfd_vma) -1;
1553 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1556 /* If R_386_TLS_IE_32 symbol is now local to the binary,
1557 make it a R_386_TLS_LE_32 requiring no TLS entry. */
1558 if (h->got.refcount > 0
1561 && elf_i386_hash_entry(h)->tls_type == GOT_TLS_IE)
1562 h->got.offset = (bfd_vma) -1;
1563 else if (h->got.refcount > 0)
1567 int tls_type = elf_i386_hash_entry(h)->tls_type;
1569 /* Make sure this symbol is output as a dynamic symbol.
1570 Undefined weak syms won't yet be marked as dynamic. */
1571 if (h->dynindx == -1
1572 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1574 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1579 h->got.offset = s->_raw_size;
1581 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
1582 if (tls_type == GOT_TLS_GD)
1584 dyn = htab->elf.dynamic_sections_created;
1585 /* R_386_TLS_IE_32 needs one dynamic relocation,
1586 R_386_TLS_GD needs one if local symbol and two if global. */
1587 if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1588 || tls_type == GOT_TLS_IE)
1589 htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1590 else if (tls_type == GOT_TLS_GD)
1591 htab->srelgot->_raw_size += 2 * sizeof (Elf32_External_Rel);
1592 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
1593 htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1596 h->got.offset = (bfd_vma) -1;
1598 eh = (struct elf_i386_link_hash_entry *) h;
1599 if (eh->dyn_relocs == NULL)
1602 /* In the shared -Bsymbolic case, discard space allocated for
1603 dynamic pc-relative relocs against symbols which turn out to be
1604 defined in regular objects. For the normal shared case, discard
1605 space for pc-relative relocs that have become local due to symbol
1606 visibility changes. */
1610 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1611 && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1614 struct elf_i386_dyn_relocs **pp;
1616 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1618 p->count -= p->pc_count;
1629 /* For the non-shared case, discard space for relocs against
1630 symbols which turn out to need copy relocs or are not
1633 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1634 && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1635 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1636 || (htab->elf.dynamic_sections_created
1637 && (h->root.type == bfd_link_hash_undefweak
1638 || h->root.type == bfd_link_hash_undefined))))
1640 /* Make sure this symbol is output as a dynamic symbol.
1641 Undefined weak syms won't yet be marked as dynamic. */
1642 if (h->dynindx == -1
1643 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1645 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1649 /* If that succeeded, we know we'll be keeping all the
1651 if (h->dynindx != -1)
1655 eh->dyn_relocs = NULL;
1660 /* Finally, allocate space. */
1661 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1663 asection *sreloc = elf_section_data (p->sec)->sreloc;
1664 sreloc->_raw_size += p->count * sizeof (Elf32_External_Rel);
1670 /* Find any dynamic relocs that apply to read-only sections. */
1673 readonly_dynrelocs (h, inf)
1674 struct elf_link_hash_entry *h;
1677 struct elf_i386_link_hash_entry *eh;
1678 struct elf_i386_dyn_relocs *p;
1680 if (h->root.type == bfd_link_hash_warning)
1681 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1683 eh = (struct elf_i386_link_hash_entry *) h;
1684 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1686 asection *s = p->sec->output_section;
1688 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1690 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1692 info->flags |= DF_TEXTREL;
1694 /* Not an error, just cut short the traversal. */
1701 /* Set the sizes of the dynamic sections. */
1704 elf_i386_size_dynamic_sections (output_bfd, info)
1705 bfd *output_bfd ATTRIBUTE_UNUSED;
1706 struct bfd_link_info *info;
1708 struct elf_i386_link_hash_table *htab;
1714 htab = elf_i386_hash_table (info);
1715 dynobj = htab->elf.dynobj;
1719 if (htab->elf.dynamic_sections_created)
1721 /* Set the contents of the .interp section to the interpreter. */
1724 s = bfd_get_section_by_name (dynobj, ".interp");
1727 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1728 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1732 /* Set up .got offsets for local syms, and space for local dynamic
1734 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1736 bfd_signed_vma *local_got;
1737 bfd_signed_vma *end_local_got;
1738 char *local_tls_type;
1739 bfd_size_type locsymcount;
1740 Elf_Internal_Shdr *symtab_hdr;
1743 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1746 for (s = ibfd->sections; s != NULL; s = s->next)
1748 struct elf_i386_dyn_relocs *p;
1750 for (p = *((struct elf_i386_dyn_relocs **)
1751 &elf_section_data (s)->local_dynrel);
1755 if (!bfd_is_abs_section (p->sec)
1756 && bfd_is_abs_section (p->sec->output_section))
1758 /* Input section has been discarded, either because
1759 it is a copy of a linkonce section or due to
1760 linker script /DISCARD/, so we'll be discarding
1763 else if (p->count != 0)
1765 srel = elf_section_data (p->sec)->sreloc;
1766 srel->_raw_size += p->count * sizeof (Elf32_External_Rel);
1767 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1768 info->flags |= DF_TEXTREL;
1773 local_got = elf_local_got_refcounts (ibfd);
1777 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1778 locsymcount = symtab_hdr->sh_info;
1779 end_local_got = local_got + locsymcount;
1780 local_tls_type = elf_i386_local_got_tls_type (ibfd);
1782 srel = htab->srelgot;
1783 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
1787 *local_got = s->_raw_size;
1789 if (*local_tls_type == GOT_TLS_GD)
1792 || *local_tls_type == GOT_TLS_GD
1793 || *local_tls_type == GOT_TLS_IE)
1794 srel->_raw_size += sizeof (Elf32_External_Rel);
1797 *local_got = (bfd_vma) -1;
1801 if (htab->tls_ldm_got.refcount > 0)
1803 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1805 htab->tls_ldm_got.offset = htab->sgot->_raw_size;
1806 htab->sgot->_raw_size += 8;
1807 htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1810 htab->tls_ldm_got.offset = -1;
1812 /* Allocate global sym .plt and .got entries, and space for global
1813 sym dynamic relocs. */
1814 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
1816 /* We now have determined the sizes of the various dynamic sections.
1817 Allocate memory for them. */
1819 for (s = dynobj->sections; s != NULL; s = s->next)
1821 if ((s->flags & SEC_LINKER_CREATED) == 0)
1826 || s == htab->sgotplt)
1828 /* Strip this section if we don't need it; see the
1831 else if (strncmp (bfd_get_section_name (dynobj, s), ".rel", 4) == 0)
1833 if (s->_raw_size != 0 && s != htab->srelplt)
1836 /* We use the reloc_count field as a counter if we need
1837 to copy relocs into the output file. */
1842 /* It's not one of our sections, so don't allocate space. */
1846 if (s->_raw_size == 0)
1848 /* If we don't need this section, strip it from the
1849 output file. This is mostly to handle .rel.bss and
1850 .rel.plt. We must create both sections in
1851 create_dynamic_sections, because they must be created
1852 before the linker maps input sections to output
1853 sections. The linker does that before
1854 adjust_dynamic_symbol is called, and it is that
1855 function which decides whether anything needs to go
1856 into these sections. */
1858 _bfd_strip_section_from_output (info, s);
1862 /* Allocate memory for the section contents. We use bfd_zalloc
1863 here in case unused entries are not reclaimed before the
1864 section's contents are written out. This should not happen,
1865 but this way if it does, we get a R_386_NONE reloc instead
1867 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1868 if (s->contents == NULL)
1872 if (htab->elf.dynamic_sections_created)
1874 /* Add some entries to the .dynamic section. We fill in the
1875 values later, in elf_i386_finish_dynamic_sections, but we
1876 must add the entries now so that we get the correct size for
1877 the .dynamic section. The DT_DEBUG entry is filled in by the
1878 dynamic linker and used by the debugger. */
1879 #define add_dynamic_entry(TAG, VAL) \
1880 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1884 if (!add_dynamic_entry (DT_DEBUG, 0))
1888 if (htab->splt->_raw_size != 0)
1890 if (!add_dynamic_entry (DT_PLTGOT, 0)
1891 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1892 || !add_dynamic_entry (DT_PLTREL, DT_REL)
1893 || !add_dynamic_entry (DT_JMPREL, 0))
1899 if (!add_dynamic_entry (DT_REL, 0)
1900 || !add_dynamic_entry (DT_RELSZ, 0)
1901 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
1904 /* If any dynamic relocs apply to a read-only section,
1905 then we need a DT_TEXTREL entry. */
1906 if ((info->flags & DF_TEXTREL) == 0)
1907 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
1910 if ((info->flags & DF_TEXTREL) != 0)
1912 if (!add_dynamic_entry (DT_TEXTREL, 0))
1917 #undef add_dynamic_entry
1922 /* Set the correct type for an x86 ELF section. We do this by the
1923 section name, which is a hack, but ought to work. */
1926 elf_i386_fake_sections (abfd, hdr, sec)
1927 bfd *abfd ATTRIBUTE_UNUSED;
1928 Elf32_Internal_Shdr *hdr;
1931 register const char *name;
1933 name = bfd_get_section_name (abfd, sec);
1935 /* This is an ugly, but unfortunately necessary hack that is
1936 needed when producing EFI binaries on x86. It tells
1937 elf.c:elf_fake_sections() not to consider ".reloc" as a section
1938 containing ELF relocation info. We need this hack in order to
1939 be able to generate ELF binaries that can be translated into
1940 EFI applications (which are essentially COFF objects). Those
1941 files contain a COFF ".reloc" section inside an ELFNN object,
1942 which would normally cause BFD to segfault because it would
1943 attempt to interpret this section as containing relocation
1944 entries for section "oc". With this hack enabled, ".reloc"
1945 will be treated as a normal data section, which will avoid the
1946 segfault. However, you won't be able to create an ELFNN binary
1947 with a section named "oc" that needs relocations, but that's
1948 the kind of ugly side-effects you get when detecting section
1949 types based on their names... In practice, this limitation is
1950 unlikely to bite. */
1951 if (strcmp (name, ".reloc") == 0)
1952 hdr->sh_type = SHT_PROGBITS;
1957 /* Return the base VMA address which should be subtracted from real addresses
1958 when resolving @dtpoff relocation.
1959 This is PT_TLS segment p_vaddr. */
1963 struct bfd_link_info *info;
1965 BFD_ASSERT (elf_hash_table (info)->tls_segment != NULL);
1966 return elf_hash_table (info)->tls_segment->start;
1969 /* Return the relocation value for @tpoff relocation
1970 if STT_TLS virtual address is ADDRESS. */
1973 tpoff (info, address)
1974 struct bfd_link_info *info;
1977 struct elf_link_tls_segment *tls_segment
1978 = elf_hash_table (info)->tls_segment;
1980 BFD_ASSERT (tls_segment != NULL);
1981 return (align_power (tls_segment->size, tls_segment->align)
1982 + tls_segment->start - address);
1985 /* Relocate an i386 ELF section. */
1988 elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
1989 contents, relocs, local_syms, local_sections)
1991 struct bfd_link_info *info;
1993 asection *input_section;
1995 Elf_Internal_Rela *relocs;
1996 Elf_Internal_Sym *local_syms;
1997 asection **local_sections;
1999 struct elf_i386_link_hash_table *htab;
2000 Elf_Internal_Shdr *symtab_hdr;
2001 struct elf_link_hash_entry **sym_hashes;
2002 bfd_vma *local_got_offsets;
2003 Elf_Internal_Rela *rel;
2004 Elf_Internal_Rela *relend;
2006 htab = elf_i386_hash_table (info);
2007 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2008 sym_hashes = elf_sym_hashes (input_bfd);
2009 local_got_offsets = elf_local_got_offsets (input_bfd);
2012 relend = relocs + input_section->reloc_count;
2013 for (; rel < relend; rel++)
2015 unsigned int r_type;
2016 reloc_howto_type *howto;
2017 unsigned long r_symndx;
2018 struct elf_link_hash_entry *h;
2019 Elf_Internal_Sym *sym;
2023 boolean unresolved_reloc;
2024 bfd_reloc_status_type r;
2028 r_type = ELF32_R_TYPE (rel->r_info);
2029 if (r_type == (int) R_386_GNU_VTINHERIT
2030 || r_type == (int) R_386_GNU_VTENTRY)
2033 if ((indx = (unsigned) r_type) >= R_386_standard
2034 && ((indx = r_type - R_386_ext_offset) - R_386_standard
2035 >= R_386_ext - R_386_standard)
2036 && ((indx = r_type - R_386_tls_offset) - R_386_ext
2037 >= R_386_tls - R_386_ext))
2039 bfd_set_error (bfd_error_bad_value);
2042 howto = elf_howto_table + indx;
2044 r_symndx = ELF32_R_SYM (rel->r_info);
2046 if (info->relocateable)
2051 /* This is a relocatable link. We don't have to change
2052 anything, unless the reloc is against a section symbol,
2053 in which case we have to adjust according to where the
2054 section symbol winds up in the output section. */
2055 if (r_symndx >= symtab_hdr->sh_info)
2058 sym = local_syms + r_symndx;
2059 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2062 sec = local_sections[r_symndx];
2063 val = sec->output_offset;
2067 where = contents + rel->r_offset;
2068 switch (howto->size)
2070 /* FIXME: overflow checks. */
2072 val += bfd_get_8 (input_bfd, where);
2073 bfd_put_8 (input_bfd, val, where);
2076 val += bfd_get_16 (input_bfd, where);
2077 bfd_put_16 (input_bfd, val, where);
2080 val += bfd_get_32 (input_bfd, where);
2081 bfd_put_32 (input_bfd, val, where);
2089 /* This is a final link. */
2093 unresolved_reloc = false;
2094 if (r_symndx < symtab_hdr->sh_info)
2096 sym = local_syms + r_symndx;
2097 sec = local_sections[r_symndx];
2098 relocation = (sec->output_section->vma
2099 + sec->output_offset
2101 if ((sec->flags & SEC_MERGE)
2102 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2106 bfd_byte *where = contents + rel->r_offset;
2108 switch (howto->size)
2111 addend = bfd_get_8 (input_bfd, where);
2112 if (howto->pc_relative)
2114 addend = (addend ^ 0x80) - 0x80;
2119 addend = bfd_get_16 (input_bfd, where);
2120 if (howto->pc_relative)
2122 addend = (addend ^ 0x8000) - 0x8000;
2127 addend = bfd_get_32 (input_bfd, where);
2128 if (howto->pc_relative)
2130 addend = (addend ^ 0x80000000) - 0x80000000;
2139 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2140 addend -= relocation;
2141 addend += msec->output_section->vma + msec->output_offset;
2143 switch (howto->size)
2146 /* FIXME: overflow checks. */
2147 if (howto->pc_relative)
2149 bfd_put_8 (input_bfd, addend, where);
2152 if (howto->pc_relative)
2154 bfd_put_16 (input_bfd, addend, where);
2157 if (howto->pc_relative)
2159 bfd_put_32 (input_bfd, addend, where);
2166 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2167 while (h->root.type == bfd_link_hash_indirect
2168 || h->root.type == bfd_link_hash_warning)
2169 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2172 if (h->root.type == bfd_link_hash_defined
2173 || h->root.type == bfd_link_hash_defweak)
2175 sec = h->root.u.def.section;
2176 if (sec->output_section == NULL)
2177 /* Set a flag that will be cleared later if we find a
2178 relocation value for this symbol. output_section
2179 is typically NULL for symbols satisfied by a shared
2181 unresolved_reloc = true;
2183 relocation = (h->root.u.def.value
2184 + sec->output_section->vma
2185 + sec->output_offset);
2187 else if (h->root.type == bfd_link_hash_undefweak)
2189 else if (info->shared
2190 && (!info->symbolic || info->allow_shlib_undefined)
2191 && !info->no_undefined
2192 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2196 if (! ((*info->callbacks->undefined_symbol)
2197 (info, h->root.root.string, input_bfd,
2198 input_section, rel->r_offset,
2199 (!info->shared || info->no_undefined
2200 || ELF_ST_VISIBILITY (h->other)))))
2208 /* Relocation is to the entry for this symbol in the global
2210 if (htab->sgot == NULL)
2217 off = h->got.offset;
2218 dyn = htab->elf.dynamic_sections_created;
2219 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
2223 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2224 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
2226 /* This is actually a static link, or it is a
2227 -Bsymbolic link and the symbol is defined
2228 locally, or the symbol was forced to be local
2229 because of a version file. We must initialize
2230 this entry in the global offset table. Since the
2231 offset must always be a multiple of 4, we use the
2232 least significant bit to record whether we have
2233 initialized it already.
2235 When doing a dynamic link, we create a .rel.got
2236 relocation entry to initialize the value. This
2237 is done in the finish_dynamic_symbol routine. */
2242 bfd_put_32 (output_bfd, relocation,
2243 htab->sgot->contents + off);
2248 unresolved_reloc = false;
2252 if (local_got_offsets == NULL)
2255 off = local_got_offsets[r_symndx];
2257 /* The offset must always be a multiple of 4. We use
2258 the least significant bit to record whether we have
2259 already generated the necessary reloc. */
2264 bfd_put_32 (output_bfd, relocation,
2265 htab->sgot->contents + off);
2270 Elf_Internal_Rel outrel;
2271 Elf32_External_Rel *loc;
2273 srelgot = htab->srelgot;
2274 if (srelgot == NULL)
2277 outrel.r_offset = (htab->sgot->output_section->vma
2278 + htab->sgot->output_offset
2280 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2281 loc = (Elf32_External_Rel *) srelgot->contents;
2282 loc += srelgot->reloc_count++;
2283 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2286 local_got_offsets[r_symndx] |= 1;
2290 if (off >= (bfd_vma) -2)
2293 relocation = htab->sgot->output_offset + off;
2297 /* Relocation is relative to the start of the global offset
2300 /* Note that sgot->output_offset is not involved in this
2301 calculation. We always want the start of .got. If we
2302 defined _GLOBAL_OFFSET_TABLE in a different way, as is
2303 permitted by the ABI, we might have to change this
2305 relocation -= htab->sgot->output_section->vma;
2309 /* Use global offset table as symbol value. */
2310 relocation = htab->sgot->output_section->vma;
2311 unresolved_reloc = false;
2315 /* Relocation is to the entry for this symbol in the
2316 procedure linkage table. */
2318 /* Resolve a PLT32 reloc against a local symbol directly,
2319 without using the procedure linkage table. */
2323 if (h->plt.offset == (bfd_vma) -1
2324 || htab->splt == NULL)
2326 /* We didn't make a PLT entry for this symbol. This
2327 happens when statically linking PIC code, or when
2328 using -Bsymbolic. */
2332 relocation = (htab->splt->output_section->vma
2333 + htab->splt->output_offset
2335 unresolved_reloc = false;
2340 /* r_symndx will be zero only for relocs against symbols
2341 from removed linkonce sections, or sections discarded by
2344 || (input_section->flags & SEC_ALLOC) == 0)
2348 && (r_type != R_386_PC32
2351 && (! info->symbolic
2352 || (h->elf_link_hash_flags
2353 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2357 && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
2358 && (((h->elf_link_hash_flags
2359 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2360 && (h->elf_link_hash_flags
2361 & ELF_LINK_HASH_DEF_REGULAR) == 0)
2362 || h->root.type == bfd_link_hash_undefweak
2363 || h->root.type == bfd_link_hash_undefined)))
2365 Elf_Internal_Rel outrel;
2366 boolean skip, relocate;
2368 Elf32_External_Rel *loc;
2370 /* When generating a shared object, these relocations
2371 are copied into the output file to be resolved at run
2378 _bfd_elf_section_offset (output_bfd, info, input_section,
2380 if (outrel.r_offset == (bfd_vma) -1)
2382 else if (outrel.r_offset == (bfd_vma) -2)
2383 skip = true, relocate = true;
2384 outrel.r_offset += (input_section->output_section->vma
2385 + input_section->output_offset);
2388 memset (&outrel, 0, sizeof outrel);
2391 && (r_type == R_386_PC32
2394 || (h->elf_link_hash_flags
2395 & ELF_LINK_HASH_DEF_REGULAR) == 0))
2396 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2399 /* This symbol is local, or marked to become local. */
2401 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2404 sreloc = elf_section_data (input_section)->sreloc;
2408 loc = (Elf32_External_Rel *) sreloc->contents;
2409 loc += sreloc->reloc_count++;
2410 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2412 /* If this reloc is against an external symbol, we do
2413 not want to fiddle with the addend. Otherwise, we
2414 need to include the symbol value so that it becomes
2415 an addend for the dynamic reloc. */
2422 case R_386_TLS_IE_32:
2423 r_type = elf_i386_tls_transition (info, r_type, h == NULL);
2424 tls_type = GOT_UNKNOWN;
2425 if (h == NULL && local_got_offsets)
2426 tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
2429 tls_type = elf_i386_hash_entry(h)->tls_type;
2430 if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
2431 r_type = R_386_TLS_LE_32;
2433 if (r_type == R_386_TLS_GD && tls_type == GOT_TLS_IE)
2434 r_type = R_386_TLS_IE_32;
2436 if (r_type == R_386_TLS_LE_32)
2438 BFD_ASSERT (! unresolved_reloc);
2439 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
2441 unsigned int val, type;
2444 /* GD->LE transition. */
2445 BFD_ASSERT (rel->r_offset >= 2);
2446 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2447 BFD_ASSERT (type == 0x8d || type == 0x04);
2448 BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2449 BFD_ASSERT (bfd_get_8 (input_bfd,
2450 contents + rel->r_offset + 4)
2452 BFD_ASSERT (rel + 1 < relend);
2453 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2454 roff = rel->r_offset + 5;
2455 val = bfd_get_8 (input_bfd,
2456 contents + rel->r_offset - 1);
2459 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2461 movl %gs:0, %eax; subl $foo@tpoff, %eax
2462 (6 byte form of subl). */
2463 BFD_ASSERT (rel->r_offset >= 3);
2464 BFD_ASSERT (bfd_get_8 (input_bfd,
2465 contents + rel->r_offset - 3)
2467 BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2468 memcpy (contents + rel->r_offset - 3,
2469 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2473 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2474 if (rel->r_offset + 10 <= input_section->_raw_size
2475 && bfd_get_8 (input_bfd,
2476 contents + rel->r_offset + 9) == 0x90)
2478 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2480 movl %gs:0, %eax; subl $foo@tpoff, %eax
2481 (6 byte form of subl). */
2482 memcpy (contents + rel->r_offset - 2,
2483 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2484 roff = rel->r_offset + 6;
2488 /* leal foo(%reg), %eax; call ___tls_get_addr
2490 movl %gs:0, %eax; subl $foo@tpoff, %eax
2491 (5 byte form of subl). */
2492 memcpy (contents + rel->r_offset - 2,
2493 "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2496 bfd_put_32 (output_bfd, tpoff (info, relocation),
2498 /* Skip R_386_PLT32. */
2504 unsigned int val, type;
2506 /* IE->LE transition:
2507 Originally it can be either:
2508 subl foo(%reg1), %reg2
2510 movl foo(%reg1), %reg2
2514 movl $foo, %reg2 (6 byte form) */
2515 BFD_ASSERT (rel->r_offset >= 2);
2516 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2517 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2518 BFD_ASSERT (rel->r_offset + 4 <= input_section->_raw_size);
2522 BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
2523 bfd_put_8 (output_bfd, 0xc7,
2524 contents + rel->r_offset - 2);
2525 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2526 contents + rel->r_offset - 1);
2528 else if (type == 0x2b)
2531 BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
2532 bfd_put_8 (output_bfd, 0x81,
2533 contents + rel->r_offset - 2);
2534 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
2535 contents + rel->r_offset - 1);
2539 bfd_put_32 (output_bfd, tpoff (info, relocation),
2540 contents + rel->r_offset);
2545 if (htab->sgot == NULL)
2549 off = h->got.offset;
2552 if (local_got_offsets == NULL)
2555 off = local_got_offsets[r_symndx];
2562 Elf_Internal_Rel outrel;
2563 Elf32_External_Rel *loc;
2566 if (htab->srelgot == NULL)
2569 outrel.r_offset = (htab->sgot->output_section->vma
2570 + htab->sgot->output_offset + off);
2572 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2573 if (r_type == R_386_TLS_GD)
2574 dr_type = R_386_TLS_DTPMOD32;
2576 dr_type = R_386_TLS_TPOFF32;
2577 if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
2578 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
2579 htab->sgot->contents + off);
2581 bfd_put_32 (output_bfd, 0,
2582 htab->sgot->contents + off);
2583 outrel.r_info = ELF32_R_INFO (indx, dr_type);
2584 loc = (Elf32_External_Rel *) htab->srelgot->contents;
2585 loc += htab->srelgot->reloc_count++;
2586 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2588 if (r_type == R_386_TLS_GD)
2592 BFD_ASSERT (! unresolved_reloc);
2593 bfd_put_32 (output_bfd,
2594 relocation - dtpoff_base (info),
2595 htab->sgot->contents + off + 4);
2599 bfd_put_32 (output_bfd, 0,
2600 htab->sgot->contents + off + 4);
2601 outrel.r_info = ELF32_R_INFO (indx,
2602 R_386_TLS_DTPOFF32);
2603 outrel.r_offset += 4;
2604 htab->srelgot->reloc_count++;
2606 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
2614 local_got_offsets[r_symndx] |= 1;
2617 if (off >= (bfd_vma) -2)
2619 if (r_type == ELF32_R_TYPE (rel->r_info))
2621 relocation = htab->sgot->output_offset + off;
2622 unresolved_reloc = false;
2626 unsigned int val, type;
2629 /* GD->IE transition. */
2630 BFD_ASSERT (rel->r_offset >= 2);
2631 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2632 BFD_ASSERT (type == 0x8d || type == 0x04);
2633 BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2634 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2636 BFD_ASSERT (rel + 1 < relend);
2637 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2638 roff = rel->r_offset - 3;
2639 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2642 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2644 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
2645 BFD_ASSERT (rel->r_offset >= 3);
2646 BFD_ASSERT (bfd_get_8 (input_bfd,
2647 contents + rel->r_offset - 3)
2649 BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2654 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2656 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
2657 BFD_ASSERT (rel->r_offset + 10 <= input_section->_raw_size);
2658 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2659 BFD_ASSERT (bfd_get_8 (input_bfd,
2660 contents + rel->r_offset + 9)
2662 roff = rel->r_offset - 2;
2664 memcpy (contents + roff,
2665 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
2666 contents[roff + 7] = 0x80 | (val & 7);
2667 bfd_put_32 (output_bfd, htab->sgot->output_offset + off,
2668 contents + roff + 8);
2669 /* Skip R_386_PLT32. */
2680 /* LD->LE transition:
2682 leal foo(%reg), %eax; call ___tls_get_addr.
2684 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
2685 BFD_ASSERT (rel->r_offset >= 2);
2686 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 2)
2688 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2689 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2690 BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2691 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2693 BFD_ASSERT (rel + 1 < relend);
2694 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2695 memcpy (contents + rel->r_offset - 2,
2696 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
2697 /* Skip R_386_PLT32. */
2702 if (htab->sgot == NULL)
2705 off = htab->tls_ldm_got.offset;
2710 Elf_Internal_Rel outrel;
2711 Elf32_External_Rel *loc;
2713 if (htab->srelgot == NULL)
2716 outrel.r_offset = (htab->sgot->output_section->vma
2717 + htab->sgot->output_offset + off);
2719 bfd_put_32 (output_bfd, 0,
2720 htab->sgot->contents + off);
2721 bfd_put_32 (output_bfd, 0,
2722 htab->sgot->contents + off + 4);
2723 outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
2724 loc = (Elf32_External_Rel *) htab->srelgot->contents;
2725 loc += htab->srelgot->reloc_count++;
2726 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2727 htab->tls_ldm_got.offset |= 1;
2729 relocation = htab->sgot->output_offset + off;
2730 unresolved_reloc = false;
2733 case R_386_TLS_LDO_32:
2735 relocation -= dtpoff_base (info);
2737 /* When converting LDO to LE, we must negate. */
2738 relocation = -tpoff (info, relocation);
2741 case R_386_TLS_LE_32:
2742 relocation = tpoff (info, relocation);
2746 relocation = -tpoff (info, relocation);
2753 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2754 because such sections are not SEC_ALLOC and thus ld.so will
2755 not process them. */
2756 if (unresolved_reloc
2757 && !((input_section->flags & SEC_DEBUGGING) != 0
2758 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
2759 (*_bfd_error_handler)
2760 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2761 bfd_archive_filename (input_bfd),
2762 bfd_get_section_name (input_bfd, input_section),
2763 (long) rel->r_offset,
2764 h->root.root.string);
2766 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2767 contents, rel->r_offset,
2768 relocation, (bfd_vma) 0);
2770 if (r != bfd_reloc_ok)
2775 name = h->root.root.string;
2778 name = bfd_elf_string_from_elf_section (input_bfd,
2779 symtab_hdr->sh_link,
2784 name = bfd_section_name (input_bfd, sec);
2787 if (r == bfd_reloc_overflow)
2789 if (! ((*info->callbacks->reloc_overflow)
2790 (info, name, howto->name, (bfd_vma) 0,
2791 input_bfd, input_section, rel->r_offset)))
2796 (*_bfd_error_handler)
2797 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
2798 bfd_archive_filename (input_bfd),
2799 bfd_get_section_name (input_bfd, input_section),
2800 (long) rel->r_offset, name, (int) r);
2809 /* Finish up dynamic symbol handling. We set the contents of various
2810 dynamic sections here. */
2813 elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
2815 struct bfd_link_info *info;
2816 struct elf_link_hash_entry *h;
2817 Elf_Internal_Sym *sym;
2819 struct elf_i386_link_hash_table *htab;
2821 htab = elf_i386_hash_table (info);
2823 if (h->plt.offset != (bfd_vma) -1)
2827 Elf_Internal_Rel rel;
2828 Elf32_External_Rel *loc;
2830 /* This symbol has an entry in the procedure linkage table. Set
2833 if (h->dynindx == -1
2834 || htab->splt == NULL
2835 || htab->sgotplt == NULL
2836 || htab->srelplt == NULL)
2839 /* Get the index in the procedure linkage table which
2840 corresponds to this symbol. This is the index of this symbol
2841 in all the symbols for which we are making plt entries. The
2842 first entry in the procedure linkage table is reserved. */
2843 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2845 /* Get the offset into the .got table of the entry that
2846 corresponds to this function. Each .got entry is 4 bytes.
2847 The first three are reserved. */
2848 got_offset = (plt_index + 3) * 4;
2850 /* Fill in the entry in the procedure linkage table. */
2853 memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
2855 bfd_put_32 (output_bfd,
2856 (htab->sgotplt->output_section->vma
2857 + htab->sgotplt->output_offset
2859 htab->splt->contents + h->plt.offset + 2);
2863 memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
2865 bfd_put_32 (output_bfd, got_offset,
2866 htab->splt->contents + h->plt.offset + 2);
2869 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
2870 htab->splt->contents + h->plt.offset + 7);
2871 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
2872 htab->splt->contents + h->plt.offset + 12);
2874 /* Fill in the entry in the global offset table. */
2875 bfd_put_32 (output_bfd,
2876 (htab->splt->output_section->vma
2877 + htab->splt->output_offset
2880 htab->sgotplt->contents + got_offset);
2882 /* Fill in the entry in the .rel.plt section. */
2883 rel.r_offset = (htab->sgotplt->output_section->vma
2884 + htab->sgotplt->output_offset
2886 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
2887 loc = (Elf32_External_Rel *) htab->srelplt->contents + plt_index;
2888 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
2890 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2892 /* Mark the symbol as undefined, rather than as defined in
2893 the .plt section. Leave the value alone. This is a clue
2894 for the dynamic linker, to make function pointer
2895 comparisons work between an application and shared
2897 sym->st_shndx = SHN_UNDEF;
2901 if (h->got.offset != (bfd_vma) -1
2902 && elf_i386_hash_entry(h)->tls_type != GOT_TLS_GD
2903 && elf_i386_hash_entry(h)->tls_type != GOT_TLS_IE)
2905 Elf_Internal_Rel rel;
2906 Elf32_External_Rel *loc;
2908 /* This symbol has an entry in the global offset table. Set it
2911 if (htab->sgot == NULL || htab->srelgot == NULL)
2914 rel.r_offset = (htab->sgot->output_section->vma
2915 + htab->sgot->output_offset
2916 + (h->got.offset & ~(bfd_vma) 1));
2918 /* If this is a static link, or it is a -Bsymbolic link and the
2919 symbol is defined locally or was forced to be local because
2920 of a version file, we just want to emit a RELATIVE reloc.
2921 The entry in the global offset table will already have been
2922 initialized in the relocate_section function. */
2926 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2927 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
2929 BFD_ASSERT((h->got.offset & 1) != 0);
2930 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2934 BFD_ASSERT((h->got.offset & 1) == 0);
2935 bfd_put_32 (output_bfd, (bfd_vma) 0,
2936 htab->sgot->contents + h->got.offset);
2937 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
2940 loc = (Elf32_External_Rel *) htab->srelgot->contents;
2941 loc += htab->srelgot->reloc_count++;
2942 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
2945 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2947 Elf_Internal_Rel rel;
2948 Elf32_External_Rel *loc;
2950 /* This symbol needs a copy reloc. Set it up. */
2952 if (h->dynindx == -1
2953 || (h->root.type != bfd_link_hash_defined
2954 && h->root.type != bfd_link_hash_defweak)
2955 || htab->srelbss == NULL)
2958 rel.r_offset = (h->root.u.def.value
2959 + h->root.u.def.section->output_section->vma
2960 + h->root.u.def.section->output_offset);
2961 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
2962 loc = (Elf32_External_Rel *) htab->srelbss->contents;
2963 loc += htab->srelbss->reloc_count++;
2964 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
2967 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2968 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2969 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2970 sym->st_shndx = SHN_ABS;
2975 /* Used to decide how to sort relocs in an optimal manner for the
2976 dynamic linker, before writing them out. */
2978 static enum elf_reloc_type_class
2979 elf_i386_reloc_type_class (rela)
2980 const Elf_Internal_Rela *rela;
2982 switch ((int) ELF32_R_TYPE (rela->r_info))
2984 case R_386_RELATIVE:
2985 return reloc_class_relative;
2986 case R_386_JUMP_SLOT:
2987 return reloc_class_plt;
2989 return reloc_class_copy;
2991 return reloc_class_normal;
2995 /* Finish up the dynamic sections. */
2998 elf_i386_finish_dynamic_sections (output_bfd, info)
3000 struct bfd_link_info *info;
3002 struct elf_i386_link_hash_table *htab;
3006 htab = elf_i386_hash_table (info);
3007 dynobj = htab->elf.dynobj;
3008 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3010 if (htab->elf.dynamic_sections_created)
3012 Elf32_External_Dyn *dyncon, *dynconend;
3014 if (sdyn == NULL || htab->sgot == NULL)
3017 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3018 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3019 for (; dyncon < dynconend; dyncon++)
3021 Elf_Internal_Dyn dyn;
3024 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3032 dyn.d_un.d_ptr = htab->sgot->output_section->vma;
3036 dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
3040 s = htab->srelplt->output_section;
3041 if (s->_cooked_size != 0)
3042 dyn.d_un.d_val = s->_cooked_size;
3044 dyn.d_un.d_val = s->_raw_size;
3048 /* My reading of the SVR4 ABI indicates that the
3049 procedure linkage table relocs (DT_JMPREL) should be
3050 included in the overall relocs (DT_REL). This is
3051 what Solaris does. However, UnixWare can not handle
3052 that case. Therefore, we override the DT_RELSZ entry
3053 here to make it not include the JMPREL relocs. Since
3054 the linker script arranges for .rel.plt to follow all
3055 other relocation sections, we don't have to worry
3056 about changing the DT_REL entry. */
3057 if (htab->srelplt != NULL)
3059 s = htab->srelplt->output_section;
3060 if (s->_cooked_size != 0)
3061 dyn.d_un.d_val -= s->_cooked_size;
3063 dyn.d_un.d_val -= s->_raw_size;
3068 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3071 /* Fill in the first entry in the procedure linkage table. */
3072 if (htab->splt && htab->splt->_raw_size > 0)
3075 memcpy (htab->splt->contents,
3076 elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
3079 memcpy (htab->splt->contents,
3080 elf_i386_plt0_entry, PLT_ENTRY_SIZE);
3081 bfd_put_32 (output_bfd,
3082 (htab->sgotplt->output_section->vma
3083 + htab->sgotplt->output_offset
3085 htab->splt->contents + 2);
3086 bfd_put_32 (output_bfd,
3087 (htab->sgotplt->output_section->vma
3088 + htab->sgotplt->output_offset
3090 htab->splt->contents + 8);
3093 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3094 really seem like the right value. */
3095 elf_section_data (htab->splt->output_section)
3096 ->this_hdr.sh_entsize = 4;
3102 /* Fill in the first three entries in the global offset table. */
3103 if (htab->sgotplt->_raw_size > 0)
3105 bfd_put_32 (output_bfd,
3106 (sdyn == NULL ? (bfd_vma) 0
3107 : sdyn->output_section->vma + sdyn->output_offset),
3108 htab->sgotplt->contents);
3109 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 4);
3110 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8);
3113 elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
3118 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
3119 #define TARGET_LITTLE_NAME "elf32-i386"
3120 #define ELF_ARCH bfd_arch_i386
3121 #define ELF_MACHINE_CODE EM_386
3122 #define ELF_MAXPAGESIZE 0x1000
3124 #define elf_backend_can_gc_sections 1
3125 #define elf_backend_can_refcount 1
3126 #define elf_backend_want_got_plt 1
3127 #define elf_backend_plt_readonly 1
3128 #define elf_backend_want_plt_sym 0
3129 #define elf_backend_got_header_size 12
3130 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
3132 #define elf_info_to_howto elf_i386_info_to_howto
3133 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
3135 #define bfd_elf32_mkobject elf_i386_mkobject
3136 #define elf_backend_object_p elf_i386_object_p
3138 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
3139 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
3140 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
3142 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
3143 #define elf_backend_check_relocs elf_i386_check_relocs
3144 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
3145 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
3146 #define elf_backend_fake_sections elf_i386_fake_sections
3147 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
3148 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
3149 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
3150 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
3151 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
3152 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
3153 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
3154 #define elf_backend_relocate_section elf_i386_relocate_section
3155 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
3157 #ifndef ELF32_I386_C_INCLUDED
3158 #include "elf32-target.h"