1 /* Intel 80386/80486-specific support for 32-bit ELF
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
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_rel
30 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
31 static bfd_boolean elf_i386_is_local_label_name
32 PARAMS ((bfd *, const char *));
33 static bfd_boolean elf_i386_grok_prstatus
34 PARAMS ((bfd *abfd, Elf_Internal_Note *note));
35 static bfd_boolean elf_i386_grok_psinfo
36 PARAMS ((bfd *abfd, Elf_Internal_Note *note));
37 static struct bfd_hash_entry *link_hash_newfunc
38 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
39 static struct bfd_link_hash_table *elf_i386_link_hash_table_create
41 static bfd_boolean create_got_section
42 PARAMS ((bfd *, struct bfd_link_info *));
43 static bfd_boolean elf_i386_create_dynamic_sections
44 PARAMS ((bfd *, struct bfd_link_info *));
45 static void elf_i386_copy_indirect_symbol
46 PARAMS ((struct elf_backend_data *, struct elf_link_hash_entry *,
47 struct elf_link_hash_entry *));
48 static int elf_i386_tls_transition
49 PARAMS ((struct bfd_link_info *, int, int));
51 static bfd_boolean elf_i386_mkobject
53 static bfd_boolean elf_i386_object_p
55 static bfd_boolean elf_i386_check_relocs
56 PARAMS ((bfd *, struct bfd_link_info *, asection *,
57 const Elf_Internal_Rela *));
58 static asection *elf_i386_gc_mark_hook
59 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
60 struct elf_link_hash_entry *, Elf_Internal_Sym *));
61 static bfd_boolean elf_i386_gc_sweep_hook
62 PARAMS ((bfd *, struct bfd_link_info *, asection *,
63 const Elf_Internal_Rela *));
64 static bfd_boolean elf_i386_adjust_dynamic_symbol
65 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
66 static bfd_boolean allocate_dynrelocs
67 PARAMS ((struct elf_link_hash_entry *, PTR));
68 static bfd_boolean readonly_dynrelocs
69 PARAMS ((struct elf_link_hash_entry *, PTR));
70 static bfd_boolean elf_i386_fake_sections
71 PARAMS ((bfd *, Elf_Internal_Shdr *, asection *));
72 static bfd_boolean elf_i386_size_dynamic_sections
73 PARAMS ((bfd *, struct bfd_link_info *));
74 static bfd_vma dtpoff_base
75 PARAMS ((struct bfd_link_info *));
77 PARAMS ((struct bfd_link_info *, bfd_vma));
78 static bfd_boolean elf_i386_relocate_section
79 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
80 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
81 static bfd_boolean elf_i386_finish_dynamic_symbol
82 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
84 static enum elf_reloc_type_class elf_i386_reloc_type_class
85 PARAMS ((const Elf_Internal_Rela *));
86 static bfd_boolean elf_i386_finish_dynamic_sections
87 PARAMS ((bfd *, struct bfd_link_info *));
89 #define USE_REL 1 /* 386 uses REL relocations instead of RELA. */
93 static reloc_howto_type elf_howto_table[]=
95 HOWTO(R_386_NONE, 0, 0, 0, FALSE, 0, complain_overflow_bitfield,
96 bfd_elf_generic_reloc, "R_386_NONE",
97 TRUE, 0x00000000, 0x00000000, FALSE),
98 HOWTO(R_386_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
99 bfd_elf_generic_reloc, "R_386_32",
100 TRUE, 0xffffffff, 0xffffffff, FALSE),
101 HOWTO(R_386_PC32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
102 bfd_elf_generic_reloc, "R_386_PC32",
103 TRUE, 0xffffffff, 0xffffffff, TRUE),
104 HOWTO(R_386_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
105 bfd_elf_generic_reloc, "R_386_GOT32",
106 TRUE, 0xffffffff, 0xffffffff, FALSE),
107 HOWTO(R_386_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
108 bfd_elf_generic_reloc, "R_386_PLT32",
109 TRUE, 0xffffffff, 0xffffffff, TRUE),
110 HOWTO(R_386_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
111 bfd_elf_generic_reloc, "R_386_COPY",
112 TRUE, 0xffffffff, 0xffffffff, FALSE),
113 HOWTO(R_386_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
114 bfd_elf_generic_reloc, "R_386_GLOB_DAT",
115 TRUE, 0xffffffff, 0xffffffff, FALSE),
116 HOWTO(R_386_JUMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
117 bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
118 TRUE, 0xffffffff, 0xffffffff, FALSE),
119 HOWTO(R_386_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
120 bfd_elf_generic_reloc, "R_386_RELATIVE",
121 TRUE, 0xffffffff, 0xffffffff, FALSE),
122 HOWTO(R_386_GOTOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
123 bfd_elf_generic_reloc, "R_386_GOTOFF",
124 TRUE, 0xffffffff, 0xffffffff, FALSE),
125 HOWTO(R_386_GOTPC, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
126 bfd_elf_generic_reloc, "R_386_GOTPC",
127 TRUE, 0xffffffff, 0xffffffff, TRUE),
129 /* We have a gap in the reloc numbers here.
130 R_386_standard counts the number up to this point, and
131 R_386_ext_offset is the value to subtract from a reloc type of
132 R_386_16 thru R_386_PC8 to form an index into this table. */
133 #define R_386_standard ((unsigned int) R_386_GOTPC + 1)
134 #define R_386_ext_offset ((unsigned int) R_386_TLS_TPOFF - R_386_standard)
136 /* These relocs are a GNU extension. */
137 HOWTO(R_386_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
138 bfd_elf_generic_reloc, "R_386_TLS_TPOFF",
139 TRUE, 0xffffffff, 0xffffffff, FALSE),
140 HOWTO(R_386_TLS_IE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
141 bfd_elf_generic_reloc, "R_386_TLS_IE",
142 TRUE, 0xffffffff, 0xffffffff, FALSE),
143 HOWTO(R_386_TLS_GOTIE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
144 bfd_elf_generic_reloc, "R_386_TLS_GOTIE",
145 TRUE, 0xffffffff, 0xffffffff, FALSE),
146 HOWTO(R_386_TLS_LE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
147 bfd_elf_generic_reloc, "R_386_TLS_LE",
148 TRUE, 0xffffffff, 0xffffffff, FALSE),
149 HOWTO(R_386_TLS_GD, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
150 bfd_elf_generic_reloc, "R_386_TLS_GD",
151 TRUE, 0xffffffff, 0xffffffff, FALSE),
152 HOWTO(R_386_TLS_LDM, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
153 bfd_elf_generic_reloc, "R_386_TLS_LDM",
154 TRUE, 0xffffffff, 0xffffffff, FALSE),
155 HOWTO(R_386_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
156 bfd_elf_generic_reloc, "R_386_16",
157 TRUE, 0xffff, 0xffff, FALSE),
158 HOWTO(R_386_PC16, 0, 1, 16, TRUE, 0, complain_overflow_bitfield,
159 bfd_elf_generic_reloc, "R_386_PC16",
160 TRUE, 0xffff, 0xffff, TRUE),
161 HOWTO(R_386_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
162 bfd_elf_generic_reloc, "R_386_8",
163 TRUE, 0xff, 0xff, FALSE),
164 HOWTO(R_386_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
165 bfd_elf_generic_reloc, "R_386_PC8",
166 TRUE, 0xff, 0xff, TRUE),
168 #define R_386_ext ((unsigned int) R_386_PC8 + 1 - R_386_ext_offset)
169 #define R_386_tls_offset ((unsigned int) R_386_TLS_LDO_32 - R_386_ext)
170 /* These are common with Solaris TLS implementation. */
171 HOWTO(R_386_TLS_LDO_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
172 bfd_elf_generic_reloc, "R_386_TLS_LDO_32",
173 TRUE, 0xffffffff, 0xffffffff, FALSE),
174 HOWTO(R_386_TLS_IE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
175 bfd_elf_generic_reloc, "R_386_TLS_IE_32",
176 TRUE, 0xffffffff, 0xffffffff, FALSE),
177 HOWTO(R_386_TLS_LE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
178 bfd_elf_generic_reloc, "R_386_TLS_LE_32",
179 TRUE, 0xffffffff, 0xffffffff, FALSE),
180 HOWTO(R_386_TLS_DTPMOD32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
181 bfd_elf_generic_reloc, "R_386_TLS_DTPMOD32",
182 TRUE, 0xffffffff, 0xffffffff, FALSE),
183 HOWTO(R_386_TLS_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
184 bfd_elf_generic_reloc, "R_386_TLS_DTPOFF32",
185 TRUE, 0xffffffff, 0xffffffff, FALSE),
186 HOWTO(R_386_TLS_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
187 bfd_elf_generic_reloc, "R_386_TLS_TPOFF32",
188 TRUE, 0xffffffff, 0xffffffff, FALSE),
191 #define R_386_tls ((unsigned int) R_386_TLS_TPOFF32 + 1 - R_386_tls_offset)
192 #define R_386_vt_offset ((unsigned int) R_386_GNU_VTINHERIT - R_386_tls)
194 /* GNU extension to record C++ vtable hierarchy. */
195 HOWTO (R_386_GNU_VTINHERIT, /* type */
197 2, /* size (0 = byte, 1 = short, 2 = long) */
199 FALSE, /* pc_relative */
201 complain_overflow_dont, /* complain_on_overflow */
202 NULL, /* special_function */
203 "R_386_GNU_VTINHERIT", /* name */
204 FALSE, /* partial_inplace */
207 FALSE), /* pcrel_offset */
209 /* GNU extension to record C++ vtable member usage. */
210 HOWTO (R_386_GNU_VTENTRY, /* type */
212 2, /* size (0 = byte, 1 = short, 2 = long) */
214 FALSE, /* pc_relative */
216 complain_overflow_dont, /* complain_on_overflow */
217 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
218 "R_386_GNU_VTENTRY", /* name */
219 FALSE, /* partial_inplace */
222 FALSE) /* pcrel_offset */
224 #define R_386_vt ((unsigned int) R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
228 #ifdef DEBUG_GEN_RELOC
229 #define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
234 static reloc_howto_type *
235 elf_i386_reloc_type_lookup (abfd, code)
236 bfd *abfd ATTRIBUTE_UNUSED;
237 bfd_reloc_code_real_type code;
242 TRACE ("BFD_RELOC_NONE");
243 return &elf_howto_table[(unsigned int) R_386_NONE ];
246 TRACE ("BFD_RELOC_32");
247 return &elf_howto_table[(unsigned int) R_386_32 ];
250 TRACE ("BFD_RELOC_CTOR");
251 return &elf_howto_table[(unsigned int) R_386_32 ];
253 case BFD_RELOC_32_PCREL:
254 TRACE ("BFD_RELOC_PC32");
255 return &elf_howto_table[(unsigned int) R_386_PC32 ];
257 case BFD_RELOC_386_GOT32:
258 TRACE ("BFD_RELOC_386_GOT32");
259 return &elf_howto_table[(unsigned int) R_386_GOT32 ];
261 case BFD_RELOC_386_PLT32:
262 TRACE ("BFD_RELOC_386_PLT32");
263 return &elf_howto_table[(unsigned int) R_386_PLT32 ];
265 case BFD_RELOC_386_COPY:
266 TRACE ("BFD_RELOC_386_COPY");
267 return &elf_howto_table[(unsigned int) R_386_COPY ];
269 case BFD_RELOC_386_GLOB_DAT:
270 TRACE ("BFD_RELOC_386_GLOB_DAT");
271 return &elf_howto_table[(unsigned int) R_386_GLOB_DAT ];
273 case BFD_RELOC_386_JUMP_SLOT:
274 TRACE ("BFD_RELOC_386_JUMP_SLOT");
275 return &elf_howto_table[(unsigned int) R_386_JUMP_SLOT ];
277 case BFD_RELOC_386_RELATIVE:
278 TRACE ("BFD_RELOC_386_RELATIVE");
279 return &elf_howto_table[(unsigned int) R_386_RELATIVE ];
281 case BFD_RELOC_386_GOTOFF:
282 TRACE ("BFD_RELOC_386_GOTOFF");
283 return &elf_howto_table[(unsigned int) R_386_GOTOFF ];
285 case BFD_RELOC_386_GOTPC:
286 TRACE ("BFD_RELOC_386_GOTPC");
287 return &elf_howto_table[(unsigned int) R_386_GOTPC ];
289 /* These relocs are a GNU extension. */
290 case BFD_RELOC_386_TLS_TPOFF:
291 TRACE ("BFD_RELOC_386_TLS_TPOFF");
292 return &elf_howto_table[(unsigned int) R_386_TLS_TPOFF - R_386_ext_offset];
294 case BFD_RELOC_386_TLS_IE:
295 TRACE ("BFD_RELOC_386_TLS_IE");
296 return &elf_howto_table[(unsigned int) R_386_TLS_IE - R_386_ext_offset];
298 case BFD_RELOC_386_TLS_GOTIE:
299 TRACE ("BFD_RELOC_386_TLS_GOTIE");
300 return &elf_howto_table[(unsigned int) R_386_TLS_GOTIE - R_386_ext_offset];
302 case BFD_RELOC_386_TLS_LE:
303 TRACE ("BFD_RELOC_386_TLS_LE");
304 return &elf_howto_table[(unsigned int) R_386_TLS_LE - R_386_ext_offset];
306 case BFD_RELOC_386_TLS_GD:
307 TRACE ("BFD_RELOC_386_TLS_GD");
308 return &elf_howto_table[(unsigned int) R_386_TLS_GD - R_386_ext_offset];
310 case BFD_RELOC_386_TLS_LDM:
311 TRACE ("BFD_RELOC_386_TLS_LDM");
312 return &elf_howto_table[(unsigned int) R_386_TLS_LDM - R_386_ext_offset];
315 TRACE ("BFD_RELOC_16");
316 return &elf_howto_table[(unsigned int) R_386_16 - R_386_ext_offset];
318 case BFD_RELOC_16_PCREL:
319 TRACE ("BFD_RELOC_16_PCREL");
320 return &elf_howto_table[(unsigned int) R_386_PC16 - R_386_ext_offset];
323 TRACE ("BFD_RELOC_8");
324 return &elf_howto_table[(unsigned int) R_386_8 - R_386_ext_offset];
326 case BFD_RELOC_8_PCREL:
327 TRACE ("BFD_RELOC_8_PCREL");
328 return &elf_howto_table[(unsigned int) R_386_PC8 - R_386_ext_offset];
330 /* Common with Sun TLS implementation. */
331 case BFD_RELOC_386_TLS_LDO_32:
332 TRACE ("BFD_RELOC_386_TLS_LDO_32");
333 return &elf_howto_table[(unsigned int) R_386_TLS_LDO_32 - R_386_tls_offset];
335 case BFD_RELOC_386_TLS_IE_32:
336 TRACE ("BFD_RELOC_386_TLS_IE_32");
337 return &elf_howto_table[(unsigned int) R_386_TLS_IE_32 - R_386_tls_offset];
339 case BFD_RELOC_386_TLS_LE_32:
340 TRACE ("BFD_RELOC_386_TLS_LE_32");
341 return &elf_howto_table[(unsigned int) R_386_TLS_LE_32 - R_386_tls_offset];
343 case BFD_RELOC_386_TLS_DTPMOD32:
344 TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
345 return &elf_howto_table[(unsigned int) R_386_TLS_DTPMOD32 - R_386_tls_offset];
347 case BFD_RELOC_386_TLS_DTPOFF32:
348 TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
349 return &elf_howto_table[(unsigned int) R_386_TLS_DTPOFF32 - R_386_tls_offset];
351 case BFD_RELOC_386_TLS_TPOFF32:
352 TRACE ("BFD_RELOC_386_TLS_TPOFF32");
353 return &elf_howto_table[(unsigned int) R_386_TLS_TPOFF32 - R_386_tls_offset];
355 case BFD_RELOC_VTABLE_INHERIT:
356 TRACE ("BFD_RELOC_VTABLE_INHERIT");
357 return &elf_howto_table[(unsigned int) R_386_GNU_VTINHERIT
360 case BFD_RELOC_VTABLE_ENTRY:
361 TRACE ("BFD_RELOC_VTABLE_ENTRY");
362 return &elf_howto_table[(unsigned int) R_386_GNU_VTENTRY
374 elf_i386_info_to_howto_rel (abfd, cache_ptr, dst)
375 bfd *abfd ATTRIBUTE_UNUSED;
377 Elf_Internal_Rela *dst;
379 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
382 if ((indx = r_type) >= R_386_standard
383 && ((indx = r_type - R_386_ext_offset) - R_386_standard
384 >= R_386_ext - R_386_standard)
385 && ((indx = r_type - R_386_tls_offset) - R_386_ext
386 >= R_386_tls - R_386_ext)
387 && ((indx = r_type - R_386_vt_offset) - R_386_tls
388 >= R_386_vt - R_386_tls))
390 (*_bfd_error_handler) (_("%s: invalid relocation type %d"),
391 bfd_archive_filename (abfd), (int) r_type);
392 indx = (unsigned int) R_386_NONE;
394 cache_ptr->howto = &elf_howto_table[indx];
397 /* Return whether a symbol name implies a local label. The UnixWare
398 2.1 cc generates temporary symbols that start with .X, so we
399 recognize them here. FIXME: do other SVR4 compilers also use .X?.
400 If so, we should move the .X recognition into
401 _bfd_elf_is_local_label_name. */
404 elf_i386_is_local_label_name (abfd, name)
408 if (name[0] == '.' && name[1] == 'X')
411 return _bfd_elf_is_local_label_name (abfd, name);
414 /* Support for core dump NOTE sections. */
416 elf_i386_grok_prstatus (abfd, note)
418 Elf_Internal_Note *note;
423 switch (note->descsz)
428 case 144: /* Linux/i386 */
430 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
433 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
442 /* Make a ".reg/999" section. */
443 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
444 raw_size, note->descpos + offset);
448 elf_i386_grok_psinfo (abfd, note)
450 Elf_Internal_Note *note;
452 switch (note->descsz)
457 case 124: /* Linux/i386 elf_prpsinfo */
458 elf_tdata (abfd)->core_program
459 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
460 elf_tdata (abfd)->core_command
461 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
464 /* Note that for some reason, a spurious space is tacked
465 onto the end of the args in some (at least one anyway)
466 implementations, so strip it off if it exists. */
469 char *command = elf_tdata (abfd)->core_command;
470 int n = strlen (command);
472 if (0 < n && command[n - 1] == ' ')
473 command[n - 1] = '\0';
479 /* Functions for the i386 ELF linker.
481 In order to gain some understanding of code in this file without
482 knowing all the intricate details of the linker, note the
485 Functions named elf_i386_* are called by external routines, other
486 functions are only called locally. elf_i386_* functions appear
487 in this file more or less in the order in which they are called
488 from external routines. eg. elf_i386_check_relocs is called
489 early in the link process, elf_i386_finish_dynamic_sections is
490 one of the last functions. */
493 /* The name of the dynamic interpreter. This is put in the .interp
496 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
498 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
499 copying dynamic variables from a shared lib into an app's dynbss
500 section, and instead use a dynamic relocation to point into the
502 #define ELIMINATE_COPY_RELOCS 1
504 /* The size in bytes of an entry in the procedure linkage table. */
506 #define PLT_ENTRY_SIZE 16
508 /* The first entry in an absolute procedure linkage table looks like
509 this. See the SVR4 ABI i386 supplement to see how this works. */
511 static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] =
513 0xff, 0x35, /* pushl contents of address */
514 0, 0, 0, 0, /* replaced with address of .got + 4. */
515 0xff, 0x25, /* jmp indirect */
516 0, 0, 0, 0, /* replaced with address of .got + 8. */
517 0, 0, 0, 0 /* pad out to 16 bytes. */
520 /* Subsequent entries in an absolute procedure linkage table look like
523 static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
525 0xff, 0x25, /* jmp indirect */
526 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
527 0x68, /* pushl immediate */
528 0, 0, 0, 0, /* replaced with offset into relocation table. */
529 0xe9, /* jmp relative */
530 0, 0, 0, 0 /* replaced with offset to start of .plt. */
533 /* The first entry in a PIC procedure linkage table look like this. */
535 static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] =
537 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
538 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
539 0, 0, 0, 0 /* pad out to 16 bytes. */
542 /* Subsequent entries in a PIC procedure linkage table look like this. */
544 static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
546 0xff, 0xa3, /* jmp *offset(%ebx) */
547 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
548 0x68, /* pushl immediate */
549 0, 0, 0, 0, /* replaced with offset into relocation table. */
550 0xe9, /* jmp relative */
551 0, 0, 0, 0 /* replaced with offset to start of .plt. */
554 /* The i386 linker needs to keep track of the number of relocs that it
555 decides to copy as dynamic relocs in check_relocs for each symbol.
556 This is so that it can later discard them if they are found to be
557 unnecessary. We store the information in a field extending the
558 regular ELF linker hash table. */
560 struct elf_i386_dyn_relocs
562 struct elf_i386_dyn_relocs *next;
564 /* The input section of the reloc. */
567 /* Total number of relocs copied for the input section. */
570 /* Number of pc-relative relocs copied for the input section. */
571 bfd_size_type pc_count;
574 /* i386 ELF linker hash entry. */
576 struct elf_i386_link_hash_entry
578 struct elf_link_hash_entry elf;
580 /* Track dynamic relocs copied for this symbol. */
581 struct elf_i386_dyn_relocs *dyn_relocs;
583 #define GOT_UNKNOWN 0
587 #define GOT_TLS_IE_POS 5
588 #define GOT_TLS_IE_NEG 6
589 #define GOT_TLS_IE_BOTH 7
590 unsigned char tls_type;
593 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
595 struct elf_i386_obj_tdata
597 struct elf_obj_tdata root;
599 /* tls_type for each local got entry. */
600 char *local_got_tls_type;
603 #define elf_i386_tdata(abfd) \
604 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
606 #define elf_i386_local_got_tls_type(abfd) \
607 (elf_i386_tdata (abfd)->local_got_tls_type)
610 elf_i386_mkobject (abfd)
613 bfd_size_type amt = sizeof (struct elf_i386_obj_tdata);
614 abfd->tdata.any = bfd_zalloc (abfd, amt);
615 if (abfd->tdata.any == NULL)
621 elf_i386_object_p (abfd)
624 /* Allocate our special target data. */
625 struct elf_i386_obj_tdata *new_tdata;
626 bfd_size_type amt = sizeof (struct elf_i386_obj_tdata);
627 new_tdata = bfd_zalloc (abfd, amt);
628 if (new_tdata == NULL)
630 new_tdata->root = *abfd->tdata.elf_obj_data;
631 abfd->tdata.any = new_tdata;
635 /* i386 ELF linker hash table. */
637 struct elf_i386_link_hash_table
639 struct elf_link_hash_table elf;
641 /* Short-cuts to get to dynamic linker sections. */
651 bfd_signed_vma refcount;
655 /* Small local sym to section mapping cache. */
656 struct sym_sec_cache sym_sec;
659 /* Get the i386 ELF linker hash table from a link_info structure. */
661 #define elf_i386_hash_table(p) \
662 ((struct elf_i386_link_hash_table *) ((p)->hash))
664 /* Create an entry in an i386 ELF linker hash table. */
666 static struct bfd_hash_entry *
667 link_hash_newfunc (entry, table, string)
668 struct bfd_hash_entry *entry;
669 struct bfd_hash_table *table;
672 /* Allocate the structure if it has not already been allocated by a
676 entry = bfd_hash_allocate (table,
677 sizeof (struct elf_i386_link_hash_entry));
682 /* Call the allocation method of the superclass. */
683 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
686 struct elf_i386_link_hash_entry *eh;
688 eh = (struct elf_i386_link_hash_entry *) entry;
689 eh->dyn_relocs = NULL;
690 eh->tls_type = GOT_UNKNOWN;
696 /* Create an i386 ELF linker hash table. */
698 static struct bfd_link_hash_table *
699 elf_i386_link_hash_table_create (abfd)
702 struct elf_i386_link_hash_table *ret;
703 bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
705 ret = (struct elf_i386_link_hash_table *) bfd_malloc (amt);
709 if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc))
722 ret->tls_ldm_got.refcount = 0;
723 ret->sym_sec.abfd = NULL;
725 return &ret->elf.root;
728 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
729 shortcuts to them in our hash table. */
732 create_got_section (dynobj, info)
734 struct bfd_link_info *info;
736 struct elf_i386_link_hash_table *htab;
738 if (! _bfd_elf_create_got_section (dynobj, info))
741 htab = elf_i386_hash_table (info);
742 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
743 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
744 if (!htab->sgot || !htab->sgotplt)
747 htab->srelgot = bfd_make_section (dynobj, ".rel.got");
748 if (htab->srelgot == NULL
749 || ! bfd_set_section_flags (dynobj, htab->srelgot,
750 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
751 | SEC_IN_MEMORY | SEC_LINKER_CREATED
753 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
758 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
759 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
763 elf_i386_create_dynamic_sections (dynobj, info)
765 struct bfd_link_info *info;
767 struct elf_i386_link_hash_table *htab;
769 htab = elf_i386_hash_table (info);
770 if (!htab->sgot && !create_got_section (dynobj, info))
773 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
776 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
777 htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
778 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
780 htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
782 if (!htab->splt || !htab->srelplt || !htab->sdynbss
783 || (!info->shared && !htab->srelbss))
789 /* Copy the extra info we tack onto an elf_link_hash_entry. */
792 elf_i386_copy_indirect_symbol (bed, dir, ind)
793 struct elf_backend_data *bed;
794 struct elf_link_hash_entry *dir, *ind;
796 struct elf_i386_link_hash_entry *edir, *eind;
798 edir = (struct elf_i386_link_hash_entry *) dir;
799 eind = (struct elf_i386_link_hash_entry *) ind;
801 if (eind->dyn_relocs != NULL)
803 if (edir->dyn_relocs != NULL)
805 struct elf_i386_dyn_relocs **pp;
806 struct elf_i386_dyn_relocs *p;
808 if (ind->root.type == bfd_link_hash_indirect)
811 /* Add reloc counts against the weak sym to the strong sym
812 list. Merge any entries against the same section. */
813 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
815 struct elf_i386_dyn_relocs *q;
817 for (q = edir->dyn_relocs; q != NULL; q = q->next)
818 if (q->sec == p->sec)
820 q->pc_count += p->pc_count;
821 q->count += p->count;
828 *pp = edir->dyn_relocs;
831 edir->dyn_relocs = eind->dyn_relocs;
832 eind->dyn_relocs = NULL;
835 if (ind->root.type == bfd_link_hash_indirect
836 && dir->got.refcount <= 0)
838 edir->tls_type = eind->tls_type;
839 eind->tls_type = GOT_UNKNOWN;
842 if (ELIMINATE_COPY_RELOCS
843 && ind->root.type != bfd_link_hash_indirect
844 && (dir->elf_link_hash_flags & ELF_LINK_HASH_DYNAMIC_ADJUSTED) != 0)
845 /* If called to transfer flags for a weakdef during processing
846 of elf_adjust_dynamic_symbol, don't copy ELF_LINK_NON_GOT_REF.
847 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
848 dir->elf_link_hash_flags |=
849 (ind->elf_link_hash_flags & (ELF_LINK_HASH_REF_DYNAMIC
850 | ELF_LINK_HASH_REF_REGULAR
851 | ELF_LINK_HASH_REF_REGULAR_NONWEAK));
853 _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
857 elf_i386_tls_transition (info, r_type, is_local)
858 struct bfd_link_info *info;
868 case R_386_TLS_IE_32:
870 return R_386_TLS_LE_32;
871 return R_386_TLS_IE_32;
873 case R_386_TLS_GOTIE:
875 return R_386_TLS_LE_32;
878 return R_386_TLS_LE_32;
884 /* Look through the relocs for a section during the first phase, and
885 calculate needed space in the global offset table, procedure linkage
886 table, and dynamic reloc sections. */
889 elf_i386_check_relocs (abfd, info, sec, relocs)
891 struct bfd_link_info *info;
893 const Elf_Internal_Rela *relocs;
895 struct elf_i386_link_hash_table *htab;
896 Elf_Internal_Shdr *symtab_hdr;
897 struct elf_link_hash_entry **sym_hashes;
898 const Elf_Internal_Rela *rel;
899 const Elf_Internal_Rela *rel_end;
902 if (info->relocateable)
905 htab = elf_i386_hash_table (info);
906 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
907 sym_hashes = elf_sym_hashes (abfd);
911 rel_end = relocs + sec->reloc_count;
912 for (rel = relocs; rel < rel_end; rel++)
915 unsigned long r_symndx;
916 struct elf_link_hash_entry *h;
918 r_symndx = ELF32_R_SYM (rel->r_info);
919 r_type = ELF32_R_TYPE (rel->r_info);
921 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
923 (*_bfd_error_handler) (_("%s: bad symbol index: %d"),
924 bfd_archive_filename (abfd),
929 if (r_symndx < symtab_hdr->sh_info)
932 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
934 r_type = elf_i386_tls_transition (info, r_type, h == NULL);
939 htab->tls_ldm_got.refcount += 1;
943 /* This symbol requires a procedure linkage table entry. We
944 actually build the entry in adjust_dynamic_symbol,
945 because this might be a case of linking PIC code which is
946 never referenced by a dynamic object, in which case we
947 don't need to generate a procedure linkage table entry
950 /* If this is a local symbol, we resolve it directly without
951 creating a procedure linkage table entry. */
955 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
956 h->plt.refcount += 1;
959 case R_386_TLS_IE_32:
961 case R_386_TLS_GOTIE:
963 info->flags |= DF_STATIC_TLS;
968 /* This symbol requires a global offset table entry. */
970 int tls_type, old_tls_type;
975 case R_386_GOT32: tls_type = GOT_NORMAL; break;
976 case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
977 case R_386_TLS_IE_32:
978 if (ELF32_R_TYPE (rel->r_info) == r_type)
979 tls_type = GOT_TLS_IE_NEG;
981 /* If this is a GD->IE transition, we may use either of
982 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
983 tls_type = GOT_TLS_IE;
986 case R_386_TLS_GOTIE:
987 tls_type = GOT_TLS_IE_POS; break;
992 h->got.refcount += 1;
993 old_tls_type = elf_i386_hash_entry(h)->tls_type;
997 bfd_signed_vma *local_got_refcounts;
999 /* This is a global offset table entry for a local symbol. */
1000 local_got_refcounts = elf_local_got_refcounts (abfd);
1001 if (local_got_refcounts == NULL)
1005 size = symtab_hdr->sh_info;
1006 size *= (sizeof (bfd_signed_vma) + sizeof(char));
1007 local_got_refcounts = ((bfd_signed_vma *)
1008 bfd_zalloc (abfd, size));
1009 if (local_got_refcounts == NULL)
1011 elf_local_got_refcounts (abfd) = local_got_refcounts;
1012 elf_i386_local_got_tls_type (abfd)
1013 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
1015 local_got_refcounts[r_symndx] += 1;
1016 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
1019 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1020 tls_type |= old_tls_type;
1021 /* If a TLS symbol is accessed using IE at least once,
1022 there is no point to use dynamic model for it. */
1023 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1024 && (old_tls_type != GOT_TLS_GD
1025 || (tls_type & GOT_TLS_IE) == 0))
1027 if ((old_tls_type & GOT_TLS_IE) && tls_type == GOT_TLS_GD)
1028 tls_type = old_tls_type;
1031 (*_bfd_error_handler)
1032 (_("%s: `%s' accessed both as normal and thread local symbol"),
1033 bfd_archive_filename (abfd),
1034 h ? h->root.root.string : "<local>");
1039 if (old_tls_type != tls_type)
1042 elf_i386_hash_entry (h)->tls_type = tls_type;
1044 elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
1052 if (htab->sgot == NULL)
1054 if (htab->elf.dynobj == NULL)
1055 htab->elf.dynobj = abfd;
1056 if (!create_got_section (htab->elf.dynobj, info))
1059 if (r_type != R_386_TLS_IE)
1063 case R_386_TLS_LE_32:
1067 info->flags |= DF_STATIC_TLS;
1072 if (h != NULL && !info->shared)
1074 /* If this reloc is in a read-only section, we might
1075 need a copy reloc. We can't check reliably at this
1076 stage whether the section is read-only, as input
1077 sections have not yet been mapped to output sections.
1078 Tentatively set the flag for now, and correct in
1079 adjust_dynamic_symbol. */
1080 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
1082 /* We may need a .plt entry if the function this reloc
1083 refers to is in a shared lib. */
1084 h->plt.refcount += 1;
1087 /* If we are creating a shared library, and this is a reloc
1088 against a global symbol, or a non PC relative reloc
1089 against a local symbol, then we need to copy the reloc
1090 into the shared library. However, if we are linking with
1091 -Bsymbolic, we do not need to copy a reloc against a
1092 global symbol which is defined in an object we are
1093 including in the link (i.e., DEF_REGULAR is set). At
1094 this point we have not seen all the input files, so it is
1095 possible that DEF_REGULAR is not set now but will be set
1096 later (it is never cleared). In case of a weak definition,
1097 DEF_REGULAR may be cleared later by a strong definition in
1098 a shared library. We account for that possibility below by
1099 storing information in the relocs_copied field of the hash
1100 table entry. A similar situation occurs when creating
1101 shared libraries and symbol visibility changes render the
1104 If on the other hand, we are creating an executable, we
1105 may need to keep relocations for symbols satisfied by a
1106 dynamic library if we manage to avoid copy relocs for the
1109 && (sec->flags & SEC_ALLOC) != 0
1110 && (r_type != R_386_PC32
1112 && (! info->symbolic
1113 || h->root.type == bfd_link_hash_defweak
1114 || (h->elf_link_hash_flags
1115 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1116 || (ELIMINATE_COPY_RELOCS
1118 && (sec->flags & SEC_ALLOC) != 0
1120 && (h->root.type == bfd_link_hash_defweak
1121 || (h->elf_link_hash_flags
1122 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
1124 struct elf_i386_dyn_relocs *p;
1125 struct elf_i386_dyn_relocs **head;
1127 /* We must copy these reloc types into the output file.
1128 Create a reloc section in dynobj and make room for
1134 unsigned int strndx = elf_elfheader (abfd)->e_shstrndx;
1135 unsigned int shnam = elf_section_data (sec)->rel_hdr.sh_name;
1137 name = bfd_elf_string_from_elf_section (abfd, strndx, shnam);
1141 if (strncmp (name, ".rel", 4) != 0
1142 || strcmp (bfd_get_section_name (abfd, sec),
1145 (*_bfd_error_handler)
1146 (_("%s: bad relocation section name `%s\'"),
1147 bfd_archive_filename (abfd), name);
1150 if (htab->elf.dynobj == NULL)
1151 htab->elf.dynobj = abfd;
1153 dynobj = htab->elf.dynobj;
1154 sreloc = bfd_get_section_by_name (dynobj, name);
1159 sreloc = bfd_make_section (dynobj, name);
1160 flags = (SEC_HAS_CONTENTS | SEC_READONLY
1161 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1162 if ((sec->flags & SEC_ALLOC) != 0)
1163 flags |= SEC_ALLOC | SEC_LOAD;
1165 || ! bfd_set_section_flags (dynobj, sreloc, flags)
1166 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
1169 elf_section_data (sec)->sreloc = sreloc;
1172 /* If this is a global symbol, we count the number of
1173 relocations we need for this symbol. */
1176 head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs;
1180 /* Track dynamic relocs needed for local syms too.
1181 We really need local syms available to do this
1185 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1190 head = ((struct elf_i386_dyn_relocs **)
1191 &elf_section_data (s)->local_dynrel);
1195 if (p == NULL || p->sec != sec)
1197 bfd_size_type amt = sizeof *p;
1198 p = ((struct elf_i386_dyn_relocs *)
1199 bfd_alloc (htab->elf.dynobj, amt));
1210 if (r_type == R_386_PC32)
1215 /* This relocation describes the C++ object vtable hierarchy.
1216 Reconstruct it for later use during GC. */
1217 case R_386_GNU_VTINHERIT:
1218 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1222 /* This relocation describes which C++ vtable entries are actually
1223 used. Record for later use during GC. */
1224 case R_386_GNU_VTENTRY:
1225 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
1237 /* Return the section that should be marked against GC for a given
1241 elf_i386_gc_mark_hook (sec, info, rel, h, sym)
1243 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1244 Elf_Internal_Rela *rel;
1245 struct elf_link_hash_entry *h;
1246 Elf_Internal_Sym *sym;
1250 switch (ELF32_R_TYPE (rel->r_info))
1252 case R_386_GNU_VTINHERIT:
1253 case R_386_GNU_VTENTRY:
1257 switch (h->root.type)
1259 case bfd_link_hash_defined:
1260 case bfd_link_hash_defweak:
1261 return h->root.u.def.section;
1263 case bfd_link_hash_common:
1264 return h->root.u.c.p->section;
1272 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1277 /* Update the got entry reference counts for the section being removed. */
1280 elf_i386_gc_sweep_hook (abfd, info, sec, relocs)
1282 struct bfd_link_info *info;
1284 const Elf_Internal_Rela *relocs;
1286 Elf_Internal_Shdr *symtab_hdr;
1287 struct elf_link_hash_entry **sym_hashes;
1288 bfd_signed_vma *local_got_refcounts;
1289 const Elf_Internal_Rela *rel, *relend;
1291 elf_section_data (sec)->local_dynrel = NULL;
1293 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1294 sym_hashes = elf_sym_hashes (abfd);
1295 local_got_refcounts = elf_local_got_refcounts (abfd);
1297 relend = relocs + sec->reloc_count;
1298 for (rel = relocs; rel < relend; rel++)
1300 unsigned long r_symndx;
1301 unsigned int r_type;
1302 struct elf_link_hash_entry *h = NULL;
1304 r_symndx = ELF32_R_SYM (rel->r_info);
1305 if (r_symndx >= symtab_hdr->sh_info)
1307 struct elf_i386_link_hash_entry *eh;
1308 struct elf_i386_dyn_relocs **pp;
1309 struct elf_i386_dyn_relocs *p;
1311 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1312 eh = (struct elf_i386_link_hash_entry *) h;
1314 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1317 /* Everything must go for SEC. */
1323 r_type = ELF32_R_TYPE (rel->r_info);
1324 r_type = elf_i386_tls_transition (info, r_type, h != NULL);
1328 if (elf_i386_hash_table (info)->tls_ldm_got.refcount > 0)
1329 elf_i386_hash_table (info)->tls_ldm_got.refcount -= 1;
1333 case R_386_TLS_IE_32:
1335 case R_386_TLS_GOTIE:
1339 if (h->got.refcount > 0)
1340 h->got.refcount -= 1;
1342 else if (local_got_refcounts != NULL)
1344 if (local_got_refcounts[r_symndx] > 0)
1345 local_got_refcounts[r_symndx] -= 1;
1358 if (h->plt.refcount > 0)
1359 h->plt.refcount -= 1;
1371 /* Adjust a symbol defined by a dynamic object and referenced by a
1372 regular object. The current definition is in some section of the
1373 dynamic object, but we're not including those sections. We have to
1374 change the definition to something the rest of the link can
1378 elf_i386_adjust_dynamic_symbol (info, h)
1379 struct bfd_link_info *info;
1380 struct elf_link_hash_entry *h;
1382 struct elf_i386_link_hash_table *htab;
1384 unsigned int power_of_two;
1386 /* If this is a function, put it in the procedure linkage table. We
1387 will fill in the contents of the procedure linkage table later,
1388 when we know the address of the .got section. */
1389 if (h->type == STT_FUNC
1390 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
1392 if (h->plt.refcount <= 0
1394 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
1395 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
1396 && h->root.type != bfd_link_hash_undefweak
1397 && h->root.type != bfd_link_hash_undefined))
1399 /* This case can occur if we saw a PLT32 reloc in an input
1400 file, but the symbol was never referred to by a dynamic
1401 object, or if all references were garbage collected. In
1402 such a case, we don't actually need to build a procedure
1403 linkage table, and we can just do a PC32 reloc instead. */
1404 h->plt.offset = (bfd_vma) -1;
1405 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1411 /* It's possible that we incorrectly decided a .plt reloc was
1412 needed for an R_386_PC32 reloc to a non-function sym in
1413 check_relocs. We can't decide accurately between function and
1414 non-function syms in check-relocs; Objects loaded later in
1415 the link may change h->type. So fix it now. */
1416 h->plt.offset = (bfd_vma) -1;
1418 /* If this is a weak symbol, and there is a real definition, the
1419 processor independent code will have arranged for us to see the
1420 real definition first, and we can just use the same value. */
1421 if (h->weakdef != NULL)
1423 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1424 || h->weakdef->root.type == bfd_link_hash_defweak);
1425 h->root.u.def.section = h->weakdef->root.u.def.section;
1426 h->root.u.def.value = h->weakdef->root.u.def.value;
1427 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
1428 h->elf_link_hash_flags
1429 = ((h->elf_link_hash_flags & ~ELF_LINK_NON_GOT_REF)
1430 | (h->weakdef->elf_link_hash_flags & ELF_LINK_NON_GOT_REF));
1434 /* This is a reference to a symbol defined by a dynamic object which
1435 is not a function. */
1437 /* If we are creating a shared library, we must presume that the
1438 only references to the symbol are via the global offset table.
1439 For such cases we need not do anything here; the relocations will
1440 be handled correctly by relocate_section. */
1444 /* If there are no references to this symbol that do not use the
1445 GOT, we don't need to generate a copy reloc. */
1446 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
1449 /* If -z nocopyreloc was given, we won't generate them either. */
1450 if (info->nocopyreloc)
1452 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1456 if (ELIMINATE_COPY_RELOCS)
1458 struct elf_i386_link_hash_entry * eh;
1459 struct elf_i386_dyn_relocs *p;
1461 eh = (struct elf_i386_link_hash_entry *) h;
1462 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1464 s = p->sec->output_section;
1465 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1469 /* If we didn't find any dynamic relocs in read-only sections, then
1470 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1473 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1478 /* We must allocate the symbol in our .dynbss section, which will
1479 become part of the .bss section of the executable. There will be
1480 an entry for this symbol in the .dynsym section. The dynamic
1481 object will contain position independent code, so all references
1482 from the dynamic object to this symbol will go through the global
1483 offset table. The dynamic linker will use the .dynsym entry to
1484 determine the address it must put in the global offset table, so
1485 both the dynamic object and the regular object will refer to the
1486 same memory location for the variable. */
1488 htab = elf_i386_hash_table (info);
1490 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
1491 copy the initial value out of the dynamic object and into the
1492 runtime process image. */
1493 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1495 htab->srelbss->_raw_size += sizeof (Elf32_External_Rel);
1496 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1499 /* We need to figure out the alignment required for this symbol. I
1500 have no idea how ELF linkers handle this. */
1501 power_of_two = bfd_log2 (h->size);
1502 if (power_of_two > 3)
1505 /* Apply the required alignment. */
1507 s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
1508 if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
1510 if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
1514 /* Define the symbol as being at this point in the section. */
1515 h->root.u.def.section = s;
1516 h->root.u.def.value = s->_raw_size;
1518 /* Increment the section size to make room for the symbol. */
1519 s->_raw_size += h->size;
1524 /* This is the condition under which elf_i386_finish_dynamic_symbol
1525 will be called from elflink.h. If elflink.h doesn't call our
1526 finish_dynamic_symbol routine, we'll need to do something about
1527 initializing any .plt and .got entries in elf_i386_relocate_section. */
1528 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, SHARED, H) \
1531 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1532 && ((H)->dynindx != -1 \
1533 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1535 /* Allocate space in .plt, .got and associated reloc sections for
1539 allocate_dynrelocs (h, inf)
1540 struct elf_link_hash_entry *h;
1543 struct bfd_link_info *info;
1544 struct elf_i386_link_hash_table *htab;
1545 struct elf_i386_link_hash_entry *eh;
1546 struct elf_i386_dyn_relocs *p;
1548 if (h->root.type == bfd_link_hash_indirect)
1551 if (h->root.type == bfd_link_hash_warning)
1552 /* When warning symbols are created, they **replace** the "real"
1553 entry in the hash table, thus we never get to see the real
1554 symbol in a hash traversal. So look at it now. */
1555 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1557 info = (struct bfd_link_info *) inf;
1558 htab = elf_i386_hash_table (info);
1560 if (htab->elf.dynamic_sections_created
1561 && h->plt.refcount > 0)
1563 /* Make sure this symbol is output as a dynamic symbol.
1564 Undefined weak syms won't yet be marked as dynamic. */
1565 if (h->dynindx == -1
1566 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1568 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1573 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1575 asection *s = htab->splt;
1577 /* If this is the first .plt entry, make room for the special
1579 if (s->_raw_size == 0)
1580 s->_raw_size += PLT_ENTRY_SIZE;
1582 h->plt.offset = s->_raw_size;
1584 /* If this symbol is not defined in a regular file, and we are
1585 not generating a shared library, then set the symbol to this
1586 location in the .plt. This is required to make function
1587 pointers compare as equal between the normal executable and
1588 the shared library. */
1590 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1592 h->root.u.def.section = s;
1593 h->root.u.def.value = h->plt.offset;
1596 /* Make room for this entry. */
1597 s->_raw_size += PLT_ENTRY_SIZE;
1599 /* We also need to make an entry in the .got.plt section, which
1600 will be placed in the .got section by the linker script. */
1601 htab->sgotplt->_raw_size += 4;
1603 /* We also need to make an entry in the .rel.plt section. */
1604 htab->srelplt->_raw_size += sizeof (Elf32_External_Rel);
1608 h->plt.offset = (bfd_vma) -1;
1609 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1614 h->plt.offset = (bfd_vma) -1;
1615 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1618 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
1619 make it a R_386_TLS_LE_32 requiring no TLS entry. */
1620 if (h->got.refcount > 0
1623 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
1624 h->got.offset = (bfd_vma) -1;
1625 else if (h->got.refcount > 0)
1629 int tls_type = elf_i386_hash_entry(h)->tls_type;
1631 /* Make sure this symbol is output as a dynamic symbol.
1632 Undefined weak syms won't yet be marked as dynamic. */
1633 if (h->dynindx == -1
1634 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1636 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1641 h->got.offset = s->_raw_size;
1643 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
1644 if (tls_type == GOT_TLS_GD || tls_type == GOT_TLS_IE_BOTH)
1646 dyn = htab->elf.dynamic_sections_created;
1647 /* R_386_TLS_IE_32 needs one dynamic relocation,
1648 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
1649 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
1650 need two), R_386_TLS_GD needs one if local symbol and two if
1652 if (tls_type == GOT_TLS_IE_BOTH)
1653 htab->srelgot->_raw_size += 2 * sizeof (Elf32_External_Rel);
1654 else if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1655 || (tls_type & GOT_TLS_IE))
1656 htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1657 else if (tls_type == GOT_TLS_GD)
1658 htab->srelgot->_raw_size += 2 * sizeof (Elf32_External_Rel);
1659 else if (info->shared
1660 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
1661 htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1664 h->got.offset = (bfd_vma) -1;
1666 eh = (struct elf_i386_link_hash_entry *) h;
1667 if (eh->dyn_relocs == NULL)
1670 /* In the shared -Bsymbolic case, discard space allocated for
1671 dynamic pc-relative relocs against symbols which turn out to be
1672 defined in regular objects. For the normal shared case, discard
1673 space for pc-relative relocs that have become local due to symbol
1674 visibility changes. */
1678 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1679 && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1682 struct elf_i386_dyn_relocs **pp;
1684 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1686 p->count -= p->pc_count;
1695 else if (ELIMINATE_COPY_RELOCS)
1697 /* For the non-shared case, discard space for relocs against
1698 symbols which turn out to need copy relocs or are not
1701 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1702 && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1703 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1704 || (htab->elf.dynamic_sections_created
1705 && (h->root.type == bfd_link_hash_undefweak
1706 || h->root.type == bfd_link_hash_undefined))))
1708 /* Make sure this symbol is output as a dynamic symbol.
1709 Undefined weak syms won't yet be marked as dynamic. */
1710 if (h->dynindx == -1
1711 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1713 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
1717 /* If that succeeded, we know we'll be keeping all the
1719 if (h->dynindx != -1)
1723 eh->dyn_relocs = NULL;
1728 /* Finally, allocate space. */
1729 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1731 asection *sreloc = elf_section_data (p->sec)->sreloc;
1732 sreloc->_raw_size += p->count * sizeof (Elf32_External_Rel);
1738 /* Find any dynamic relocs that apply to read-only sections. */
1741 readonly_dynrelocs (h, inf)
1742 struct elf_link_hash_entry *h;
1745 struct elf_i386_link_hash_entry *eh;
1746 struct elf_i386_dyn_relocs *p;
1748 if (h->root.type == bfd_link_hash_warning)
1749 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1751 eh = (struct elf_i386_link_hash_entry *) h;
1752 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1754 asection *s = p->sec->output_section;
1756 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1758 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1760 info->flags |= DF_TEXTREL;
1762 /* Not an error, just cut short the traversal. */
1769 /* Set the sizes of the dynamic sections. */
1772 elf_i386_size_dynamic_sections (output_bfd, info)
1773 bfd *output_bfd ATTRIBUTE_UNUSED;
1774 struct bfd_link_info *info;
1776 struct elf_i386_link_hash_table *htab;
1782 htab = elf_i386_hash_table (info);
1783 dynobj = htab->elf.dynobj;
1787 if (htab->elf.dynamic_sections_created)
1789 /* Set the contents of the .interp section to the interpreter. */
1792 s = bfd_get_section_by_name (dynobj, ".interp");
1795 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1796 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1800 /* Set up .got offsets for local syms, and space for local dynamic
1802 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1804 bfd_signed_vma *local_got;
1805 bfd_signed_vma *end_local_got;
1806 char *local_tls_type;
1807 bfd_size_type locsymcount;
1808 Elf_Internal_Shdr *symtab_hdr;
1811 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1814 for (s = ibfd->sections; s != NULL; s = s->next)
1816 struct elf_i386_dyn_relocs *p;
1818 for (p = *((struct elf_i386_dyn_relocs **)
1819 &elf_section_data (s)->local_dynrel);
1823 if (!bfd_is_abs_section (p->sec)
1824 && bfd_is_abs_section (p->sec->output_section))
1826 /* Input section has been discarded, either because
1827 it is a copy of a linkonce section or due to
1828 linker script /DISCARD/, so we'll be discarding
1831 else if (p->count != 0)
1833 srel = elf_section_data (p->sec)->sreloc;
1834 srel->_raw_size += p->count * sizeof (Elf32_External_Rel);
1835 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1836 info->flags |= DF_TEXTREL;
1841 local_got = elf_local_got_refcounts (ibfd);
1845 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1846 locsymcount = symtab_hdr->sh_info;
1847 end_local_got = local_got + locsymcount;
1848 local_tls_type = elf_i386_local_got_tls_type (ibfd);
1850 srel = htab->srelgot;
1851 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
1855 *local_got = s->_raw_size;
1857 if (*local_tls_type == GOT_TLS_GD
1858 || *local_tls_type == GOT_TLS_IE_BOTH)
1861 || *local_tls_type == GOT_TLS_GD
1862 || (*local_tls_type & GOT_TLS_IE))
1864 if (*local_tls_type == GOT_TLS_IE_BOTH)
1865 srel->_raw_size += 2 * sizeof (Elf32_External_Rel);
1867 srel->_raw_size += sizeof (Elf32_External_Rel);
1871 *local_got = (bfd_vma) -1;
1875 if (htab->tls_ldm_got.refcount > 0)
1877 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
1879 htab->tls_ldm_got.offset = htab->sgot->_raw_size;
1880 htab->sgot->_raw_size += 8;
1881 htab->srelgot->_raw_size += sizeof (Elf32_External_Rel);
1884 htab->tls_ldm_got.offset = -1;
1886 /* Allocate global sym .plt and .got entries, and space for global
1887 sym dynamic relocs. */
1888 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
1890 /* We now have determined the sizes of the various dynamic sections.
1891 Allocate memory for them. */
1893 for (s = dynobj->sections; s != NULL; s = s->next)
1895 if ((s->flags & SEC_LINKER_CREATED) == 0)
1900 || s == htab->sgotplt)
1902 /* Strip this section if we don't need it; see the
1905 else if (strncmp (bfd_get_section_name (dynobj, s), ".rel", 4) == 0)
1907 if (s->_raw_size != 0 && s != htab->srelplt)
1910 /* We use the reloc_count field as a counter if we need
1911 to copy relocs into the output file. */
1916 /* It's not one of our sections, so don't allocate space. */
1920 if (s->_raw_size == 0)
1922 /* If we don't need this section, strip it from the
1923 output file. This is mostly to handle .rel.bss and
1924 .rel.plt. We must create both sections in
1925 create_dynamic_sections, because they must be created
1926 before the linker maps input sections to output
1927 sections. The linker does that before
1928 adjust_dynamic_symbol is called, and it is that
1929 function which decides whether anything needs to go
1930 into these sections. */
1932 _bfd_strip_section_from_output (info, s);
1936 /* Allocate memory for the section contents. We use bfd_zalloc
1937 here in case unused entries are not reclaimed before the
1938 section's contents are written out. This should not happen,
1939 but this way if it does, we get a R_386_NONE reloc instead
1941 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1942 if (s->contents == NULL)
1946 if (htab->elf.dynamic_sections_created)
1948 /* Add some entries to the .dynamic section. We fill in the
1949 values later, in elf_i386_finish_dynamic_sections, but we
1950 must add the entries now so that we get the correct size for
1951 the .dynamic section. The DT_DEBUG entry is filled in by the
1952 dynamic linker and used by the debugger. */
1953 #define add_dynamic_entry(TAG, VAL) \
1954 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1958 if (!add_dynamic_entry (DT_DEBUG, 0))
1962 if (htab->splt->_raw_size != 0)
1964 if (!add_dynamic_entry (DT_PLTGOT, 0)
1965 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1966 || !add_dynamic_entry (DT_PLTREL, DT_REL)
1967 || !add_dynamic_entry (DT_JMPREL, 0))
1973 if (!add_dynamic_entry (DT_REL, 0)
1974 || !add_dynamic_entry (DT_RELSZ, 0)
1975 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
1978 /* If any dynamic relocs apply to a read-only section,
1979 then we need a DT_TEXTREL entry. */
1980 if ((info->flags & DF_TEXTREL) == 0)
1981 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
1984 if ((info->flags & DF_TEXTREL) != 0)
1986 if (!add_dynamic_entry (DT_TEXTREL, 0))
1991 #undef add_dynamic_entry
1996 /* Set the correct type for an x86 ELF section. We do this by the
1997 section name, which is a hack, but ought to work. */
2000 elf_i386_fake_sections (abfd, hdr, sec)
2001 bfd *abfd ATTRIBUTE_UNUSED;
2002 Elf_Internal_Shdr *hdr;
2005 register const char *name;
2007 name = bfd_get_section_name (abfd, sec);
2009 /* This is an ugly, but unfortunately necessary hack that is
2010 needed when producing EFI binaries on x86. It tells
2011 elf.c:elf_fake_sections() not to consider ".reloc" as a section
2012 containing ELF relocation info. We need this hack in order to
2013 be able to generate ELF binaries that can be translated into
2014 EFI applications (which are essentially COFF objects). Those
2015 files contain a COFF ".reloc" section inside an ELFNN object,
2016 which would normally cause BFD to segfault because it would
2017 attempt to interpret this section as containing relocation
2018 entries for section "oc". With this hack enabled, ".reloc"
2019 will be treated as a normal data section, which will avoid the
2020 segfault. However, you won't be able to create an ELFNN binary
2021 with a section named "oc" that needs relocations, but that's
2022 the kind of ugly side-effects you get when detecting section
2023 types based on their names... In practice, this limitation is
2024 unlikely to bite. */
2025 if (strcmp (name, ".reloc") == 0)
2026 hdr->sh_type = SHT_PROGBITS;
2031 /* Return the base VMA address which should be subtracted from real addresses
2032 when resolving @dtpoff relocation.
2033 This is PT_TLS segment p_vaddr. */
2037 struct bfd_link_info *info;
2039 /* If tls_segment is NULL, we should have signalled an error already. */
2040 if (elf_hash_table (info)->tls_segment == NULL)
2042 return elf_hash_table (info)->tls_segment->start;
2045 /* Return the relocation value for @tpoff relocation
2046 if STT_TLS virtual address is ADDRESS. */
2049 tpoff (info, address)
2050 struct bfd_link_info *info;
2053 struct elf_link_tls_segment *tls_segment
2054 = elf_hash_table (info)->tls_segment;
2056 /* If tls_segment is NULL, we should have signalled an error already. */
2057 if (tls_segment == NULL)
2059 return (align_power (tls_segment->size, tls_segment->align)
2060 + tls_segment->start - address);
2063 /* Relocate an i386 ELF section. */
2066 elf_i386_relocate_section (output_bfd, info, input_bfd, input_section,
2067 contents, relocs, local_syms, local_sections)
2069 struct bfd_link_info *info;
2071 asection *input_section;
2073 Elf_Internal_Rela *relocs;
2074 Elf_Internal_Sym *local_syms;
2075 asection **local_sections;
2077 struct elf_i386_link_hash_table *htab;
2078 Elf_Internal_Shdr *symtab_hdr;
2079 struct elf_link_hash_entry **sym_hashes;
2080 bfd_vma *local_got_offsets;
2081 Elf_Internal_Rela *rel;
2082 Elf_Internal_Rela *relend;
2084 htab = elf_i386_hash_table (info);
2085 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2086 sym_hashes = elf_sym_hashes (input_bfd);
2087 local_got_offsets = elf_local_got_offsets (input_bfd);
2090 relend = relocs + input_section->reloc_count;
2091 for (; rel < relend; rel++)
2093 unsigned int r_type;
2094 reloc_howto_type *howto;
2095 unsigned long r_symndx;
2096 struct elf_link_hash_entry *h;
2097 Elf_Internal_Sym *sym;
2101 bfd_boolean unresolved_reloc;
2102 bfd_reloc_status_type r;
2106 r_type = ELF32_R_TYPE (rel->r_info);
2107 if (r_type == (int) R_386_GNU_VTINHERIT
2108 || r_type == (int) R_386_GNU_VTENTRY)
2111 if ((indx = (unsigned) r_type) >= R_386_standard
2112 && ((indx = r_type - R_386_ext_offset) - R_386_standard
2113 >= R_386_ext - R_386_standard)
2114 && ((indx = r_type - R_386_tls_offset) - R_386_ext
2115 >= R_386_tls - R_386_ext))
2117 bfd_set_error (bfd_error_bad_value);
2120 howto = elf_howto_table + indx;
2122 r_symndx = ELF32_R_SYM (rel->r_info);
2124 if (info->relocateable)
2129 /* This is a relocatable link. We don't have to change
2130 anything, unless the reloc is against a section symbol,
2131 in which case we have to adjust according to where the
2132 section symbol winds up in the output section. */
2133 if (r_symndx >= symtab_hdr->sh_info)
2136 sym = local_syms + r_symndx;
2137 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2140 sec = local_sections[r_symndx];
2141 val = sec->output_offset;
2145 where = contents + rel->r_offset;
2146 switch (howto->size)
2148 /* FIXME: overflow checks. */
2150 val += bfd_get_8 (input_bfd, where);
2151 bfd_put_8 (input_bfd, val, where);
2154 val += bfd_get_16 (input_bfd, where);
2155 bfd_put_16 (input_bfd, val, where);
2158 val += bfd_get_32 (input_bfd, where);
2159 bfd_put_32 (input_bfd, val, where);
2167 /* This is a final link. */
2171 unresolved_reloc = FALSE;
2172 if (r_symndx < symtab_hdr->sh_info)
2174 sym = local_syms + r_symndx;
2175 sec = local_sections[r_symndx];
2176 relocation = (sec->output_section->vma
2177 + sec->output_offset
2179 if ((sec->flags & SEC_MERGE)
2180 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2184 bfd_byte *where = contents + rel->r_offset;
2186 switch (howto->size)
2189 addend = bfd_get_8 (input_bfd, where);
2190 if (howto->pc_relative)
2192 addend = (addend ^ 0x80) - 0x80;
2197 addend = bfd_get_16 (input_bfd, where);
2198 if (howto->pc_relative)
2200 addend = (addend ^ 0x8000) - 0x8000;
2205 addend = bfd_get_32 (input_bfd, where);
2206 if (howto->pc_relative)
2208 addend = (addend ^ 0x80000000) - 0x80000000;
2217 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2218 addend -= relocation;
2219 addend += msec->output_section->vma + msec->output_offset;
2221 switch (howto->size)
2224 /* FIXME: overflow checks. */
2225 if (howto->pc_relative)
2227 bfd_put_8 (input_bfd, addend, where);
2230 if (howto->pc_relative)
2232 bfd_put_16 (input_bfd, addend, where);
2235 if (howto->pc_relative)
2237 bfd_put_32 (input_bfd, addend, where);
2244 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2245 while (h->root.type == bfd_link_hash_indirect
2246 || h->root.type == bfd_link_hash_warning)
2247 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2250 if (h->root.type == bfd_link_hash_defined
2251 || h->root.type == bfd_link_hash_defweak)
2253 sec = h->root.u.def.section;
2254 if (sec->output_section == NULL)
2255 /* Set a flag that will be cleared later if we find a
2256 relocation value for this symbol. output_section
2257 is typically NULL for symbols satisfied by a shared
2259 unresolved_reloc = TRUE;
2261 relocation = (h->root.u.def.value
2262 + sec->output_section->vma
2263 + sec->output_offset);
2265 else if (h->root.type == bfd_link_hash_undefweak)
2267 else if (info->shared
2268 && !info->no_undefined
2269 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2273 if (! ((*info->callbacks->undefined_symbol)
2274 (info, h->root.root.string, input_bfd,
2275 input_section, rel->r_offset,
2276 (!info->shared || info->no_undefined
2277 || ELF_ST_VISIBILITY (h->other)))))
2285 /* Relocation is to the entry for this symbol in the global
2287 if (htab->sgot == NULL)
2294 off = h->got.offset;
2295 dyn = htab->elf.dynamic_sections_created;
2296 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2300 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2301 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
2303 /* This is actually a static link, or it is a
2304 -Bsymbolic link and the symbol is defined
2305 locally, or the symbol was forced to be local
2306 because of a version file. We must initialize
2307 this entry in the global offset table. Since the
2308 offset must always be a multiple of 4, we use the
2309 least significant bit to record whether we have
2310 initialized it already.
2312 When doing a dynamic link, we create a .rel.got
2313 relocation entry to initialize the value. This
2314 is done in the finish_dynamic_symbol routine. */
2319 bfd_put_32 (output_bfd, relocation,
2320 htab->sgot->contents + off);
2325 unresolved_reloc = FALSE;
2329 if (local_got_offsets == NULL)
2332 off = local_got_offsets[r_symndx];
2334 /* The offset must always be a multiple of 4. We use
2335 the least significant bit to record whether we have
2336 already generated the necessary reloc. */
2341 bfd_put_32 (output_bfd, relocation,
2342 htab->sgot->contents + off);
2347 Elf_Internal_Rela outrel;
2354 outrel.r_offset = (htab->sgot->output_section->vma
2355 + htab->sgot->output_offset
2357 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2359 loc += s->reloc_count++ * sizeof (Elf32_External_Rel);
2360 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2363 local_got_offsets[r_symndx] |= 1;
2367 if (off >= (bfd_vma) -2)
2370 relocation = htab->sgot->output_offset + off;
2374 /* Relocation is relative to the start of the global offset
2377 /* Note that sgot->output_offset is not involved in this
2378 calculation. We always want the start of .got. If we
2379 defined _GLOBAL_OFFSET_TABLE in a different way, as is
2380 permitted by the ABI, we might have to change this
2382 relocation -= htab->sgot->output_section->vma;
2386 /* Use global offset table as symbol value. */
2387 relocation = htab->sgot->output_section->vma;
2388 unresolved_reloc = FALSE;
2392 /* Relocation is to the entry for this symbol in the
2393 procedure linkage table. */
2395 /* Resolve a PLT32 reloc against a local symbol directly,
2396 without using the procedure linkage table. */
2400 if (h->plt.offset == (bfd_vma) -1
2401 || htab->splt == NULL)
2403 /* We didn't make a PLT entry for this symbol. This
2404 happens when statically linking PIC code, or when
2405 using -Bsymbolic. */
2409 relocation = (htab->splt->output_section->vma
2410 + htab->splt->output_offset
2412 unresolved_reloc = FALSE;
2417 /* r_symndx will be zero only for relocs against symbols
2418 from removed linkonce sections, or sections discarded by
2421 || (input_section->flags & SEC_ALLOC) == 0)
2425 && (r_type != R_386_PC32
2428 && (! info->symbolic
2429 || (h->elf_link_hash_flags
2430 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2431 || (ELIMINATE_COPY_RELOCS
2435 && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
2436 && (((h->elf_link_hash_flags
2437 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2438 && (h->elf_link_hash_flags
2439 & ELF_LINK_HASH_DEF_REGULAR) == 0)
2440 || h->root.type == bfd_link_hash_undefweak
2441 || h->root.type == bfd_link_hash_undefined)))
2443 Elf_Internal_Rela outrel;
2445 bfd_boolean skip, relocate;
2448 /* When generating a shared object, these relocations
2449 are copied into the output file to be resolved at run
2456 _bfd_elf_section_offset (output_bfd, info, input_section,
2458 if (outrel.r_offset == (bfd_vma) -1)
2460 else if (outrel.r_offset == (bfd_vma) -2)
2461 skip = TRUE, relocate = TRUE;
2462 outrel.r_offset += (input_section->output_section->vma
2463 + input_section->output_offset);
2466 memset (&outrel, 0, sizeof outrel);
2469 && (r_type == R_386_PC32
2472 || (h->elf_link_hash_flags
2473 & ELF_LINK_HASH_DEF_REGULAR) == 0))
2474 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2477 /* This symbol is local, or marked to become local. */
2479 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2482 sreloc = elf_section_data (input_section)->sreloc;
2486 loc = sreloc->contents;
2487 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2488 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2490 /* If this reloc is against an external symbol, we do
2491 not want to fiddle with the addend. Otherwise, we
2492 need to include the symbol value so that it becomes
2493 an addend for the dynamic reloc. */
2502 Elf_Internal_Rela outrel;
2506 outrel.r_offset = rel->r_offset
2507 + input_section->output_section->vma
2508 + input_section->output_offset;
2509 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
2510 sreloc = elf_section_data (input_section)->sreloc;
2513 loc = sreloc->contents;
2514 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2515 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2520 case R_386_TLS_IE_32:
2521 case R_386_TLS_GOTIE:
2522 r_type = elf_i386_tls_transition (info, r_type, h == NULL);
2523 tls_type = GOT_UNKNOWN;
2524 if (h == NULL && local_got_offsets)
2525 tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
2528 tls_type = elf_i386_hash_entry(h)->tls_type;
2529 if (!info->shared && h->dynindx == -1 && (tls_type & GOT_TLS_IE))
2530 r_type = R_386_TLS_LE_32;
2532 if (tls_type == GOT_TLS_IE)
2533 tls_type = GOT_TLS_IE_NEG;
2534 if (r_type == R_386_TLS_GD)
2536 if (tls_type == GOT_TLS_IE_POS)
2537 r_type = R_386_TLS_GOTIE;
2538 else if (tls_type & GOT_TLS_IE)
2539 r_type = R_386_TLS_IE_32;
2542 if (r_type == R_386_TLS_LE_32)
2544 BFD_ASSERT (! unresolved_reloc);
2545 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
2547 unsigned int val, type;
2550 /* GD->LE transition. */
2551 BFD_ASSERT (rel->r_offset >= 2);
2552 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2553 BFD_ASSERT (type == 0x8d || type == 0x04);
2554 BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2555 BFD_ASSERT (bfd_get_8 (input_bfd,
2556 contents + rel->r_offset + 4)
2558 BFD_ASSERT (rel + 1 < relend);
2559 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2560 roff = rel->r_offset + 5;
2561 val = bfd_get_8 (input_bfd,
2562 contents + rel->r_offset - 1);
2565 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2567 movl %gs:0, %eax; subl $foo@tpoff, %eax
2568 (6 byte form of subl). */
2569 BFD_ASSERT (rel->r_offset >= 3);
2570 BFD_ASSERT (bfd_get_8 (input_bfd,
2571 contents + rel->r_offset - 3)
2573 BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2574 memcpy (contents + rel->r_offset - 3,
2575 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2579 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2580 if (rel->r_offset + 10 <= input_section->_raw_size
2581 && bfd_get_8 (input_bfd,
2582 contents + rel->r_offset + 9) == 0x90)
2584 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2586 movl %gs:0, %eax; subl $foo@tpoff, %eax
2587 (6 byte form of subl). */
2588 memcpy (contents + rel->r_offset - 2,
2589 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2590 roff = rel->r_offset + 6;
2594 /* leal foo(%reg), %eax; call ___tls_get_addr
2596 movl %gs:0, %eax; subl $foo@tpoff, %eax
2597 (5 byte form of subl). */
2598 memcpy (contents + rel->r_offset - 2,
2599 "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2602 bfd_put_32 (output_bfd, tpoff (info, relocation),
2604 /* Skip R_386_PLT32. */
2608 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
2610 unsigned int val, type;
2612 /* IE->LE transition:
2613 Originally it can be one of:
2621 BFD_ASSERT (rel->r_offset >= 1);
2622 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2623 BFD_ASSERT (rel->r_offset + 4 <= input_section->_raw_size);
2626 /* movl foo, %eax. */
2627 bfd_put_8 (output_bfd, 0xb8, contents + rel->r_offset - 1);
2631 BFD_ASSERT (rel->r_offset >= 2);
2632 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2637 BFD_ASSERT ((val & 0xc7) == 0x05);
2638 bfd_put_8 (output_bfd, 0xc7,
2639 contents + rel->r_offset - 2);
2640 bfd_put_8 (output_bfd,
2641 0xc0 | ((val >> 3) & 7),
2642 contents + rel->r_offset - 1);
2646 BFD_ASSERT ((val & 0xc7) == 0x05);
2647 bfd_put_8 (output_bfd, 0x81,
2648 contents + rel->r_offset - 2);
2649 bfd_put_8 (output_bfd,
2650 0xc0 | ((val >> 3) & 7),
2651 contents + rel->r_offset - 1);
2658 bfd_put_32 (output_bfd, -tpoff (info, relocation),
2659 contents + rel->r_offset);
2664 unsigned int val, type;
2666 /* {IE_32,GOTIE}->LE transition:
2667 Originally it can be one of:
2668 subl foo(%reg1), %reg2
2669 movl foo(%reg1), %reg2
2670 addl foo(%reg1), %reg2
2673 movl $foo, %reg2 (6 byte form)
2674 addl $foo, %reg2. */
2675 BFD_ASSERT (rel->r_offset >= 2);
2676 type = 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 (rel->r_offset + 4 <= input_section->_raw_size);
2679 BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
2683 bfd_put_8 (output_bfd, 0xc7,
2684 contents + rel->r_offset - 2);
2685 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2686 contents + rel->r_offset - 1);
2688 else if (type == 0x2b)
2691 bfd_put_8 (output_bfd, 0x81,
2692 contents + rel->r_offset - 2);
2693 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
2694 contents + rel->r_offset - 1);
2696 else if (type == 0x03)
2699 bfd_put_8 (output_bfd, 0x81,
2700 contents + rel->r_offset - 2);
2701 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2702 contents + rel->r_offset - 1);
2706 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
2707 bfd_put_32 (output_bfd, -tpoff (info, relocation),
2708 contents + rel->r_offset);
2710 bfd_put_32 (output_bfd, tpoff (info, relocation),
2711 contents + rel->r_offset);
2716 if (htab->sgot == NULL)
2720 off = h->got.offset;
2723 if (local_got_offsets == NULL)
2726 off = local_got_offsets[r_symndx];
2733 Elf_Internal_Rela outrel;
2737 if (htab->srelgot == NULL)
2740 outrel.r_offset = (htab->sgot->output_section->vma
2741 + htab->sgot->output_offset + off);
2743 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2744 if (r_type == R_386_TLS_GD)
2745 dr_type = R_386_TLS_DTPMOD32;
2746 else if (tls_type == GOT_TLS_IE_POS)
2747 dr_type = R_386_TLS_TPOFF;
2749 dr_type = R_386_TLS_TPOFF32;
2750 if (dr_type == R_386_TLS_TPOFF && indx == 0)
2751 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
2752 htab->sgot->contents + off);
2753 else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
2754 bfd_put_32 (output_bfd, dtpoff_base (info) - relocation,
2755 htab->sgot->contents + off);
2757 bfd_put_32 (output_bfd, 0,
2758 htab->sgot->contents + off);
2759 outrel.r_info = ELF32_R_INFO (indx, dr_type);
2760 loc = htab->srelgot->contents;
2761 loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
2762 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2764 if (r_type == R_386_TLS_GD)
2768 BFD_ASSERT (! unresolved_reloc);
2769 bfd_put_32 (output_bfd,
2770 relocation - dtpoff_base (info),
2771 htab->sgot->contents + off + 4);
2775 bfd_put_32 (output_bfd, 0,
2776 htab->sgot->contents + off + 4);
2777 outrel.r_info = ELF32_R_INFO (indx,
2778 R_386_TLS_DTPOFF32);
2779 outrel.r_offset += 4;
2780 htab->srelgot->reloc_count++;
2781 loc += sizeof (Elf32_External_Rel);
2782 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2785 else if (tls_type == GOT_TLS_IE_BOTH)
2787 bfd_put_32 (output_bfd,
2788 indx == 0 ? relocation - dtpoff_base (info) : 0,
2789 htab->sgot->contents + off + 4);
2790 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
2791 outrel.r_offset += 4;
2792 htab->srelgot->reloc_count++;
2793 loc += sizeof (Elf32_External_Rel);
2794 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2800 local_got_offsets[r_symndx] |= 1;
2803 if (off >= (bfd_vma) -2)
2805 if (r_type == ELF32_R_TYPE (rel->r_info))
2807 relocation = htab->sgot->output_offset + off;
2808 if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
2809 && tls_type == GOT_TLS_IE_BOTH)
2811 if (r_type == R_386_TLS_IE)
2812 relocation += htab->sgot->output_section->vma;
2813 unresolved_reloc = FALSE;
2817 unsigned int val, type;
2820 /* GD->IE transition. */
2821 BFD_ASSERT (rel->r_offset >= 2);
2822 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2823 BFD_ASSERT (type == 0x8d || type == 0x04);
2824 BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2825 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2827 BFD_ASSERT (rel + 1 < relend);
2828 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2829 roff = rel->r_offset - 3;
2830 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2833 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2835 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
2836 BFD_ASSERT (rel->r_offset >= 3);
2837 BFD_ASSERT (bfd_get_8 (input_bfd,
2838 contents + rel->r_offset - 3)
2840 BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2845 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2847 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
2848 BFD_ASSERT (rel->r_offset + 10 <= input_section->_raw_size);
2849 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2850 BFD_ASSERT (bfd_get_8 (input_bfd,
2851 contents + rel->r_offset + 9)
2853 roff = rel->r_offset - 2;
2855 memcpy (contents + roff,
2856 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
2857 contents[roff + 7] = 0x80 | (val & 7);
2858 /* If foo is used only with foo@gotntpoff(%reg) and
2859 foo@indntpoff, but not with foo@gottpoff(%reg), change
2860 subl $foo@gottpoff(%reg), %eax
2862 addl $foo@gotntpoff(%reg), %eax. */
2863 if (r_type == R_386_TLS_GOTIE)
2865 contents[roff + 6] = 0x03;
2866 if (tls_type == GOT_TLS_IE_BOTH)
2869 bfd_put_32 (output_bfd, htab->sgot->output_offset + off,
2870 contents + roff + 8);
2871 /* Skip R_386_PLT32. */
2882 /* LD->LE transition:
2884 leal foo(%reg), %eax; call ___tls_get_addr.
2886 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
2887 BFD_ASSERT (rel->r_offset >= 2);
2888 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 2)
2890 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2891 BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2892 BFD_ASSERT (rel->r_offset + 9 <= input_section->_raw_size);
2893 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2895 BFD_ASSERT (rel + 1 < relend);
2896 BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2897 memcpy (contents + rel->r_offset - 2,
2898 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
2899 /* Skip R_386_PLT32. */
2904 if (htab->sgot == NULL)
2907 off = htab->tls_ldm_got.offset;
2912 Elf_Internal_Rela outrel;
2915 if (htab->srelgot == NULL)
2918 outrel.r_offset = (htab->sgot->output_section->vma
2919 + htab->sgot->output_offset + off);
2921 bfd_put_32 (output_bfd, 0,
2922 htab->sgot->contents + off);
2923 bfd_put_32 (output_bfd, 0,
2924 htab->sgot->contents + off + 4);
2925 outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
2926 loc = htab->srelgot->contents;
2927 loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
2928 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2929 htab->tls_ldm_got.offset |= 1;
2931 relocation = htab->sgot->output_offset + off;
2932 unresolved_reloc = FALSE;
2935 case R_386_TLS_LDO_32:
2936 if (info->shared || (input_section->flags & SEC_CODE) == 0)
2937 relocation -= dtpoff_base (info);
2939 /* When converting LDO to LE, we must negate. */
2940 relocation = -tpoff (info, relocation);
2943 case R_386_TLS_LE_32:
2947 Elf_Internal_Rela outrel;
2952 outrel.r_offset = rel->r_offset
2953 + input_section->output_section->vma
2954 + input_section->output_offset;
2955 if (h != NULL && h->dynindx != -1)
2959 if (r_type == R_386_TLS_LE_32)
2960 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
2962 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
2963 sreloc = elf_section_data (input_section)->sreloc;
2966 loc = sreloc->contents;
2967 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2968 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2971 else if (r_type == R_386_TLS_LE_32)
2972 relocation = dtpoff_base (info) - relocation;
2974 relocation -= dtpoff_base (info);
2976 else if (r_type == R_386_TLS_LE_32)
2977 relocation = tpoff (info, relocation);
2979 relocation = -tpoff (info, relocation);
2986 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2987 because such sections are not SEC_ALLOC and thus ld.so will
2988 not process them. */
2989 if (unresolved_reloc
2990 && !((input_section->flags & SEC_DEBUGGING) != 0
2991 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
2993 (*_bfd_error_handler)
2994 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2995 bfd_archive_filename (input_bfd),
2996 bfd_get_section_name (input_bfd, input_section),
2997 (long) rel->r_offset,
2998 h->root.root.string);
3002 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3003 contents, rel->r_offset,
3004 relocation, (bfd_vma) 0);
3006 if (r != bfd_reloc_ok)
3011 name = h->root.root.string;
3014 name = bfd_elf_string_from_elf_section (input_bfd,
3015 symtab_hdr->sh_link,
3020 name = bfd_section_name (input_bfd, sec);
3023 if (r == bfd_reloc_overflow)
3025 if (! ((*info->callbacks->reloc_overflow)
3026 (info, name, howto->name, (bfd_vma) 0,
3027 input_bfd, input_section, rel->r_offset)))
3032 (*_bfd_error_handler)
3033 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
3034 bfd_archive_filename (input_bfd),
3035 bfd_get_section_name (input_bfd, input_section),
3036 (long) rel->r_offset, name, (int) r);
3045 /* Finish up dynamic symbol handling. We set the contents of various
3046 dynamic sections here. */
3049 elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym)
3051 struct bfd_link_info *info;
3052 struct elf_link_hash_entry *h;
3053 Elf_Internal_Sym *sym;
3055 struct elf_i386_link_hash_table *htab;
3057 htab = elf_i386_hash_table (info);
3059 if (h->plt.offset != (bfd_vma) -1)
3063 Elf_Internal_Rela rel;
3066 /* This symbol has an entry in the procedure linkage table. Set
3069 if (h->dynindx == -1
3070 || htab->splt == NULL
3071 || htab->sgotplt == NULL
3072 || htab->srelplt == NULL)
3075 /* Get the index in the procedure linkage table which
3076 corresponds to this symbol. This is the index of this symbol
3077 in all the symbols for which we are making plt entries. The
3078 first entry in the procedure linkage table is reserved. */
3079 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3081 /* Get the offset into the .got table of the entry that
3082 corresponds to this function. Each .got entry is 4 bytes.
3083 The first three are reserved. */
3084 got_offset = (plt_index + 3) * 4;
3086 /* Fill in the entry in the procedure linkage table. */
3089 memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry,
3091 bfd_put_32 (output_bfd,
3092 (htab->sgotplt->output_section->vma
3093 + htab->sgotplt->output_offset
3095 htab->splt->contents + h->plt.offset + 2);
3099 memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry,
3101 bfd_put_32 (output_bfd, got_offset,
3102 htab->splt->contents + h->plt.offset + 2);
3105 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel),
3106 htab->splt->contents + h->plt.offset + 7);
3107 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
3108 htab->splt->contents + h->plt.offset + 12);
3110 /* Fill in the entry in the global offset table. */
3111 bfd_put_32 (output_bfd,
3112 (htab->splt->output_section->vma
3113 + htab->splt->output_offset
3116 htab->sgotplt->contents + got_offset);
3118 /* Fill in the entry in the .rel.plt section. */
3119 rel.r_offset = (htab->sgotplt->output_section->vma
3120 + htab->sgotplt->output_offset
3122 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
3123 loc = htab->srelplt->contents + plt_index * sizeof (Elf32_External_Rel);
3124 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3126 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3128 /* Mark the symbol as undefined, rather than as defined in
3129 the .plt section. Leave the value alone. This is a clue
3130 for the dynamic linker, to make function pointer
3131 comparisons work between an application and shared
3133 sym->st_shndx = SHN_UNDEF;
3137 if (h->got.offset != (bfd_vma) -1
3138 && elf_i386_hash_entry(h)->tls_type != GOT_TLS_GD
3139 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0)
3141 Elf_Internal_Rela rel;
3144 /* This symbol has an entry in the global offset table. Set it
3147 if (htab->sgot == NULL || htab->srelgot == NULL)
3150 rel.r_offset = (htab->sgot->output_section->vma
3151 + htab->sgot->output_offset
3152 + (h->got.offset & ~(bfd_vma) 1));
3154 /* If this is a static link, or it is a -Bsymbolic link and the
3155 symbol is defined locally or was forced to be local because
3156 of a version file, we just want to emit a RELATIVE reloc.
3157 The entry in the global offset table will already have been
3158 initialized in the relocate_section function. */
3162 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
3163 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3165 BFD_ASSERT((h->got.offset & 1) != 0);
3166 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3170 BFD_ASSERT((h->got.offset & 1) == 0);
3171 bfd_put_32 (output_bfd, (bfd_vma) 0,
3172 htab->sgot->contents + h->got.offset);
3173 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
3176 loc = htab->srelgot->contents;
3177 loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
3178 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3181 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
3183 Elf_Internal_Rela rel;
3186 /* This symbol needs a copy reloc. Set it up. */
3188 if (h->dynindx == -1
3189 || (h->root.type != bfd_link_hash_defined
3190 && h->root.type != bfd_link_hash_defweak)
3191 || htab->srelbss == NULL)
3194 rel.r_offset = (h->root.u.def.value
3195 + h->root.u.def.section->output_section->vma
3196 + h->root.u.def.section->output_offset);
3197 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
3198 loc = htab->srelbss->contents;
3199 loc += htab->srelbss->reloc_count++ * sizeof (Elf32_External_Rel);
3200 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
3203 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3204 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3205 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3206 sym->st_shndx = SHN_ABS;
3211 /* Used to decide how to sort relocs in an optimal manner for the
3212 dynamic linker, before writing them out. */
3214 static enum elf_reloc_type_class
3215 elf_i386_reloc_type_class (rela)
3216 const Elf_Internal_Rela *rela;
3218 switch ((int) ELF32_R_TYPE (rela->r_info))
3220 case R_386_RELATIVE:
3221 return reloc_class_relative;
3222 case R_386_JUMP_SLOT:
3223 return reloc_class_plt;
3225 return reloc_class_copy;
3227 return reloc_class_normal;
3231 /* Finish up the dynamic sections. */
3234 elf_i386_finish_dynamic_sections (output_bfd, info)
3236 struct bfd_link_info *info;
3238 struct elf_i386_link_hash_table *htab;
3242 htab = elf_i386_hash_table (info);
3243 dynobj = htab->elf.dynobj;
3244 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3246 if (htab->elf.dynamic_sections_created)
3248 Elf32_External_Dyn *dyncon, *dynconend;
3250 if (sdyn == NULL || htab->sgot == NULL)
3253 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3254 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3255 for (; dyncon < dynconend; dyncon++)
3257 Elf_Internal_Dyn dyn;
3260 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3268 dyn.d_un.d_ptr = htab->sgot->output_section->vma;
3273 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3278 dyn.d_un.d_val = s->_raw_size;
3282 /* My reading of the SVR4 ABI indicates that the
3283 procedure linkage table relocs (DT_JMPREL) should be
3284 included in the overall relocs (DT_REL). This is
3285 what Solaris does. However, UnixWare can not handle
3286 that case. Therefore, we override the DT_RELSZ entry
3287 here to make it not include the JMPREL relocs. */
3291 dyn.d_un.d_val -= s->_raw_size;
3295 /* We may not be using the standard ELF linker script.
3296 If .rel.plt is the first .rel section, we adjust
3297 DT_REL to not include it. */
3301 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
3303 dyn.d_un.d_ptr += s->_raw_size;
3307 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3310 /* Fill in the first entry in the procedure linkage table. */
3311 if (htab->splt && htab->splt->_raw_size > 0)
3314 memcpy (htab->splt->contents,
3315 elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE);
3318 memcpy (htab->splt->contents,
3319 elf_i386_plt0_entry, PLT_ENTRY_SIZE);
3320 bfd_put_32 (output_bfd,
3321 (htab->sgotplt->output_section->vma
3322 + htab->sgotplt->output_offset
3324 htab->splt->contents + 2);
3325 bfd_put_32 (output_bfd,
3326 (htab->sgotplt->output_section->vma
3327 + htab->sgotplt->output_offset
3329 htab->splt->contents + 8);
3332 /* UnixWare sets the entsize of .plt to 4, although that doesn't
3333 really seem like the right value. */
3334 elf_section_data (htab->splt->output_section)
3335 ->this_hdr.sh_entsize = 4;
3341 /* Fill in the first three entries in the global offset table. */
3342 if (htab->sgotplt->_raw_size > 0)
3344 bfd_put_32 (output_bfd,
3345 (sdyn == NULL ? (bfd_vma) 0
3346 : sdyn->output_section->vma + sdyn->output_offset),
3347 htab->sgotplt->contents);
3348 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 4);
3349 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8);
3352 elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4;
3357 #define TARGET_LITTLE_SYM bfd_elf32_i386_vec
3358 #define TARGET_LITTLE_NAME "elf32-i386"
3359 #define ELF_ARCH bfd_arch_i386
3360 #define ELF_MACHINE_CODE EM_386
3361 #define ELF_MAXPAGESIZE 0x1000
3363 #define elf_backend_can_gc_sections 1
3364 #define elf_backend_can_refcount 1
3365 #define elf_backend_want_got_plt 1
3366 #define elf_backend_plt_readonly 1
3367 #define elf_backend_want_plt_sym 0
3368 #define elf_backend_got_header_size 12
3369 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
3371 /* Support RELA for objdump of prelink objects. */
3372 #define elf_info_to_howto elf_i386_info_to_howto_rel
3373 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
3375 #define bfd_elf32_mkobject elf_i386_mkobject
3376 #define elf_backend_object_p elf_i386_object_p
3378 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
3379 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
3380 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
3382 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
3383 #define elf_backend_check_relocs elf_i386_check_relocs
3384 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
3385 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
3386 #define elf_backend_fake_sections elf_i386_fake_sections
3387 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
3388 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
3389 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
3390 #define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook
3391 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
3392 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
3393 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
3394 #define elf_backend_relocate_section elf_i386_relocate_section
3395 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
3397 #include "elf32-target.h"
3399 /* FreeBSD support. */
3401 #undef TARGET_LITTLE_SYM
3402 #define TARGET_LITTLE_SYM bfd_elf32_i386_freebsd_vec
3403 #undef TARGET_LITTLE_NAME
3404 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
3406 /* The kernel recognizes executables as valid only if they carry a
3407 "FreeBSD" label in the ELF header. So we put this label on all
3408 executables and (for simplicity) also all other object files. */
3410 static void elf_i386_post_process_headers
3411 PARAMS ((bfd *, struct bfd_link_info *));
3414 elf_i386_post_process_headers (abfd, link_info)
3416 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
3418 Elf_Internal_Ehdr *i_ehdrp;
3420 i_ehdrp = elf_elfheader (abfd);
3422 /* Put an ABI label supported by FreeBSD >= 4.1. */
3423 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
3424 #ifdef OLD_FREEBSD_ABI_LABEL
3425 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
3426 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
3430 #undef elf_backend_post_process_headers
3431 #define elf_backend_post_process_headers elf_i386_post_process_headers
3433 #define elf32_bed elf32_i386_fbsd_bed
3435 #include "elf32-target.h"