1 /* Intel 80386/80486-specific support for 32-bit ELF
2 Copyright (C) 1993-2017 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
21 #include "elfxx-x86.h"
23 #include "elf-vxworks.h"
25 #include "opcode/i386.h"
27 /* 386 uses REL relocations instead of RELA. */
32 static reloc_howto_type elf_howto_table[]=
34 HOWTO(R_386_NONE, 0, 3, 0, FALSE, 0, complain_overflow_dont,
35 bfd_elf_generic_reloc, "R_386_NONE",
36 TRUE, 0x00000000, 0x00000000, FALSE),
37 HOWTO(R_386_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
38 bfd_elf_generic_reloc, "R_386_32",
39 TRUE, 0xffffffff, 0xffffffff, FALSE),
40 HOWTO(R_386_PC32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
41 bfd_elf_generic_reloc, "R_386_PC32",
42 TRUE, 0xffffffff, 0xffffffff, TRUE),
43 HOWTO(R_386_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
44 bfd_elf_generic_reloc, "R_386_GOT32",
45 TRUE, 0xffffffff, 0xffffffff, FALSE),
46 HOWTO(R_386_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
47 bfd_elf_generic_reloc, "R_386_PLT32",
48 TRUE, 0xffffffff, 0xffffffff, TRUE),
49 HOWTO(R_386_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
50 bfd_elf_generic_reloc, "R_386_COPY",
51 TRUE, 0xffffffff, 0xffffffff, FALSE),
52 HOWTO(R_386_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
53 bfd_elf_generic_reloc, "R_386_GLOB_DAT",
54 TRUE, 0xffffffff, 0xffffffff, FALSE),
55 HOWTO(R_386_JUMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
56 bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
57 TRUE, 0xffffffff, 0xffffffff, FALSE),
58 HOWTO(R_386_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
59 bfd_elf_generic_reloc, "R_386_RELATIVE",
60 TRUE, 0xffffffff, 0xffffffff, FALSE),
61 HOWTO(R_386_GOTOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
62 bfd_elf_generic_reloc, "R_386_GOTOFF",
63 TRUE, 0xffffffff, 0xffffffff, FALSE),
64 HOWTO(R_386_GOTPC, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
65 bfd_elf_generic_reloc, "R_386_GOTPC",
66 TRUE, 0xffffffff, 0xffffffff, TRUE),
68 /* We have a gap in the reloc numbers here.
69 R_386_standard counts the number up to this point, and
70 R_386_ext_offset is the value to subtract from a reloc type of
71 R_386_16 thru R_386_PC8 to form an index into this table. */
72 #define R_386_standard (R_386_GOTPC + 1)
73 #define R_386_ext_offset (R_386_TLS_TPOFF - R_386_standard)
75 /* These relocs are a GNU extension. */
76 HOWTO(R_386_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
77 bfd_elf_generic_reloc, "R_386_TLS_TPOFF",
78 TRUE, 0xffffffff, 0xffffffff, FALSE),
79 HOWTO(R_386_TLS_IE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
80 bfd_elf_generic_reloc, "R_386_TLS_IE",
81 TRUE, 0xffffffff, 0xffffffff, FALSE),
82 HOWTO(R_386_TLS_GOTIE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
83 bfd_elf_generic_reloc, "R_386_TLS_GOTIE",
84 TRUE, 0xffffffff, 0xffffffff, FALSE),
85 HOWTO(R_386_TLS_LE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
86 bfd_elf_generic_reloc, "R_386_TLS_LE",
87 TRUE, 0xffffffff, 0xffffffff, FALSE),
88 HOWTO(R_386_TLS_GD, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
89 bfd_elf_generic_reloc, "R_386_TLS_GD",
90 TRUE, 0xffffffff, 0xffffffff, FALSE),
91 HOWTO(R_386_TLS_LDM, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
92 bfd_elf_generic_reloc, "R_386_TLS_LDM",
93 TRUE, 0xffffffff, 0xffffffff, FALSE),
94 HOWTO(R_386_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
95 bfd_elf_generic_reloc, "R_386_16",
96 TRUE, 0xffff, 0xffff, FALSE),
97 HOWTO(R_386_PC16, 0, 1, 16, TRUE, 0, complain_overflow_bitfield,
98 bfd_elf_generic_reloc, "R_386_PC16",
99 TRUE, 0xffff, 0xffff, TRUE),
100 HOWTO(R_386_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
101 bfd_elf_generic_reloc, "R_386_8",
102 TRUE, 0xff, 0xff, FALSE),
103 HOWTO(R_386_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
104 bfd_elf_generic_reloc, "R_386_PC8",
105 TRUE, 0xff, 0xff, TRUE),
107 #define R_386_ext (R_386_PC8 + 1 - R_386_ext_offset)
108 #define R_386_tls_offset (R_386_TLS_LDO_32 - R_386_ext)
109 /* These are common with Solaris TLS implementation. */
110 HOWTO(R_386_TLS_LDO_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
111 bfd_elf_generic_reloc, "R_386_TLS_LDO_32",
112 TRUE, 0xffffffff, 0xffffffff, FALSE),
113 HOWTO(R_386_TLS_IE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
114 bfd_elf_generic_reloc, "R_386_TLS_IE_32",
115 TRUE, 0xffffffff, 0xffffffff, FALSE),
116 HOWTO(R_386_TLS_LE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
117 bfd_elf_generic_reloc, "R_386_TLS_LE_32",
118 TRUE, 0xffffffff, 0xffffffff, FALSE),
119 HOWTO(R_386_TLS_DTPMOD32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
120 bfd_elf_generic_reloc, "R_386_TLS_DTPMOD32",
121 TRUE, 0xffffffff, 0xffffffff, FALSE),
122 HOWTO(R_386_TLS_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
123 bfd_elf_generic_reloc, "R_386_TLS_DTPOFF32",
124 TRUE, 0xffffffff, 0xffffffff, FALSE),
125 HOWTO(R_386_TLS_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
126 bfd_elf_generic_reloc, "R_386_TLS_TPOFF32",
127 TRUE, 0xffffffff, 0xffffffff, FALSE),
128 HOWTO(R_386_SIZE32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
129 bfd_elf_generic_reloc, "R_386_SIZE32",
130 TRUE, 0xffffffff, 0xffffffff, FALSE),
131 HOWTO(R_386_TLS_GOTDESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
132 bfd_elf_generic_reloc, "R_386_TLS_GOTDESC",
133 TRUE, 0xffffffff, 0xffffffff, FALSE),
134 HOWTO(R_386_TLS_DESC_CALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
135 bfd_elf_generic_reloc, "R_386_TLS_DESC_CALL",
137 HOWTO(R_386_TLS_DESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
138 bfd_elf_generic_reloc, "R_386_TLS_DESC",
139 TRUE, 0xffffffff, 0xffffffff, FALSE),
140 HOWTO(R_386_IRELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
141 bfd_elf_generic_reloc, "R_386_IRELATIVE",
142 TRUE, 0xffffffff, 0xffffffff, FALSE),
143 HOWTO(R_386_GOT32X, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
144 bfd_elf_generic_reloc, "R_386_GOT32X",
145 TRUE, 0xffffffff, 0xffffffff, FALSE),
148 #define R_386_ext2 (R_386_GOT32X + 1 - R_386_tls_offset)
149 #define R_386_vt_offset (R_386_GNU_VTINHERIT - R_386_ext2)
151 /* GNU extension to record C++ vtable hierarchy. */
152 HOWTO (R_386_GNU_VTINHERIT, /* type */
154 2, /* size (0 = byte, 1 = short, 2 = long) */
156 FALSE, /* pc_relative */
158 complain_overflow_dont, /* complain_on_overflow */
159 NULL, /* special_function */
160 "R_386_GNU_VTINHERIT", /* name */
161 FALSE, /* partial_inplace */
164 FALSE), /* pcrel_offset */
166 /* GNU extension to record C++ vtable member usage. */
167 HOWTO (R_386_GNU_VTENTRY, /* type */
169 2, /* size (0 = byte, 1 = short, 2 = long) */
171 FALSE, /* pc_relative */
173 complain_overflow_dont, /* complain_on_overflow */
174 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
175 "R_386_GNU_VTENTRY", /* name */
176 FALSE, /* partial_inplace */
179 FALSE) /* pcrel_offset */
181 #define R_386_vt (R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
185 #ifdef DEBUG_GEN_RELOC
187 fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
192 static reloc_howto_type *
193 elf_i386_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
194 bfd_reloc_code_real_type code)
199 TRACE ("BFD_RELOC_NONE");
200 return &elf_howto_table[R_386_NONE];
203 TRACE ("BFD_RELOC_32");
204 return &elf_howto_table[R_386_32];
207 TRACE ("BFD_RELOC_CTOR");
208 return &elf_howto_table[R_386_32];
210 case BFD_RELOC_32_PCREL:
211 TRACE ("BFD_RELOC_PC32");
212 return &elf_howto_table[R_386_PC32];
214 case BFD_RELOC_386_GOT32:
215 TRACE ("BFD_RELOC_386_GOT32");
216 return &elf_howto_table[R_386_GOT32];
218 case BFD_RELOC_386_PLT32:
219 TRACE ("BFD_RELOC_386_PLT32");
220 return &elf_howto_table[R_386_PLT32];
222 case BFD_RELOC_386_COPY:
223 TRACE ("BFD_RELOC_386_COPY");
224 return &elf_howto_table[R_386_COPY];
226 case BFD_RELOC_386_GLOB_DAT:
227 TRACE ("BFD_RELOC_386_GLOB_DAT");
228 return &elf_howto_table[R_386_GLOB_DAT];
230 case BFD_RELOC_386_JUMP_SLOT:
231 TRACE ("BFD_RELOC_386_JUMP_SLOT");
232 return &elf_howto_table[R_386_JUMP_SLOT];
234 case BFD_RELOC_386_RELATIVE:
235 TRACE ("BFD_RELOC_386_RELATIVE");
236 return &elf_howto_table[R_386_RELATIVE];
238 case BFD_RELOC_386_GOTOFF:
239 TRACE ("BFD_RELOC_386_GOTOFF");
240 return &elf_howto_table[R_386_GOTOFF];
242 case BFD_RELOC_386_GOTPC:
243 TRACE ("BFD_RELOC_386_GOTPC");
244 return &elf_howto_table[R_386_GOTPC];
246 /* These relocs are a GNU extension. */
247 case BFD_RELOC_386_TLS_TPOFF:
248 TRACE ("BFD_RELOC_386_TLS_TPOFF");
249 return &elf_howto_table[R_386_TLS_TPOFF - R_386_ext_offset];
251 case BFD_RELOC_386_TLS_IE:
252 TRACE ("BFD_RELOC_386_TLS_IE");
253 return &elf_howto_table[R_386_TLS_IE - R_386_ext_offset];
255 case BFD_RELOC_386_TLS_GOTIE:
256 TRACE ("BFD_RELOC_386_TLS_GOTIE");
257 return &elf_howto_table[R_386_TLS_GOTIE - R_386_ext_offset];
259 case BFD_RELOC_386_TLS_LE:
260 TRACE ("BFD_RELOC_386_TLS_LE");
261 return &elf_howto_table[R_386_TLS_LE - R_386_ext_offset];
263 case BFD_RELOC_386_TLS_GD:
264 TRACE ("BFD_RELOC_386_TLS_GD");
265 return &elf_howto_table[R_386_TLS_GD - R_386_ext_offset];
267 case BFD_RELOC_386_TLS_LDM:
268 TRACE ("BFD_RELOC_386_TLS_LDM");
269 return &elf_howto_table[R_386_TLS_LDM - R_386_ext_offset];
272 TRACE ("BFD_RELOC_16");
273 return &elf_howto_table[R_386_16 - R_386_ext_offset];
275 case BFD_RELOC_16_PCREL:
276 TRACE ("BFD_RELOC_16_PCREL");
277 return &elf_howto_table[R_386_PC16 - R_386_ext_offset];
280 TRACE ("BFD_RELOC_8");
281 return &elf_howto_table[R_386_8 - R_386_ext_offset];
283 case BFD_RELOC_8_PCREL:
284 TRACE ("BFD_RELOC_8_PCREL");
285 return &elf_howto_table[R_386_PC8 - R_386_ext_offset];
287 /* Common with Sun TLS implementation. */
288 case BFD_RELOC_386_TLS_LDO_32:
289 TRACE ("BFD_RELOC_386_TLS_LDO_32");
290 return &elf_howto_table[R_386_TLS_LDO_32 - R_386_tls_offset];
292 case BFD_RELOC_386_TLS_IE_32:
293 TRACE ("BFD_RELOC_386_TLS_IE_32");
294 return &elf_howto_table[R_386_TLS_IE_32 - R_386_tls_offset];
296 case BFD_RELOC_386_TLS_LE_32:
297 TRACE ("BFD_RELOC_386_TLS_LE_32");
298 return &elf_howto_table[R_386_TLS_LE_32 - R_386_tls_offset];
300 case BFD_RELOC_386_TLS_DTPMOD32:
301 TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
302 return &elf_howto_table[R_386_TLS_DTPMOD32 - R_386_tls_offset];
304 case BFD_RELOC_386_TLS_DTPOFF32:
305 TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
306 return &elf_howto_table[R_386_TLS_DTPOFF32 - R_386_tls_offset];
308 case BFD_RELOC_386_TLS_TPOFF32:
309 TRACE ("BFD_RELOC_386_TLS_TPOFF32");
310 return &elf_howto_table[R_386_TLS_TPOFF32 - R_386_tls_offset];
312 case BFD_RELOC_SIZE32:
313 TRACE ("BFD_RELOC_SIZE32");
314 return &elf_howto_table[R_386_SIZE32 - R_386_tls_offset];
316 case BFD_RELOC_386_TLS_GOTDESC:
317 TRACE ("BFD_RELOC_386_TLS_GOTDESC");
318 return &elf_howto_table[R_386_TLS_GOTDESC - R_386_tls_offset];
320 case BFD_RELOC_386_TLS_DESC_CALL:
321 TRACE ("BFD_RELOC_386_TLS_DESC_CALL");
322 return &elf_howto_table[R_386_TLS_DESC_CALL - R_386_tls_offset];
324 case BFD_RELOC_386_TLS_DESC:
325 TRACE ("BFD_RELOC_386_TLS_DESC");
326 return &elf_howto_table[R_386_TLS_DESC - R_386_tls_offset];
328 case BFD_RELOC_386_IRELATIVE:
329 TRACE ("BFD_RELOC_386_IRELATIVE");
330 return &elf_howto_table[R_386_IRELATIVE - R_386_tls_offset];
332 case BFD_RELOC_386_GOT32X:
333 TRACE ("BFD_RELOC_386_GOT32X");
334 return &elf_howto_table[R_386_GOT32X - R_386_tls_offset];
336 case BFD_RELOC_VTABLE_INHERIT:
337 TRACE ("BFD_RELOC_VTABLE_INHERIT");
338 return &elf_howto_table[R_386_GNU_VTINHERIT - R_386_vt_offset];
340 case BFD_RELOC_VTABLE_ENTRY:
341 TRACE ("BFD_RELOC_VTABLE_ENTRY");
342 return &elf_howto_table[R_386_GNU_VTENTRY - R_386_vt_offset];
352 static reloc_howto_type *
353 elf_i386_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
358 for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
359 if (elf_howto_table[i].name != NULL
360 && strcasecmp (elf_howto_table[i].name, r_name) == 0)
361 return &elf_howto_table[i];
366 static reloc_howto_type *
367 elf_i386_rtype_to_howto (bfd *abfd, unsigned r_type)
371 if ((indx = r_type) >= R_386_standard
372 && ((indx = r_type - R_386_ext_offset) - R_386_standard
373 >= R_386_ext - R_386_standard)
374 && ((indx = r_type - R_386_tls_offset) - R_386_ext
375 >= R_386_ext2 - R_386_ext)
376 && ((indx = r_type - R_386_vt_offset) - R_386_ext2
377 >= R_386_vt - R_386_ext2))
379 /* xgettext:c-format */
380 _bfd_error_handler (_("%B: invalid relocation type %d"),
384 /* PR 17512: file: 0f67f69d. */
385 if (elf_howto_table [indx].type != r_type)
387 return &elf_howto_table[indx];
391 elf_i386_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
393 Elf_Internal_Rela *dst)
395 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
396 cache_ptr->howto = elf_i386_rtype_to_howto (abfd, r_type);
399 /* Return whether a symbol name implies a local label. The UnixWare
400 2.1 cc generates temporary symbols that start with .X, so we
401 recognize them here. FIXME: do other SVR4 compilers also use .X?.
402 If so, we should move the .X recognition into
403 _bfd_elf_is_local_label_name. */
406 elf_i386_is_local_label_name (bfd *abfd, const char *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. */
417 elf_i386_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
422 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
424 int pr_version = bfd_get_32 (abfd, note->descdata);
430 elf_tdata (abfd)->core->signal = bfd_get_32 (abfd, note->descdata + 20);
433 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
437 size = bfd_get_32 (abfd, note->descdata + 8);
441 switch (note->descsz)
446 case 144: /* Linux/i386 */
448 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
451 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
461 /* Make a ".reg/999" section. */
462 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
463 size, note->descpos + offset);
467 elf_i386_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
469 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
471 int pr_version = bfd_get_32 (abfd, note->descdata);
476 elf_tdata (abfd)->core->program
477 = _bfd_elfcore_strndup (abfd, note->descdata + 8, 17);
478 elf_tdata (abfd)->core->command
479 = _bfd_elfcore_strndup (abfd, note->descdata + 25, 81);
483 switch (note->descsz)
488 case 124: /* Linux/i386 elf_prpsinfo. */
489 elf_tdata (abfd)->core->pid
490 = bfd_get_32 (abfd, note->descdata + 12);
491 elf_tdata (abfd)->core->program
492 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
493 elf_tdata (abfd)->core->command
494 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
498 /* Note that for some reason, a spurious space is tacked
499 onto the end of the args in some (at least one anyway)
500 implementations, so strip it off if it exists. */
502 char *command = elf_tdata (abfd)->core->command;
503 int n = strlen (command);
505 if (0 < n && command[n - 1] == ' ')
506 command[n - 1] = '\0';
512 /* Functions for the i386 ELF linker.
514 In order to gain some understanding of code in this file without
515 knowing all the intricate details of the linker, note the
518 Functions named elf_i386_* are called by external routines, other
519 functions are only called locally. elf_i386_* functions appear
520 in this file more or less in the order in which they are called
521 from external routines. eg. elf_i386_check_relocs is called
522 early in the link process, elf_i386_finish_dynamic_sections is
523 one of the last functions. */
525 /* The size in bytes of an entry in the lazy procedure linkage table. */
527 #define LAZY_PLT_ENTRY_SIZE 16
529 /* The size in bytes of an entry in the non-lazy procedure linkage
532 #define NON_LAZY_PLT_ENTRY_SIZE 8
534 /* The first entry in an absolute lazy procedure linkage table looks
535 like this. See the SVR4 ABI i386 supplement to see how this works.
536 Will be padded to LAZY_PLT_ENTRY_SIZE with lazy_plt->plt0_pad_byte. */
538 static const bfd_byte elf_i386_lazy_plt0_entry[12] =
540 0xff, 0x35, /* pushl contents of address */
541 0, 0, 0, 0, /* replaced with address of .got + 4. */
542 0xff, 0x25, /* jmp indirect */
543 0, 0, 0, 0 /* replaced with address of .got + 8. */
546 /* Subsequent entries in an absolute lazy procedure linkage table look
549 static const bfd_byte elf_i386_lazy_plt_entry[LAZY_PLT_ENTRY_SIZE] =
551 0xff, 0x25, /* jmp indirect */
552 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
553 0x68, /* pushl immediate */
554 0, 0, 0, 0, /* replaced with offset into relocation table. */
555 0xe9, /* jmp relative */
556 0, 0, 0, 0 /* replaced with offset to start of .plt. */
559 /* The first entry in a PIC lazy procedure linkage table look like
560 this. Will be padded to LAZY_PLT_ENTRY_SIZE with
561 lazy_plt->plt0_pad_byte. */
563 static const bfd_byte elf_i386_pic_lazy_plt0_entry[12] =
565 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
566 0xff, 0xa3, 8, 0, 0, 0 /* jmp *8(%ebx) */
569 /* Subsequent entries in a PIC lazy procedure linkage table look like
572 static const bfd_byte elf_i386_pic_lazy_plt_entry[LAZY_PLT_ENTRY_SIZE] =
574 0xff, 0xa3, /* jmp *offset(%ebx) */
575 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
576 0x68, /* pushl immediate */
577 0, 0, 0, 0, /* replaced with offset into relocation table. */
578 0xe9, /* jmp relative */
579 0, 0, 0, 0 /* replaced with offset to start of .plt. */
582 /* Entries in the non-lazy procedure linkage table look like this. */
584 static const bfd_byte elf_i386_non_lazy_plt_entry[NON_LAZY_PLT_ENTRY_SIZE] =
586 0xff, 0x25, /* jmp indirect */
587 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
588 0x66, 0x90 /* xchg %ax,%ax */
591 /* Entries in the PIC non-lazy procedure linkage table look like
594 static const bfd_byte elf_i386_pic_non_lazy_plt_entry[NON_LAZY_PLT_ENTRY_SIZE] =
596 0xff, 0xa3, /* jmp *offset(%ebx) */
597 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
598 0x66, 0x90 /* xchg %ax,%ax */
601 /* The first entry in an absolute IBT-enabled lazy procedure linkage
602 table looks like this. */
604 static const bfd_byte elf_i386_lazy_ibt_plt0_entry[LAZY_PLT_ENTRY_SIZE] =
606 0xff, 0x35, 0, 0, 0, 0, /* pushl GOT[1] */
607 0xff, 0x25, 0, 0, 0, 0, /* jmp *GOT[2] */
608 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
611 /* Subsequent entries for an absolute IBT-enabled lazy procedure linkage
612 table look like this. Subsequent entries for a PIC IBT-enabled lazy
613 procedure linkage table are the same. */
615 static const bfd_byte elf_i386_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] =
617 0xf3, 0x0f, 0x1e, 0xfb, /* endbr32 */
618 0x68, 0, 0, 0, 0, /* pushl immediate */
619 0xe9, 0, 0, 0, 0, /* jmp relative */
620 0x66, 0x90 /* xchg %ax,%ax */
623 /* The first entry in a PIC IBT-enabled lazy procedure linkage table
626 static const bfd_byte elf_i386_pic_lazy_ibt_plt0_entry[LAZY_PLT_ENTRY_SIZE] =
628 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
629 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */
630 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
633 /* Entries for branches with IBT-enabled in the absolute non-lazey
634 procedure linkage table look like this. They have the same size
635 as the lazy PLT entry. */
637 static const bfd_byte elf_i386_non_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] =
639 0xf3, 0x0f, 0x1e, 0xfb, /* endbr32 */
640 0xff, 0x25, 0, 0, 0, 0, /* jmp *name@GOT */
641 0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nopw 0x0(%rax,%rax,1) */
644 /* Entries for branches with IBT-enabled in the PIC non-lazey procedure
645 linkage table look like this. They have the same size as the lazy
648 static const bfd_byte elf_i386_pic_non_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] =
650 0xf3, 0x0f, 0x1e, 0xfb, /* endbr32 */
651 0xff, 0xa3, 0, 0, 0, 0, /* jmp *name@GOT(%ebx) */
652 0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nopw 0x0(%rax,%rax,1) */
655 /* .eh_frame covering the lazy .plt section. */
657 static const bfd_byte elf_i386_eh_frame_lazy_plt[] =
659 #define PLT_CIE_LENGTH 20
660 #define PLT_FDE_LENGTH 36
661 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
662 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
663 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
664 0, 0, 0, 0, /* CIE ID */
666 'z', 'R', 0, /* Augmentation string */
667 1, /* Code alignment factor */
668 0x7c, /* Data alignment factor */
669 8, /* Return address column */
670 1, /* Augmentation size */
671 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
672 DW_CFA_def_cfa, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
673 DW_CFA_offset + 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
674 DW_CFA_nop, DW_CFA_nop,
676 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
677 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
678 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
679 0, 0, 0, 0, /* .plt size goes here */
680 0, /* Augmentation size */
681 DW_CFA_def_cfa_offset, 8, /* DW_CFA_def_cfa_offset: 8 */
682 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
683 DW_CFA_def_cfa_offset, 12, /* DW_CFA_def_cfa_offset: 12 */
684 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
685 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
686 11, /* Block length */
687 DW_OP_breg4, 4, /* DW_OP_breg4 (esp): 4 */
688 DW_OP_breg8, 0, /* DW_OP_breg8 (eip): 0 */
689 DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
690 DW_OP_lit2, DW_OP_shl, DW_OP_plus,
691 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
694 /* .eh_frame covering the lazy .plt section with IBT-enabled. */
696 static const bfd_byte elf_i386_eh_frame_lazy_ibt_plt[] =
698 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
699 0, 0, 0, 0, /* CIE ID */
701 'z', 'R', 0, /* Augmentation string */
702 1, /* Code alignment factor */
703 0x7c, /* Data alignment factor */
704 8, /* Return address column */
705 1, /* Augmentation size */
706 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
707 DW_CFA_def_cfa, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
708 DW_CFA_offset + 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
709 DW_CFA_nop, DW_CFA_nop,
711 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
712 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
713 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
714 0, 0, 0, 0, /* .plt size goes here */
715 0, /* Augmentation size */
716 DW_CFA_def_cfa_offset, 8, /* DW_CFA_def_cfa_offset: 8 */
717 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
718 DW_CFA_def_cfa_offset, 12, /* DW_CFA_def_cfa_offset: 12 */
719 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
720 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
721 11, /* Block length */
722 DW_OP_breg4, 4, /* DW_OP_breg4 (esp): 4 */
723 DW_OP_breg8, 0, /* DW_OP_breg8 (eip): 0 */
724 DW_OP_lit15, DW_OP_and, DW_OP_lit9, DW_OP_ge,
725 DW_OP_lit2, DW_OP_shl, DW_OP_plus,
726 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
729 /* .eh_frame covering the non-lazy .plt section. */
731 static const bfd_byte elf_i386_eh_frame_non_lazy_plt[] =
733 #define PLT_GOT_FDE_LENGTH 16
734 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
735 0, 0, 0, 0, /* CIE ID */
737 'z', 'R', 0, /* Augmentation string */
738 1, /* Code alignment factor */
739 0x7c, /* Data alignment factor */
740 8, /* Return address column */
741 1, /* Augmentation size */
742 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
743 DW_CFA_def_cfa, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
744 DW_CFA_offset + 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
745 DW_CFA_nop, DW_CFA_nop,
747 PLT_GOT_FDE_LENGTH, 0, 0, 0, /* FDE length */
748 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
749 0, 0, 0, 0, /* the start of non-lazy .plt goes here */
750 0, 0, 0, 0, /* non-lazy .plt size goes here */
751 0, /* Augmentation size */
752 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
755 /* These are the standard parameters. */
756 static const struct elf_x86_lazy_plt_layout elf_i386_lazy_plt =
758 elf_i386_lazy_plt0_entry, /* plt0_entry */
759 sizeof (elf_i386_lazy_plt0_entry), /* plt0_entry_size */
760 elf_i386_lazy_plt_entry, /* plt_entry */
761 LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */
762 2, /* plt0_got1_offset */
763 8, /* plt0_got2_offset */
764 0, /* plt0_got2_insn_end */
765 2, /* plt_got_offset */
766 7, /* plt_reloc_offset */
767 12, /* plt_plt_offset */
768 0, /* plt_got_insn_size */
769 0, /* plt_plt_insn_end */
770 6, /* plt_lazy_offset */
771 elf_i386_pic_lazy_plt0_entry, /* pic_plt0_entry */
772 elf_i386_pic_lazy_plt_entry, /* pic_plt_entry */
773 elf_i386_eh_frame_lazy_plt, /* eh_frame_plt */
774 sizeof (elf_i386_eh_frame_lazy_plt) /* eh_frame_plt_size */
777 static const struct elf_x86_non_lazy_plt_layout elf_i386_non_lazy_plt =
779 elf_i386_non_lazy_plt_entry, /* plt_entry */
780 elf_i386_pic_non_lazy_plt_entry, /* pic_plt_entry */
781 NON_LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */
782 2, /* plt_got_offset */
783 0, /* plt_got_insn_size */
784 elf_i386_eh_frame_non_lazy_plt, /* eh_frame_plt */
785 sizeof (elf_i386_eh_frame_non_lazy_plt) /* eh_frame_plt_size */
788 static const struct elf_x86_lazy_plt_layout elf_i386_lazy_ibt_plt =
790 elf_i386_lazy_ibt_plt0_entry, /* plt0_entry */
791 sizeof (elf_i386_lazy_ibt_plt0_entry), /* plt0_entry_size */
792 elf_i386_lazy_ibt_plt_entry, /* plt_entry */
793 LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */
794 2, /* plt0_got1_offset */
795 8, /* plt0_got2_offset */
796 0, /* plt0_got2_insn_end */
797 4+2, /* plt_got_offset */
798 4+1, /* plt_reloc_offset */
799 4+6, /* plt_plt_offset */
800 0, /* plt_got_insn_size */
801 0, /* plt_plt_insn_end */
802 0, /* plt_lazy_offset */
803 elf_i386_pic_lazy_ibt_plt0_entry, /* pic_plt0_entry */
804 elf_i386_lazy_ibt_plt_entry, /* pic_plt_entry */
805 elf_i386_eh_frame_lazy_ibt_plt, /* eh_frame_plt */
806 sizeof (elf_i386_eh_frame_lazy_ibt_plt) /* eh_frame_plt_size */
809 static const struct elf_x86_non_lazy_plt_layout elf_i386_non_lazy_ibt_plt =
811 elf_i386_non_lazy_ibt_plt_entry, /* plt_entry */
812 elf_i386_pic_non_lazy_ibt_plt_entry,/* pic_plt_entry */
813 LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */
814 4+2, /* plt_got_offset */
815 0, /* plt_got_insn_size */
816 elf_i386_eh_frame_non_lazy_plt, /* eh_frame_plt */
817 sizeof (elf_i386_eh_frame_non_lazy_plt) /* eh_frame_plt_size */
821 /* On VxWorks, the .rel.plt.unloaded section has absolute relocations
822 for the PLTResolve stub and then for each PLT entry. */
823 #define PLTRESOLVE_RELOCS_SHLIB 0
824 #define PLTRESOLVE_RELOCS 2
825 #define PLT_NON_JUMP_SLOT_RELOCS 2
827 /* Architecture-specific backend data for i386. */
829 struct elf_i386_backend_data
831 /* Value used to fill the unused bytes of the first PLT entry. */
832 bfd_byte plt0_pad_byte;
843 #define get_elf_i386_backend_data(abfd) \
844 ((const struct elf_i386_backend_data *) \
845 get_elf_backend_data (abfd)->arch_data)
847 /* These are the standard parameters. */
848 static const struct elf_i386_backend_data elf_i386_arch_bed =
850 0, /* plt0_pad_byte */
854 #define elf_backend_arch_data &elf_i386_arch_bed
856 /* Values in tls_type of x86 ELF linker hash entry. */
858 #define GOT_TLS_IE_POS 5
859 #define GOT_TLS_IE_NEG 6
860 #define GOT_TLS_IE_BOTH 7
861 #define GOT_TLS_GDESC 8
862 #define GOT_TLS_GD_BOTH_P(type) \
863 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
864 #define GOT_TLS_GD_P(type) \
865 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
866 #define GOT_TLS_GDESC_P(type) \
867 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
868 #define GOT_TLS_GD_ANY_P(type) \
869 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
871 #define is_i386_elf(bfd) \
872 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
873 && elf_tdata (bfd) != NULL \
874 && elf_object_id (bfd) == I386_ELF_DATA)
876 #define elf_i386_compute_jump_table_size(htab) \
877 ((htab)->elf.srelplt->reloc_count * 4)
879 /* Return TRUE if the TLS access code sequence support transition
883 elf_i386_check_tls_transition (asection *sec,
885 Elf_Internal_Shdr *symtab_hdr,
886 struct elf_link_hash_entry **sym_hashes,
888 const Elf_Internal_Rela *rel,
889 const Elf_Internal_Rela *relend)
891 unsigned int val, type, reg;
892 unsigned long r_symndx;
893 struct elf_link_hash_entry *h;
896 bfd_boolean indirect_call;
898 offset = rel->r_offset;
903 if (offset < 2 || (rel + 1) >= relend)
906 indirect_call = FALSE;
907 call = contents + offset + 4;
910 if (r_type == R_386_TLS_GD)
912 /* Check transition from GD access model. Only
913 leal foo@tlsgd(,%ebx,1), %eax
914 call ___tls_get_addr@PLT
916 leal foo@tlsgd(%ebx) %eax
917 call ___tls_get_addr@PLT
920 leal foo@tlsgd(%reg), %eax
921 call *___tls_get_addr@GOT(%reg)
922 which may be converted to
923 addr32 call ___tls_get_addr
924 can transit to different access model. */
925 if ((offset + 10) > sec->size
926 || (type != 0x8d && type != 0x04))
931 /* leal foo@tlsgd(,%ebx,1), %eax
932 call ___tls_get_addr@PLT */
936 if (*(call - 7) != 0x8d
944 leal foo@tlsgd(%ebx), %eax
945 call ___tls_get_addr@PLT
948 leal foo@tlsgd(%reg), %eax
949 call *___tls_get_addr@GOT(%reg)
950 which may be converted to
951 addr32 call ___tls_get_addr
953 %eax can't be used as the GOT base register since it
954 is used to pass parameter to ___tls_get_addr. */
956 if ((val & 0xf8) != 0x80 || reg == 4 || reg == 0)
959 indirect_call = call[0] == 0xff;
960 if (!(reg == 3 && call[0] == 0xe8 && call[5] == 0x90)
961 && !(call[0] == 0x67 && call[1] == 0xe8)
963 && (call[1] & 0xf8) == 0x90
964 && (call[1] & 0x7) == reg))
970 /* Check transition from LD access model. Only
971 leal foo@tlsldm(%ebx), %eax
972 call ___tls_get_addr@PLT
974 leal foo@tlsldm(%reg), %eax
975 call *___tls_get_addr@GOT(%reg)
976 which may be converted to
977 addr32 call ___tls_get_addr
978 can transit to different access model. */
979 if (type != 0x8d || (offset + 9) > sec->size)
982 /* %eax can't be used as the GOT base register since it is
983 used to pass parameter to ___tls_get_addr. */
985 if ((val & 0xf8) != 0x80 || reg == 4 || reg == 0)
988 indirect_call = call[0] == 0xff;
989 if (!(reg == 3 && call[0] == 0xe8)
990 && !(call[0] == 0x67 && call[1] == 0xe8)
992 && (call[1] & 0xf8) == 0x90
993 && (call[1] & 0x7) == reg))
997 r_symndx = ELF32_R_SYM (rel[1].r_info);
998 if (r_symndx < symtab_hdr->sh_info)
1001 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1003 || !((struct elf_x86_link_hash_entry *) h)->tls_get_addr)
1005 else if (indirect_call)
1006 return (ELF32_R_TYPE (rel[1].r_info) == R_386_GOT32X);
1008 return (ELF32_R_TYPE (rel[1].r_info) == R_386_PC32
1009 || ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
1012 /* Check transition from IE access model:
1013 movl foo@indntpoff(%rip), %eax
1014 movl foo@indntpoff(%rip), %reg
1015 addl foo@indntpoff(%rip), %reg
1018 if (offset < 1 || (offset + 4) > sec->size)
1021 /* Check "movl foo@tpoff(%rip), %eax" first. */
1022 val = bfd_get_8 (abfd, contents + offset - 1);
1029 /* Check movl|addl foo@tpoff(%rip), %reg. */
1030 type = bfd_get_8 (abfd, contents + offset - 2);
1031 return ((type == 0x8b || type == 0x03)
1032 && (val & 0xc7) == 0x05);
1034 case R_386_TLS_GOTIE:
1035 case R_386_TLS_IE_32:
1036 /* Check transition from {IE_32,GOTIE} access model:
1037 subl foo@{tpoff,gontoff}(%reg1), %reg2
1038 movl foo@{tpoff,gontoff}(%reg1), %reg2
1039 addl foo@{tpoff,gontoff}(%reg1), %reg2
1042 if (offset < 2 || (offset + 4) > sec->size)
1045 val = bfd_get_8 (abfd, contents + offset - 1);
1046 if ((val & 0xc0) != 0x80 || (val & 7) == 4)
1049 type = bfd_get_8 (abfd, contents + offset - 2);
1050 return type == 0x8b || type == 0x2b || type == 0x03;
1052 case R_386_TLS_GOTDESC:
1053 /* Check transition from GDesc access model:
1054 leal x@tlsdesc(%ebx), %eax
1056 Make sure it's a leal adding ebx to a 32-bit offset
1057 into any register, although it's probably almost always
1060 if (offset < 2 || (offset + 4) > sec->size)
1063 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1066 val = bfd_get_8 (abfd, contents + offset - 1);
1067 return (val & 0xc7) == 0x83;
1069 case R_386_TLS_DESC_CALL:
1070 /* Check transition from GDesc access model:
1071 call *x@tlsdesc(%eax)
1073 if (offset + 2 <= sec->size)
1075 /* Make sure that it's a call *x@tlsdesc(%eax). */
1076 call = contents + offset;
1077 return call[0] == 0xff && call[1] == 0x10;
1087 /* Return TRUE if the TLS access transition is OK or no transition
1088 will be performed. Update R_TYPE if there is a transition. */
1091 elf_i386_tls_transition (struct bfd_link_info *info, bfd *abfd,
1092 asection *sec, bfd_byte *contents,
1093 Elf_Internal_Shdr *symtab_hdr,
1094 struct elf_link_hash_entry **sym_hashes,
1095 unsigned int *r_type, int tls_type,
1096 const Elf_Internal_Rela *rel,
1097 const Elf_Internal_Rela *relend,
1098 struct elf_link_hash_entry *h,
1099 unsigned long r_symndx,
1100 bfd_boolean from_relocate_section)
1102 unsigned int from_type = *r_type;
1103 unsigned int to_type = from_type;
1104 bfd_boolean check = TRUE;
1106 /* Skip TLS transition for functions. */
1108 && (h->type == STT_FUNC
1109 || h->type == STT_GNU_IFUNC))
1115 case R_386_TLS_GOTDESC:
1116 case R_386_TLS_DESC_CALL:
1117 case R_386_TLS_IE_32:
1119 case R_386_TLS_GOTIE:
1120 if (bfd_link_executable (info))
1123 to_type = R_386_TLS_LE_32;
1124 else if (from_type != R_386_TLS_IE
1125 && from_type != R_386_TLS_GOTIE)
1126 to_type = R_386_TLS_IE_32;
1129 /* When we are called from elf_i386_relocate_section, there may
1130 be additional transitions based on TLS_TYPE. */
1131 if (from_relocate_section)
1133 unsigned int new_to_type = to_type;
1135 if (bfd_link_executable (info)
1138 && (tls_type & GOT_TLS_IE))
1139 new_to_type = R_386_TLS_LE_32;
1141 if (to_type == R_386_TLS_GD
1142 || to_type == R_386_TLS_GOTDESC
1143 || to_type == R_386_TLS_DESC_CALL)
1145 if (tls_type == GOT_TLS_IE_POS)
1146 new_to_type = R_386_TLS_GOTIE;
1147 else if (tls_type & GOT_TLS_IE)
1148 new_to_type = R_386_TLS_IE_32;
1151 /* We checked the transition before when we were called from
1152 elf_i386_check_relocs. We only want to check the new
1153 transition which hasn't been checked before. */
1154 check = new_to_type != to_type && from_type == to_type;
1155 to_type = new_to_type;
1161 if (bfd_link_executable (info))
1162 to_type = R_386_TLS_LE_32;
1169 /* Return TRUE if there is no transition. */
1170 if (from_type == to_type)
1173 /* Check if the transition can be performed. */
1175 && ! elf_i386_check_tls_transition (sec, contents,
1176 symtab_hdr, sym_hashes,
1177 from_type, rel, relend))
1179 reloc_howto_type *from, *to;
1182 from = elf_i386_rtype_to_howto (abfd, from_type);
1183 to = elf_i386_rtype_to_howto (abfd, to_type);
1186 name = h->root.root.string;
1189 struct elf_x86_link_hash_table *htab;
1191 htab = elf_x86_hash_table (info, I386_ELF_DATA);
1196 Elf_Internal_Sym *isym;
1198 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1200 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1205 /* xgettext:c-format */
1206 (_("%B: TLS transition from %s to %s against `%s' at %#Lx "
1207 "in section `%A' failed"),
1208 abfd, from->name, to->name, name,
1209 rel->r_offset, sec);
1210 bfd_set_error (bfd_error_bad_value);
1218 /* With the local symbol, foo, we convert
1219 mov foo@GOT[(%reg1)], %reg2
1221 lea foo[@GOTOFF(%reg1)], %reg2
1223 call/jmp *foo@GOT[(%reg)]
1225 nop call foo/jmp foo nop
1226 When PIC is false, convert
1227 test %reg1, foo@GOT[(%reg2)]
1231 binop foo@GOT[(%reg1)], %reg2
1234 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1239 elf_i386_convert_load_reloc (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
1241 Elf_Internal_Rela *irel,
1242 struct elf_link_hash_entry *h,
1243 bfd_boolean *converted,
1244 struct bfd_link_info *link_info)
1246 struct elf_x86_link_hash_table *htab;
1247 unsigned int opcode;
1249 bfd_boolean baseless;
1250 Elf_Internal_Sym *isym;
1251 unsigned int addend;
1255 bfd_boolean to_reloc_32;
1256 unsigned int r_type;
1257 unsigned int r_symndx;
1258 bfd_vma roff = irel->r_offset;
1263 /* Addend for R_386_GOT32X relocations must be 0. */
1264 addend = bfd_get_32 (abfd, contents + roff);
1268 htab = elf_x86_hash_table (link_info, I386_ELF_DATA);
1269 is_pic = bfd_link_pic (link_info);
1271 r_type = ELF32_R_TYPE (irel->r_info);
1272 r_symndx = ELF32_R_SYM (irel->r_info);
1274 modrm = bfd_get_8 (abfd, contents + roff - 1);
1275 baseless = (modrm & 0xc7) == 0x5;
1277 if (baseless && is_pic)
1279 /* For PIC, disallow R_386_GOT32X without a base register
1280 since we don't know what the GOT base is. */
1285 isym = bfd_sym_from_r_symndx (&htab->sym_cache, abfd,
1287 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1290 name = h->root.root.string;
1293 /* xgettext:c-format */
1294 (_("%B: direct GOT relocation R_386_GOT32X against `%s' without base"
1295 " register can not be used when making a shared object"),
1300 opcode = bfd_get_8 (abfd, contents + roff - 2);
1302 /* Convert to R_386_32 if PIC is false or there is no base
1304 to_reloc_32 = !is_pic || baseless;
1306 /* Try to convert R_386_GOT32X. Get the symbol referred to by the
1310 if (opcode == 0x0ff)
1311 /* Convert "call/jmp *foo@GOT[(%reg)]". */
1312 goto convert_branch;
1314 /* Convert "mov foo@GOT[(%reg1)], %reg2",
1315 "test %reg1, foo@GOT(%reg2)" and
1316 "binop foo@GOT[(%reg1)], %reg2". */
1320 /* Undefined weak symbol is only bound locally in executable
1321 and its reference is resolved as 0. */
1322 if (UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info, I386_ELF_DATA, TRUE,
1323 elf_x86_hash_entry (h)))
1327 /* No direct branch to 0 for PIC. */
1331 goto convert_branch;
1335 /* We can convert load of address 0 to R_386_32. */
1343 /* We have "call/jmp *foo@GOT[(%reg)]". */
1344 if ((h->root.type == bfd_link_hash_defined
1345 || h->root.type == bfd_link_hash_defweak)
1346 && SYMBOL_REFERENCES_LOCAL (link_info, h))
1348 /* The function is locally defined. */
1350 /* Convert R_386_GOT32X to R_386_PC32. */
1351 if (modrm == 0x15 || (modrm & 0xf8) == 0x90)
1353 struct elf_x86_link_hash_entry *eh
1354 = (struct elf_x86_link_hash_entry *) h;
1356 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
1359 /* To support TLS optimization, always use addr32 prefix
1360 for "call *___tls_get_addr@GOT(%reg)". */
1361 if (eh && eh->tls_get_addr)
1364 nop_offset = irel->r_offset - 2;
1368 nop = link_info->call_nop_byte;
1369 if (link_info->call_nop_as_suffix)
1371 nop_offset = roff + 3;
1372 irel->r_offset -= 1;
1375 nop_offset = roff - 2;
1380 /* Convert to "jmp foo nop". */
1383 nop_offset = roff + 3;
1384 irel->r_offset -= 1;
1387 bfd_put_8 (abfd, nop, contents + nop_offset);
1388 bfd_put_8 (abfd, modrm, contents + irel->r_offset - 1);
1389 /* When converting to PC-relative relocation, we
1390 need to adjust addend by -4. */
1391 bfd_put_32 (abfd, -4, contents + irel->r_offset);
1392 irel->r_info = ELF32_R_INFO (r_symndx, R_386_PC32);
1399 /* We have "mov foo@GOT[(%re1g)], %reg2",
1400 "test %reg1, foo@GOT(%reg2)" and
1401 "binop foo@GOT[(%reg1)], %reg2".
1403 Avoid optimizing _DYNAMIC since ld.so may use its
1404 link-time address. */
1405 if (h == htab->elf.hdynamic)
1408 /* def_regular is set by an assignment in a linker script in
1409 bfd_elf_record_link_assignment. start_stop is set on
1410 __start_SECNAME/__stop_SECNAME which mark section SECNAME. */
1413 || h->root.type == bfd_link_hash_defined
1414 || h->root.type == bfd_link_hash_defweak)
1415 && SYMBOL_REFERENCES_LOCAL (link_info, h)))
1422 /* Convert "mov foo@GOT[(%reg1)], %reg2" to
1423 "mov $foo, %reg2" with R_386_32. */
1425 modrm = 0xc0 | (modrm & 0x38) >> 3;
1426 bfd_put_8 (abfd, modrm, contents + roff - 1);
1431 /* Convert "mov foo@GOT(%reg1), %reg2" to
1432 "lea foo@GOTOFF(%reg1), %reg2". */
1433 r_type = R_386_GOTOFF;
1439 /* Only R_386_32 is supported. */
1445 /* Convert "test %reg1, foo@GOT(%reg2)" to
1446 "test $foo, %reg1". */
1447 modrm = 0xc0 | (modrm & 0x38) >> 3;
1452 /* Convert "binop foo@GOT(%reg1), %reg2" to
1453 "binop $foo, %reg2". */
1455 | (modrm & 0x38) >> 3
1459 bfd_put_8 (abfd, modrm, contents + roff - 1);
1463 bfd_put_8 (abfd, opcode, contents + roff - 2);
1464 irel->r_info = ELF32_R_INFO (r_symndx, r_type);
1473 /* Rename some of the generic section flags to better document how they
1475 #define need_convert_load sec_flg0
1476 #define check_relocs_failed sec_flg1
1478 /* Look through the relocs for a section during the first phase, and
1479 calculate needed space in the global offset table, procedure linkage
1480 table, and dynamic reloc sections. */
1483 elf_i386_check_relocs (bfd *abfd,
1484 struct bfd_link_info *info,
1486 const Elf_Internal_Rela *relocs)
1488 struct elf_x86_link_hash_table *htab;
1489 Elf_Internal_Shdr *symtab_hdr;
1490 struct elf_link_hash_entry **sym_hashes;
1491 const Elf_Internal_Rela *rel;
1492 const Elf_Internal_Rela *rel_end;
1496 if (bfd_link_relocatable (info))
1499 /* Don't do anything special with non-loaded, non-alloced sections.
1500 In particular, any relocs in such sections should not affect GOT
1501 and PLT reference counting (ie. we don't allow them to create GOT
1502 or PLT entries), there's no possibility or desire to optimize TLS
1503 relocs, and there's not much point in propagating relocs to shared
1504 libs that the dynamic linker won't relocate. */
1505 if ((sec->flags & SEC_ALLOC) == 0)
1508 BFD_ASSERT (is_i386_elf (abfd));
1510 htab = elf_x86_hash_table (info, I386_ELF_DATA);
1513 sec->check_relocs_failed = 1;
1517 /* Get the section contents. */
1518 if (elf_section_data (sec)->this_hdr.contents != NULL)
1519 contents = elf_section_data (sec)->this_hdr.contents;
1520 else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1522 sec->check_relocs_failed = 1;
1526 symtab_hdr = &elf_symtab_hdr (abfd);
1527 sym_hashes = elf_sym_hashes (abfd);
1531 rel_end = relocs + sec->reloc_count;
1532 for (rel = relocs; rel < rel_end; rel++)
1534 unsigned int r_type;
1535 unsigned int r_symndx;
1536 struct elf_link_hash_entry *h;
1537 struct elf_x86_link_hash_entry *eh;
1538 Elf_Internal_Sym *isym;
1540 bfd_boolean size_reloc;
1542 r_symndx = ELF32_R_SYM (rel->r_info);
1543 r_type = ELF32_R_TYPE (rel->r_info);
1545 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1547 /* xgettext:c-format */
1548 _bfd_error_handler (_("%B: bad symbol index: %d"),
1553 if (r_symndx < symtab_hdr->sh_info)
1555 /* A local symbol. */
1556 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1561 /* Check relocation against local STT_GNU_IFUNC symbol. */
1562 if (ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1564 h = _bfd_elf_x86_get_local_sym_hash (htab, abfd, rel, TRUE);
1568 /* Fake a STT_GNU_IFUNC symbol. */
1569 h->root.root.string = bfd_elf_sym_name (abfd, symtab_hdr,
1571 h->type = STT_GNU_IFUNC;
1574 h->forced_local = 1;
1575 h->root.type = bfd_link_hash_defined;
1583 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1584 while (h->root.type == bfd_link_hash_indirect
1585 || h->root.type == bfd_link_hash_warning)
1586 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1589 eh = (struct elf_x86_link_hash_entry *) h;
1592 if (r_type == R_386_GOTOFF)
1595 /* It is referenced by a non-shared object. */
1597 h->root.non_ir_ref_regular = 1;
1599 if (h->type == STT_GNU_IFUNC)
1600 elf_tdata (info->output_bfd)->has_gnu_symbols
1601 |= elf_gnu_symbol_ifunc;
1604 if (! elf_i386_tls_transition (info, abfd, sec, contents,
1605 symtab_hdr, sym_hashes,
1606 &r_type, GOT_UNKNOWN,
1607 rel, rel_end, h, r_symndx, FALSE))
1613 htab->tls_ld_or_ldm_got.refcount += 1;
1617 /* This symbol requires a procedure linkage table entry. We
1618 actually build the entry in adjust_dynamic_symbol,
1619 because this might be a case of linking PIC code which is
1620 never referenced by a dynamic object, in which case we
1621 don't need to generate a procedure linkage table entry
1624 /* If this is a local symbol, we resolve it directly without
1625 creating a procedure linkage table entry. */
1629 eh->has_got_reloc = 1;
1631 h->plt.refcount += 1;
1638 case R_386_TLS_IE_32:
1640 case R_386_TLS_GOTIE:
1641 if (!bfd_link_executable (info))
1642 info->flags |= DF_STATIC_TLS;
1648 case R_386_TLS_GOTDESC:
1649 case R_386_TLS_DESC_CALL:
1650 /* This symbol requires a global offset table entry. */
1652 int tls_type, old_tls_type;
1659 tls_type = GOT_NORMAL;
1661 case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
1662 case R_386_TLS_GOTDESC:
1663 case R_386_TLS_DESC_CALL:
1664 tls_type = GOT_TLS_GDESC; break;
1665 case R_386_TLS_IE_32:
1666 if (ELF32_R_TYPE (rel->r_info) == r_type)
1667 tls_type = GOT_TLS_IE_NEG;
1669 /* If this is a GD->IE transition, we may use either of
1670 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
1671 tls_type = GOT_TLS_IE;
1674 case R_386_TLS_GOTIE:
1675 tls_type = GOT_TLS_IE_POS; break;
1680 h->got.refcount += 1;
1681 old_tls_type = elf_x86_hash_entry (h)->tls_type;
1685 bfd_signed_vma *local_got_refcounts;
1687 /* This is a global offset table entry for a local symbol. */
1688 local_got_refcounts = elf_local_got_refcounts (abfd);
1689 if (local_got_refcounts == NULL)
1693 size = symtab_hdr->sh_info;
1694 size *= (sizeof (bfd_signed_vma)
1695 + sizeof (bfd_vma) + sizeof(char));
1696 local_got_refcounts = (bfd_signed_vma *)
1697 bfd_zalloc (abfd, size);
1698 if (local_got_refcounts == NULL)
1700 elf_local_got_refcounts (abfd) = local_got_refcounts;
1701 elf_x86_local_tlsdesc_gotent (abfd)
1702 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
1703 elf_x86_local_got_tls_type (abfd)
1704 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
1706 local_got_refcounts[r_symndx] += 1;
1707 old_tls_type = elf_x86_local_got_tls_type (abfd) [r_symndx];
1710 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1711 tls_type |= old_tls_type;
1712 /* If a TLS symbol is accessed using IE at least once,
1713 there is no point to use dynamic model for it. */
1714 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1715 && (! GOT_TLS_GD_ANY_P (old_tls_type)
1716 || (tls_type & GOT_TLS_IE) == 0))
1718 if ((old_tls_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (tls_type))
1719 tls_type = old_tls_type;
1720 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1721 && GOT_TLS_GD_ANY_P (tls_type))
1722 tls_type |= old_tls_type;
1726 name = h->root.root.string;
1728 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1731 /* xgettext:c-format */
1732 (_("%B: `%s' accessed both as normal and "
1733 "thread local symbol"),
1735 bfd_set_error (bfd_error_bad_value);
1740 if (old_tls_type != tls_type)
1743 elf_x86_hash_entry (h)->tls_type = tls_type;
1745 elf_x86_local_got_tls_type (abfd) [r_symndx] = tls_type;
1753 if (r_type != R_386_TLS_IE)
1756 eh->has_got_reloc = 1;
1761 case R_386_TLS_LE_32:
1764 eh->has_got_reloc = 1;
1765 if (bfd_link_executable (info))
1767 info->flags |= DF_STATIC_TLS;
1772 if (eh != NULL && (sec->flags & SEC_CODE) != 0)
1773 eh->has_non_got_reloc = 1;
1775 /* We are called after all symbols have been resolved. Only
1776 relocation against STT_GNU_IFUNC symbol must go through
1779 && (bfd_link_executable (info)
1780 || h->type == STT_GNU_IFUNC))
1782 /* If this reloc is in a read-only section, we might
1783 need a copy reloc. We can't check reliably at this
1784 stage whether the section is read-only, as input
1785 sections have not yet been mapped to output sections.
1786 Tentatively set the flag for now, and correct in
1787 adjust_dynamic_symbol. */
1790 /* We may need a .plt entry if the symbol is a function
1791 defined in a shared lib or is a STT_GNU_IFUNC function
1792 referenced from the code or read-only section. */
1794 || (sec->flags & (SEC_CODE | SEC_READONLY)) != 0)
1795 h->plt.refcount += 1;
1797 if (r_type == R_386_PC32)
1799 /* Since something like ".long foo - ." may be used
1800 as pointer, make sure that PLT is used if foo is
1801 a function defined in a shared library. */
1802 if ((sec->flags & SEC_CODE) == 0)
1803 h->pointer_equality_needed = 1;
1804 else if (h->type == STT_GNU_IFUNC
1805 && bfd_link_pic (info))
1808 /* xgettext:c-format */
1809 (_("%B: unsupported non-PIC call to IFUNC `%s'"),
1810 abfd, h->root.root.string);
1811 bfd_set_error (bfd_error_bad_value);
1817 h->pointer_equality_needed = 1;
1818 /* R_386_32 can be resolved at run-time. */
1819 if (r_type == R_386_32
1820 && (sec->flags & SEC_READONLY) == 0)
1821 eh->func_pointer_refcount += 1;
1827 /* If we are creating a shared library, and this is a reloc
1828 against a global symbol, or a non PC relative reloc
1829 against a local symbol, then we need to copy the reloc
1830 into the shared library. However, if we are linking with
1831 -Bsymbolic, we do not need to copy a reloc against a
1832 global symbol which is defined in an object we are
1833 including in the link (i.e., DEF_REGULAR is set). At
1834 this point we have not seen all the input files, so it is
1835 possible that DEF_REGULAR is not set now but will be set
1836 later (it is never cleared). In case of a weak definition,
1837 DEF_REGULAR may be cleared later by a strong definition in
1838 a shared library. We account for that possibility below by
1839 storing information in the relocs_copied field of the hash
1840 table entry. A similar situation occurs when creating
1841 shared libraries and symbol visibility changes render the
1844 If on the other hand, we are creating an executable, we
1845 may need to keep relocations for symbols satisfied by a
1846 dynamic library if we manage to avoid copy relocs for the
1849 Generate dynamic pointer relocation against STT_GNU_IFUNC
1850 symbol in the non-code section. */
1851 if ((bfd_link_pic (info)
1852 && (r_type != R_386_PC32
1854 && (! (bfd_link_pie (info)
1855 || SYMBOLIC_BIND (info, h))
1856 || h->root.type == bfd_link_hash_defweak
1857 || !h->def_regular))))
1859 && h->type == STT_GNU_IFUNC
1860 && r_type == R_386_32
1861 && (sec->flags & SEC_CODE) == 0)
1862 || (ELIMINATE_COPY_RELOCS
1863 && !bfd_link_pic (info)
1865 && (h->root.type == bfd_link_hash_defweak
1866 || !h->def_regular)))
1868 struct elf_dyn_relocs *p;
1869 struct elf_dyn_relocs **head;
1871 /* We must copy these reloc types into the output file.
1872 Create a reloc section in dynobj and make room for
1876 sreloc = _bfd_elf_make_dynamic_reloc_section
1877 (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ FALSE);
1883 /* If this is a global symbol, we count the number of
1884 relocations we need for this symbol. */
1887 head = &eh->dyn_relocs;
1891 /* Track dynamic relocs needed for local syms too.
1892 We really need local syms available to do this
1897 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1902 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1906 vpp = &elf_section_data (s)->local_dynrel;
1907 head = (struct elf_dyn_relocs **)vpp;
1911 if (p == NULL || p->sec != sec)
1913 bfd_size_type amt = sizeof *p;
1914 p = (struct elf_dyn_relocs *) bfd_alloc (htab->elf.dynobj,
1926 /* Count size relocation as PC-relative relocation. */
1927 if (r_type == R_386_PC32 || size_reloc)
1932 /* This relocation describes the C++ object vtable hierarchy.
1933 Reconstruct it for later use during GC. */
1934 case R_386_GNU_VTINHERIT:
1935 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1939 /* This relocation describes which C++ vtable entries are actually
1940 used. Record for later use during GC. */
1941 case R_386_GNU_VTENTRY:
1942 BFD_ASSERT (h != NULL);
1944 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
1952 if (r_type == R_386_GOT32X
1953 && (h == NULL || h->type != STT_GNU_IFUNC))
1954 sec->need_convert_load = 1;
1957 if (elf_section_data (sec)->this_hdr.contents != contents)
1959 if (!info->keep_memory)
1963 /* Cache the section contents for elf_link_input_bfd. */
1964 elf_section_data (sec)->this_hdr.contents = contents;
1971 if (elf_section_data (sec)->this_hdr.contents != contents)
1973 sec->check_relocs_failed = 1;
1977 /* Return the section that should be marked against GC for a given
1981 elf_i386_gc_mark_hook (asection *sec,
1982 struct bfd_link_info *info,
1983 Elf_Internal_Rela *rel,
1984 struct elf_link_hash_entry *h,
1985 Elf_Internal_Sym *sym)
1988 switch (ELF32_R_TYPE (rel->r_info))
1990 case R_386_GNU_VTINHERIT:
1991 case R_386_GNU_VTENTRY:
1995 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1998 /* Adjust a symbol defined by a dynamic object and referenced by a
1999 regular object. The current definition is in some section of the
2000 dynamic object, but we're not including those sections. We have to
2001 change the definition to something the rest of the link can
2005 elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info,
2006 struct elf_link_hash_entry *h)
2008 struct elf_x86_link_hash_table *htab;
2010 struct elf_x86_link_hash_entry *eh;
2011 struct elf_dyn_relocs *p;
2013 /* STT_GNU_IFUNC symbol must go through PLT. */
2014 if (h->type == STT_GNU_IFUNC)
2016 /* All local STT_GNU_IFUNC references must be treate as local
2017 calls via local PLT. */
2019 && SYMBOL_CALLS_LOCAL (info, h))
2021 bfd_size_type pc_count = 0, count = 0;
2022 struct elf_dyn_relocs **pp;
2024 eh = (struct elf_x86_link_hash_entry *) h;
2025 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2027 pc_count += p->pc_count;
2028 p->count -= p->pc_count;
2037 if (pc_count || count)
2042 /* Increment PLT reference count only for PC-relative
2045 if (h->plt.refcount <= 0)
2046 h->plt.refcount = 1;
2048 h->plt.refcount += 1;
2053 if (h->plt.refcount <= 0)
2055 h->plt.offset = (bfd_vma) -1;
2061 /* If this is a function, put it in the procedure linkage table. We
2062 will fill in the contents of the procedure linkage table later,
2063 when we know the address of the .got section. */
2064 if (h->type == STT_FUNC
2067 if (h->plt.refcount <= 0
2068 || SYMBOL_CALLS_LOCAL (info, h)
2069 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2070 && h->root.type == bfd_link_hash_undefweak))
2072 /* This case can occur if we saw a PLT32 reloc in an input
2073 file, but the symbol was never referred to by a dynamic
2074 object, or if all references were garbage collected. In
2075 such a case, we don't actually need to build a procedure
2076 linkage table, and we can just do a PC32 reloc instead. */
2077 h->plt.offset = (bfd_vma) -1;
2084 /* It's possible that we incorrectly decided a .plt reloc was
2085 needed for an R_386_PC32 reloc to a non-function sym in
2086 check_relocs. We can't decide accurately between function and
2087 non-function syms in check-relocs; Objects loaded later in
2088 the link may change h->type. So fix it now. */
2089 h->plt.offset = (bfd_vma) -1;
2091 eh = (struct elf_x86_link_hash_entry *) h;
2093 /* If this is a weak symbol, and there is a real definition, the
2094 processor independent code will have arranged for us to see the
2095 real definition first, and we can just use the same value. */
2096 if (h->u.weakdef != NULL)
2098 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2099 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2100 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2101 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2102 if (ELIMINATE_COPY_RELOCS
2103 || info->nocopyreloc
2104 || SYMBOL_NO_COPYRELOC (info, eh))
2105 h->non_got_ref = h->u.weakdef->non_got_ref;
2109 /* This is a reference to a symbol defined by a dynamic object which
2110 is not a function. */
2112 /* If we are creating a shared library, we must presume that the
2113 only references to the symbol are via the global offset table.
2114 For such cases we need not do anything here; the relocations will
2115 be handled correctly by relocate_section. */
2116 if (!bfd_link_executable (info))
2119 /* If there are no references to this symbol that do not use the
2120 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
2122 if (!h->non_got_ref && !eh->gotoff_ref)
2125 /* If -z nocopyreloc was given, we won't generate them either. */
2126 if (info->nocopyreloc || SYMBOL_NO_COPYRELOC (info, eh))
2132 htab = elf_x86_hash_table (info, I386_ELF_DATA);
2136 /* If there aren't any dynamic relocs in read-only sections nor
2137 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
2138 avoid the copy reloc. This doesn't work on VxWorks, where we can
2139 not have dynamic relocations (other than copy and jump slot
2140 relocations) in an executable. */
2141 if (ELIMINATE_COPY_RELOCS
2143 && get_elf_i386_backend_data (info->output_bfd)->os != is_vxworks)
2145 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2147 s = p->sec->output_section;
2148 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2159 /* We must allocate the symbol in our .dynbss section, which will
2160 become part of the .bss section of the executable. There will be
2161 an entry for this symbol in the .dynsym section. The dynamic
2162 object will contain position independent code, so all references
2163 from the dynamic object to this symbol will go through the global
2164 offset table. The dynamic linker will use the .dynsym entry to
2165 determine the address it must put in the global offset table, so
2166 both the dynamic object and the regular object will refer to the
2167 same memory location for the variable. */
2169 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
2170 copy the initial value out of the dynamic object and into the
2171 runtime process image. */
2172 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
2174 s = htab->elf.sdynrelro;
2175 srel = htab->elf.sreldynrelro;
2179 s = htab->elf.sdynbss;
2180 srel = htab->elf.srelbss;
2182 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2184 srel->size += sizeof (Elf32_External_Rel);
2188 return _bfd_elf_adjust_dynamic_copy (info, h, s);
2191 /* Allocate space in .plt, .got and associated reloc sections for
2195 elf_i386_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
2197 struct bfd_link_info *info;
2198 struct elf_x86_link_hash_table *htab;
2199 struct elf_x86_link_hash_entry *eh;
2200 struct elf_dyn_relocs *p;
2201 unsigned plt_entry_size;
2202 bfd_boolean resolved_to_zero;
2203 const struct elf_i386_backend_data *bed;
2205 if (h->root.type == bfd_link_hash_indirect)
2208 eh = (struct elf_x86_link_hash_entry *) h;
2210 info = (struct bfd_link_info *) inf;
2211 htab = elf_x86_hash_table (info, I386_ELF_DATA);
2215 bed = get_elf_i386_backend_data (info->output_bfd);
2217 plt_entry_size = htab->plt.plt_entry_size;
2219 resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
2224 /* Clear the reference count of function pointer relocations if
2225 symbol isn't a normal function. */
2226 if (h->type != STT_FUNC)
2227 eh->func_pointer_refcount = 0;
2229 /* We can't use the GOT PLT if pointer equality is needed since
2230 finish_dynamic_symbol won't clear symbol value and the dynamic
2231 linker won't update the GOT slot. We will get into an infinite
2232 loop at run-time. */
2233 if (htab->plt_got != NULL
2234 && h->type != STT_GNU_IFUNC
2235 && !h->pointer_equality_needed
2236 && h->plt.refcount > 0
2237 && h->got.refcount > 0)
2239 /* Don't use the regular PLT if there are both GOT and GOTPLT
2241 h->plt.offset = (bfd_vma) -1;
2243 /* Use the GOT PLT. */
2244 eh->plt_got.refcount = 1;
2247 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2248 here if it is defined and referenced in a non-shared object. */
2249 if (h->type == STT_GNU_IFUNC
2252 if (_bfd_elf_allocate_ifunc_dyn_relocs (info, h, &eh->dyn_relocs,
2253 &htab->readonly_dynrelocs_against_ifunc,
2259 asection *s = htab->plt_second;
2260 if (h->plt.offset != (bfd_vma) -1 && s != NULL)
2262 /* Use the second PLT section if it is created. */
2263 eh->plt_second.offset = s->size;
2265 /* Make room for this entry in the second PLT section. */
2266 s->size += htab->non_lazy_plt->plt_entry_size;
2274 /* Don't create the PLT entry if there are only function pointer
2275 relocations which can be resolved at run-time. */
2276 else if (htab->elf.dynamic_sections_created
2277 && (h->plt.refcount > eh->func_pointer_refcount
2278 || eh->plt_got.refcount > 0))
2280 bfd_boolean use_plt_got = eh->plt_got.refcount > 0;
2282 /* Clear the reference count of function pointer relocations
2284 eh->func_pointer_refcount = 0;
2286 /* Make sure this symbol is output as a dynamic symbol.
2287 Undefined weak syms won't yet be marked as dynamic. */
2288 if (h->dynindx == -1
2290 && !resolved_to_zero
2291 && h->root.type == bfd_link_hash_undefweak)
2293 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2297 if (bfd_link_pic (info)
2298 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2300 asection *s = htab->elf.splt;
2301 asection *second_s = htab->plt_second;
2302 asection *got_s = htab->plt_got;
2304 /* If this is the first .plt entry, make room for the special
2305 first entry. The .plt section is used by prelink to undo
2306 prelinking for dynamic relocations. */
2308 s->size = htab->plt.has_plt0 * plt_entry_size;
2311 eh->plt_got.offset = got_s->size;
2314 h->plt.offset = s->size;
2316 eh->plt_second.offset = second_s->size;
2319 /* If this symbol is not defined in a regular file, and we are
2320 not generating a shared library, then set the symbol to this
2321 location in the .plt. This is required to make function
2322 pointers compare as equal between the normal executable and
2323 the shared library. */
2324 if (! bfd_link_pic (info)
2329 /* We need to make a call to the entry of the GOT PLT
2330 instead of regular PLT entry. */
2331 h->root.u.def.section = got_s;
2332 h->root.u.def.value = eh->plt_got.offset;
2338 /* We need to make a call to the entry of the
2339 second PLT instead of regular PLT entry. */
2340 h->root.u.def.section = second_s;
2341 h->root.u.def.value = eh->plt_second.offset;
2345 h->root.u.def.section = s;
2346 h->root.u.def.value = h->plt.offset;
2351 /* Make room for this entry. */
2353 got_s->size += htab->non_lazy_plt->plt_entry_size;
2356 s->size += plt_entry_size;
2358 second_s->size += htab->non_lazy_plt->plt_entry_size;
2360 /* We also need to make an entry in the .got.plt section,
2361 which will be placed in the .got section by the linker
2363 htab->elf.sgotplt->size += 4;
2365 /* There should be no PLT relocation against resolved
2366 undefined weak symbol in executable. */
2367 if (!resolved_to_zero)
2369 /* We also need to make an entry in the .rel.plt
2371 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2372 htab->elf.srelplt->reloc_count++;
2376 if (bed->os == is_vxworks && !bfd_link_pic (info))
2378 /* VxWorks has a second set of relocations for each PLT entry
2379 in executables. They go in a separate relocation section,
2380 which is processed by the kernel loader. */
2382 /* There are two relocations for the initial PLT entry: an
2383 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2384 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
2386 asection *srelplt2 = htab->srelplt2;
2387 if (h->plt.offset == plt_entry_size)
2388 srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2390 /* There are two extra relocations for each subsequent PLT entry:
2391 an R_386_32 relocation for the GOT entry, and an R_386_32
2392 relocation for the PLT entry. */
2394 srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2399 eh->plt_got.offset = (bfd_vma) -1;
2400 h->plt.offset = (bfd_vma) -1;
2406 eh->plt_got.offset = (bfd_vma) -1;
2407 h->plt.offset = (bfd_vma) -1;
2411 eh->tlsdesc_got = (bfd_vma) -1;
2413 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
2414 make it a R_386_TLS_LE_32 requiring no TLS entry. */
2415 if (h->got.refcount > 0
2416 && bfd_link_executable (info)
2418 && (elf_x86_hash_entry (h)->tls_type & GOT_TLS_IE))
2419 h->got.offset = (bfd_vma) -1;
2420 else if (h->got.refcount > 0)
2424 int tls_type = elf_x86_hash_entry (h)->tls_type;
2426 /* Make sure this symbol is output as a dynamic symbol.
2427 Undefined weak syms won't yet be marked as dynamic. */
2428 if (h->dynindx == -1
2430 && !resolved_to_zero
2431 && h->root.type == bfd_link_hash_undefweak)
2433 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2438 if (GOT_TLS_GDESC_P (tls_type))
2440 eh->tlsdesc_got = htab->elf.sgotplt->size
2441 - elf_i386_compute_jump_table_size (htab);
2442 htab->elf.sgotplt->size += 8;
2443 h->got.offset = (bfd_vma) -2;
2445 if (! GOT_TLS_GDESC_P (tls_type)
2446 || GOT_TLS_GD_P (tls_type))
2448 h->got.offset = s->size;
2450 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
2451 if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
2454 dyn = htab->elf.dynamic_sections_created;
2455 /* R_386_TLS_IE_32 needs one dynamic relocation,
2456 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2457 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2458 need two), R_386_TLS_GD needs one if local symbol and two if
2459 global. No dynamic relocation against resolved undefined weak
2460 symbol in executable. */
2461 if (tls_type == GOT_TLS_IE_BOTH)
2462 htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
2463 else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
2464 || (tls_type & GOT_TLS_IE))
2465 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2466 else if (GOT_TLS_GD_P (tls_type))
2467 htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
2468 else if (! GOT_TLS_GDESC_P (tls_type)
2469 && ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2470 && !resolved_to_zero)
2471 || h->root.type != bfd_link_hash_undefweak)
2472 && (bfd_link_pic (info)
2473 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
2474 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2475 if (GOT_TLS_GDESC_P (tls_type))
2476 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2479 h->got.offset = (bfd_vma) -1;
2481 if (eh->dyn_relocs == NULL)
2484 /* In the shared -Bsymbolic case, discard space allocated for
2485 dynamic pc-relative relocs against symbols which turn out to be
2486 defined in regular objects. For the normal shared case, discard
2487 space for pc-relative relocs that have become local due to symbol
2488 visibility changes. */
2490 if (bfd_link_pic (info))
2492 /* The only reloc that uses pc_count is R_386_PC32, which will
2493 appear on a call or on something like ".long foo - .". We
2494 want calls to protected symbols to resolve directly to the
2495 function rather than going via the plt. If people want
2496 function pointer comparisons to work as expected then they
2497 should avoid writing assembly like ".long foo - .". */
2498 if (SYMBOL_CALLS_LOCAL (info, h))
2500 struct elf_dyn_relocs **pp;
2502 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2504 p->count -= p->pc_count;
2513 if (bed->os == is_vxworks)
2515 struct elf_dyn_relocs **pp;
2516 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2518 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2525 /* Also discard relocs on undefined weak syms with non-default
2526 visibility or in PIE. */
2527 if (eh->dyn_relocs != NULL
2528 && h->root.type == bfd_link_hash_undefweak)
2530 /* Undefined weak symbol is never bound locally in shared
2532 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2533 || resolved_to_zero)
2537 /* Keep dynamic non-GOT/non-PLT relocation so that we
2538 can branch to 0 without PLT. */
2539 struct elf_dyn_relocs **pp;
2541 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2542 if (p->pc_count == 0)
2546 /* Remove non-R_386_PC32 relocation. */
2547 p->count = p->pc_count;
2551 if (eh->dyn_relocs != NULL)
2553 /* Make sure undefined weak symbols are output
2554 as dynamic symbols in PIEs for dynamic non-GOT
2555 non-PLT reloations. */
2556 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2561 eh->dyn_relocs = NULL;
2563 else if (h->dynindx == -1
2564 && !h->forced_local)
2566 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2571 else if (ELIMINATE_COPY_RELOCS)
2573 /* For the non-shared case, discard space for relocs against
2574 symbols which turn out to need copy relocs or are not
2575 dynamic. Keep dynamic relocations for run-time function
2576 pointer initialization. */
2578 if ((!h->non_got_ref
2579 || eh->func_pointer_refcount > 0
2580 || (h->root.type == bfd_link_hash_undefweak
2581 && !resolved_to_zero))
2584 || (htab->elf.dynamic_sections_created
2585 && (h->root.type == bfd_link_hash_undefweak
2586 || h->root.type == bfd_link_hash_undefined))))
2588 /* Make sure this symbol is output as a dynamic symbol.
2589 Undefined weak syms won't yet be marked as dynamic. */
2590 if (h->dynindx == -1
2592 && !resolved_to_zero
2593 && h->root.type == bfd_link_hash_undefweak)
2595 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2599 /* If that succeeded, we know we'll be keeping all the
2601 if (h->dynindx != -1)
2605 eh->dyn_relocs = NULL;
2606 eh->func_pointer_refcount = 0;
2611 /* Finally, allocate space. */
2612 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2616 sreloc = elf_section_data (p->sec)->sreloc;
2618 BFD_ASSERT (sreloc != NULL);
2619 sreloc->size += p->count * sizeof (Elf32_External_Rel);
2625 /* Allocate space in .plt, .got and associated reloc sections for
2626 local dynamic relocs. */
2629 elf_i386_allocate_local_dynrelocs (void **slot, void *inf)
2631 struct elf_link_hash_entry *h
2632 = (struct elf_link_hash_entry *) *slot;
2634 if (h->type != STT_GNU_IFUNC
2638 || h->root.type != bfd_link_hash_defined)
2641 return elf_i386_allocate_dynrelocs (h, inf);
2644 /* Convert load via the GOT slot to load immediate. */
2647 elf_i386_convert_load (bfd *abfd, asection *sec,
2648 struct bfd_link_info *link_info)
2650 struct elf_x86_link_hash_table *htab;
2651 Elf_Internal_Shdr *symtab_hdr;
2652 Elf_Internal_Rela *internal_relocs;
2653 Elf_Internal_Rela *irel, *irelend;
2655 bfd_boolean changed;
2656 bfd_signed_vma *local_got_refcounts;
2658 /* Don't even try to convert non-ELF outputs. */
2659 if (!is_elf_hash_table (link_info->hash))
2662 /* Nothing to do if there is no need or no output. */
2663 if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
2664 || sec->need_convert_load == 0
2665 || bfd_is_abs_section (sec->output_section))
2668 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2670 /* Load the relocations for this section. */
2671 internal_relocs = (_bfd_elf_link_read_relocs
2672 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
2673 link_info->keep_memory));
2674 if (internal_relocs == NULL)
2678 htab = elf_x86_hash_table (link_info, I386_ELF_DATA);
2679 local_got_refcounts = elf_local_got_refcounts (abfd);
2681 /* Get the section contents. */
2682 if (elf_section_data (sec)->this_hdr.contents != NULL)
2683 contents = elf_section_data (sec)->this_hdr.contents;
2686 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
2690 irelend = internal_relocs + sec->reloc_count;
2691 for (irel = internal_relocs; irel < irelend; irel++)
2693 unsigned int r_type = ELF32_R_TYPE (irel->r_info);
2694 unsigned int r_symndx;
2695 struct elf_link_hash_entry *h;
2696 bfd_boolean converted;
2698 /* Don't convert R_386_GOT32 since we can't tell if it is applied
2699 to "mov $foo@GOT, %reg" which isn't a load via GOT. */
2700 if (r_type != R_386_GOT32X)
2703 r_symndx = ELF32_R_SYM (irel->r_info);
2704 if (r_symndx < symtab_hdr->sh_info)
2705 h = _bfd_elf_x86_get_local_sym_hash (htab, sec->owner,
2706 (const Elf_Internal_Rela *) irel,
2710 h = elf_sym_hashes (abfd)[r_symndx - symtab_hdr->sh_info];
2711 while (h->root.type == bfd_link_hash_indirect
2712 || h->root.type == bfd_link_hash_warning)
2713 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2716 /* STT_GNU_IFUNC must keep GOT32 relocations. */
2717 if (h != NULL && h->type == STT_GNU_IFUNC)
2721 if (!elf_i386_convert_load_reloc (abfd, symtab_hdr, contents,
2722 irel, h, &converted, link_info))
2727 changed = converted;
2730 if (h->got.refcount > 0)
2731 h->got.refcount -= 1;
2735 if (local_got_refcounts != NULL
2736 && local_got_refcounts[r_symndx] > 0)
2737 local_got_refcounts[r_symndx] -= 1;
2742 if (contents != NULL
2743 && elf_section_data (sec)->this_hdr.contents != contents)
2745 if (!changed && !link_info->keep_memory)
2749 /* Cache the section contents for elf_link_input_bfd. */
2750 elf_section_data (sec)->this_hdr.contents = contents;
2754 if (elf_section_data (sec)->relocs != internal_relocs)
2757 free (internal_relocs);
2759 elf_section_data (sec)->relocs = internal_relocs;
2765 if (contents != NULL
2766 && elf_section_data (sec)->this_hdr.contents != contents)
2768 if (internal_relocs != NULL
2769 && elf_section_data (sec)->relocs != internal_relocs)
2770 free (internal_relocs);
2774 /* Set the sizes of the dynamic sections. */
2777 elf_i386_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
2779 struct elf_x86_link_hash_table *htab;
2785 htab = elf_x86_hash_table (info, I386_ELF_DATA);
2788 dynobj = htab->elf.dynobj;
2792 /* Set up .got offsets for local syms, and space for local dynamic
2794 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2796 bfd_signed_vma *local_got;
2797 bfd_signed_vma *end_local_got;
2798 char *local_tls_type;
2799 bfd_vma *local_tlsdesc_gotent;
2800 bfd_size_type locsymcount;
2801 Elf_Internal_Shdr *symtab_hdr;
2804 if (! is_i386_elf (ibfd))
2807 for (s = ibfd->sections; s != NULL; s = s->next)
2809 struct elf_dyn_relocs *p;
2811 if (!elf_i386_convert_load (ibfd, s, info))
2814 for (p = ((struct elf_dyn_relocs *)
2815 elf_section_data (s)->local_dynrel);
2819 if (!bfd_is_abs_section (p->sec)
2820 && bfd_is_abs_section (p->sec->output_section))
2822 /* Input section has been discarded, either because
2823 it is a copy of a linkonce section or due to
2824 linker script /DISCARD/, so we'll be discarding
2827 else if ((get_elf_i386_backend_data (output_bfd)->os
2829 && strcmp (p->sec->output_section->name,
2832 /* Relocations in vxworks .tls_vars sections are
2833 handled specially by the loader. */
2835 else if (p->count != 0)
2837 srel = elf_section_data (p->sec)->sreloc;
2838 srel->size += p->count * sizeof (Elf32_External_Rel);
2839 if ((p->sec->output_section->flags & SEC_READONLY) != 0
2840 && (info->flags & DF_TEXTREL) == 0)
2842 info->flags |= DF_TEXTREL;
2843 if ((info->warn_shared_textrel && bfd_link_pic (info))
2844 || info->error_textrel)
2845 /* xgettext:c-format */
2846 info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
2847 p->sec->owner, p->sec);
2853 local_got = elf_local_got_refcounts (ibfd);
2857 symtab_hdr = &elf_symtab_hdr (ibfd);
2858 locsymcount = symtab_hdr->sh_info;
2859 end_local_got = local_got + locsymcount;
2860 local_tls_type = elf_x86_local_got_tls_type (ibfd);
2861 local_tlsdesc_gotent = elf_x86_local_tlsdesc_gotent (ibfd);
2863 srel = htab->elf.srelgot;
2864 for (; local_got < end_local_got;
2865 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
2867 *local_tlsdesc_gotent = (bfd_vma) -1;
2870 if (GOT_TLS_GDESC_P (*local_tls_type))
2872 *local_tlsdesc_gotent = htab->elf.sgotplt->size
2873 - elf_i386_compute_jump_table_size (htab);
2874 htab->elf.sgotplt->size += 8;
2875 *local_got = (bfd_vma) -2;
2877 if (! GOT_TLS_GDESC_P (*local_tls_type)
2878 || GOT_TLS_GD_P (*local_tls_type))
2880 *local_got = s->size;
2882 if (GOT_TLS_GD_P (*local_tls_type)
2883 || *local_tls_type == GOT_TLS_IE_BOTH)
2886 if (bfd_link_pic (info)
2887 || GOT_TLS_GD_ANY_P (*local_tls_type)
2888 || (*local_tls_type & GOT_TLS_IE))
2890 if (*local_tls_type == GOT_TLS_IE_BOTH)
2891 srel->size += 2 * sizeof (Elf32_External_Rel);
2892 else if (GOT_TLS_GD_P (*local_tls_type)
2893 || ! GOT_TLS_GDESC_P (*local_tls_type))
2894 srel->size += sizeof (Elf32_External_Rel);
2895 if (GOT_TLS_GDESC_P (*local_tls_type))
2896 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2900 *local_got = (bfd_vma) -1;
2904 if (htab->tls_ld_or_ldm_got.refcount > 0)
2906 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
2908 htab->tls_ld_or_ldm_got.offset = htab->elf.sgot->size;
2909 htab->elf.sgot->size += 8;
2910 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2913 htab->tls_ld_or_ldm_got.offset = -1;
2915 /* Allocate global sym .plt and .got entries, and space for global
2916 sym dynamic relocs. */
2917 elf_link_hash_traverse (&htab->elf, elf_i386_allocate_dynrelocs, info);
2919 /* Allocate .plt and .got entries, and space for local symbols. */
2920 htab_traverse (htab->loc_hash_table,
2921 elf_i386_allocate_local_dynrelocs,
2924 /* For every jump slot reserved in the sgotplt, reloc_count is
2925 incremented. However, when we reserve space for TLS descriptors,
2926 it's not incremented, so in order to compute the space reserved
2927 for them, it suffices to multiply the reloc count by the jump
2930 PR ld/13302: We start next_irelative_index at the end of .rela.plt
2931 so that R_386_IRELATIVE entries come last. */
2932 if (htab->elf.srelplt)
2934 htab->next_tls_desc_index = htab->elf.srelplt->reloc_count;
2935 htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4;
2936 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
2938 else if (htab->elf.irelplt)
2939 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
2942 if (htab->elf.sgotplt)
2944 /* Don't allocate .got.plt section if there are no GOT nor PLT
2945 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
2946 if ((htab->elf.hgot == NULL
2947 || !htab->elf.hgot->ref_regular_nonweak)
2948 && (htab->elf.sgotplt->size
2949 == get_elf_backend_data (output_bfd)->got_header_size)
2950 && (htab->elf.splt == NULL
2951 || htab->elf.splt->size == 0)
2952 && (htab->elf.sgot == NULL
2953 || htab->elf.sgot->size == 0)
2954 && (htab->elf.iplt == NULL
2955 || htab->elf.iplt->size == 0)
2956 && (htab->elf.igotplt == NULL
2957 || htab->elf.igotplt->size == 0))
2958 htab->elf.sgotplt->size = 0;
2961 if (_bfd_elf_eh_frame_present (info))
2963 if (htab->plt_eh_frame != NULL
2964 && htab->elf.splt != NULL
2965 && htab->elf.splt->size != 0
2966 && !bfd_is_abs_section (htab->elf.splt->output_section))
2967 htab->plt_eh_frame->size = htab->plt.eh_frame_plt_size;
2969 if (htab->plt_got_eh_frame != NULL
2970 && htab->plt_got != NULL
2971 && htab->plt_got->size != 0
2972 && !bfd_is_abs_section (htab->plt_got->output_section))
2973 htab->plt_got_eh_frame->size
2974 = htab->non_lazy_plt->eh_frame_plt_size;
2976 /* Unwind info for the second PLT and .plt.got sections are
2978 if (htab->plt_second_eh_frame != NULL
2979 && htab->plt_second != NULL
2980 && htab->plt_second->size != 0
2981 && !bfd_is_abs_section (htab->plt_second->output_section))
2982 htab->plt_second_eh_frame->size
2983 = htab->non_lazy_plt->eh_frame_plt_size;
2986 /* We now have determined the sizes of the various dynamic sections.
2987 Allocate memory for them. */
2989 for (s = dynobj->sections; s != NULL; s = s->next)
2991 bfd_boolean strip_section = TRUE;
2993 if ((s->flags & SEC_LINKER_CREATED) == 0)
2996 if (s == htab->elf.splt
2997 || s == htab->elf.sgot)
2999 /* Strip this section if we don't need it; see the
3001 /* We'd like to strip these sections if they aren't needed, but if
3002 we've exported dynamic symbols from them we must leave them.
3003 It's too late to tell BFD to get rid of the symbols. */
3005 if (htab->elf.hplt != NULL)
3006 strip_section = FALSE;
3008 else if (s == htab->elf.sgotplt
3009 || s == htab->elf.iplt
3010 || s == htab->elf.igotplt
3011 || s == htab->plt_second
3012 || s == htab->plt_got
3013 || s == htab->plt_eh_frame
3014 || s == htab->plt_got_eh_frame
3015 || s == htab->plt_second_eh_frame
3016 || s == htab->elf.sdynbss
3017 || s == htab->elf.sdynrelro)
3019 /* Strip these too. */
3021 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rel"))
3024 && s != htab->elf.srelplt
3025 && s != htab->srelplt2)
3028 /* We use the reloc_count field as a counter if we need
3029 to copy relocs into the output file. */
3034 /* It's not one of our sections, so don't allocate space. */
3040 /* If we don't need this section, strip it from the
3041 output file. This is mostly to handle .rel.bss and
3042 .rel.plt. We must create both sections in
3043 create_dynamic_sections, because they must be created
3044 before the linker maps input sections to output
3045 sections. The linker does that before
3046 adjust_dynamic_symbol is called, and it is that
3047 function which decides whether anything needs to go
3048 into these sections. */
3050 s->flags |= SEC_EXCLUDE;
3054 if ((s->flags & SEC_HAS_CONTENTS) == 0)
3057 /* Allocate memory for the section contents. We use bfd_zalloc
3058 here in case unused entries are not reclaimed before the
3059 section's contents are written out. This should not happen,
3060 but this way if it does, we get a R_386_NONE reloc instead
3062 s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
3063 if (s->contents == NULL)
3067 if (htab->plt_eh_frame != NULL
3068 && htab->plt_eh_frame->contents != NULL)
3070 memcpy (htab->plt_eh_frame->contents,
3071 htab->plt.eh_frame_plt,
3072 htab->plt_eh_frame->size);
3073 bfd_put_32 (dynobj, htab->elf.splt->size,
3074 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
3077 if (htab->plt_got_eh_frame != NULL
3078 && htab->plt_got_eh_frame->contents != NULL)
3080 memcpy (htab->plt_got_eh_frame->contents,
3081 htab->non_lazy_plt->eh_frame_plt,
3082 htab->plt_got_eh_frame->size);
3083 bfd_put_32 (dynobj, htab->plt_got->size,
3084 (htab->plt_got_eh_frame->contents
3085 + PLT_FDE_LEN_OFFSET));
3088 if (htab->plt_second_eh_frame != NULL
3089 && htab->plt_second_eh_frame->contents != NULL)
3091 memcpy (htab->plt_second_eh_frame->contents,
3092 htab->non_lazy_plt->eh_frame_plt,
3093 htab->plt_second_eh_frame->size);
3094 bfd_put_32 (dynobj, htab->plt_second->size,
3095 (htab->plt_second_eh_frame->contents
3096 + PLT_FDE_LEN_OFFSET));
3099 if (htab->elf.dynamic_sections_created)
3101 /* Add some entries to the .dynamic section. We fill in the
3102 values later, in elf_i386_finish_dynamic_sections, but we
3103 must add the entries now so that we get the correct size for
3104 the .dynamic section. The DT_DEBUG entry is filled in by the
3105 dynamic linker and used by the debugger. */
3106 #define add_dynamic_entry(TAG, VAL) \
3107 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3109 if (bfd_link_executable (info))
3111 if (!add_dynamic_entry (DT_DEBUG, 0))
3115 if (htab->elf.splt->size != 0)
3117 /* DT_PLTGOT is used by prelink even if there is no PLT
3119 if (!add_dynamic_entry (DT_PLTGOT, 0))
3123 if (htab->elf.srelplt->size != 0)
3125 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3126 || !add_dynamic_entry (DT_PLTREL, DT_REL)
3127 || !add_dynamic_entry (DT_JMPREL, 0))
3133 if (!add_dynamic_entry (DT_REL, 0)
3134 || !add_dynamic_entry (DT_RELSZ, 0)
3135 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
3138 /* If any dynamic relocs apply to a read-only section,
3139 then we need a DT_TEXTREL entry. */
3140 if ((info->flags & DF_TEXTREL) == 0)
3141 elf_link_hash_traverse (&htab->elf,
3142 _bfd_x86_elf_readonly_dynrelocs,
3145 if ((info->flags & DF_TEXTREL) != 0)
3147 if (htab->readonly_dynrelocs_against_ifunc)
3149 info->callbacks->einfo
3150 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3151 bfd_set_error (bfd_error_bad_value);
3155 if (!add_dynamic_entry (DT_TEXTREL, 0))
3159 if (get_elf_i386_backend_data (output_bfd)->os == is_vxworks
3160 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
3163 #undef add_dynamic_entry
3168 /* Set the correct type for an x86 ELF section. We do this by the
3169 section name, which is a hack, but ought to work. */
3172 elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
3173 Elf_Internal_Shdr *hdr,
3178 name = bfd_get_section_name (abfd, sec);
3180 /* This is an ugly, but unfortunately necessary hack that is
3181 needed when producing EFI binaries on x86. It tells
3182 elf.c:elf_fake_sections() not to consider ".reloc" as a section
3183 containing ELF relocation info. We need this hack in order to
3184 be able to generate ELF binaries that can be translated into
3185 EFI applications (which are essentially COFF objects). Those
3186 files contain a COFF ".reloc" section inside an ELFNN object,
3187 which would normally cause BFD to segfault because it would
3188 attempt to interpret this section as containing relocation
3189 entries for section "oc". With this hack enabled, ".reloc"
3190 will be treated as a normal data section, which will avoid the
3191 segfault. However, you won't be able to create an ELFNN binary
3192 with a section named "oc" that needs relocations, but that's
3193 the kind of ugly side-effects you get when detecting section
3194 types based on their names... In practice, this limitation is
3195 unlikely to bite. */
3196 if (strcmp (name, ".reloc") == 0)
3197 hdr->sh_type = SHT_PROGBITS;
3202 /* Return the relocation value for @tpoff relocation
3203 if STT_TLS virtual address is ADDRESS. */
3206 elf_i386_tpoff (struct bfd_link_info *info, bfd_vma address)
3208 struct elf_link_hash_table *htab = elf_hash_table (info);
3209 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3210 bfd_vma static_tls_size;
3212 /* If tls_sec is NULL, we should have signalled an error already. */
3213 if (htab->tls_sec == NULL)
3216 /* Consider special static TLS alignment requirements. */
3217 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3218 return static_tls_size + htab->tls_sec->vma - address;
3221 /* Relocate an i386 ELF section. */
3224 elf_i386_relocate_section (bfd *output_bfd,
3225 struct bfd_link_info *info,
3227 asection *input_section,
3229 Elf_Internal_Rela *relocs,
3230 Elf_Internal_Sym *local_syms,
3231 asection **local_sections)
3233 struct elf_x86_link_hash_table *htab;
3234 Elf_Internal_Shdr *symtab_hdr;
3235 struct elf_link_hash_entry **sym_hashes;
3236 bfd_vma *local_got_offsets;
3237 bfd_vma *local_tlsdesc_gotents;
3238 Elf_Internal_Rela *rel;
3239 Elf_Internal_Rela *wrel;
3240 Elf_Internal_Rela *relend;
3241 bfd_boolean is_vxworks_tls;
3242 unsigned plt_entry_size;
3244 BFD_ASSERT (is_i386_elf (input_bfd));
3246 /* Skip if check_relocs failed. */
3247 if (input_section->check_relocs_failed)
3250 htab = elf_x86_hash_table (info, I386_ELF_DATA);
3253 symtab_hdr = &elf_symtab_hdr (input_bfd);
3254 sym_hashes = elf_sym_hashes (input_bfd);
3255 local_got_offsets = elf_local_got_offsets (input_bfd);
3256 local_tlsdesc_gotents = elf_x86_local_tlsdesc_gotent (input_bfd);
3257 /* We have to handle relocations in vxworks .tls_vars sections
3258 specially, because the dynamic loader is 'weird'. */
3259 is_vxworks_tls = ((get_elf_i386_backend_data (output_bfd)->os
3261 && bfd_link_pic (info)
3262 && !strcmp (input_section->output_section->name,
3265 _bfd_x86_elf_set_tls_module_base (info);
3267 plt_entry_size = htab->plt.plt_entry_size;
3269 rel = wrel = relocs;
3270 relend = relocs + input_section->reloc_count;
3271 for (; rel < relend; wrel++, rel++)
3273 unsigned int r_type;
3274 reloc_howto_type *howto;
3275 unsigned long r_symndx;
3276 struct elf_link_hash_entry *h;
3277 struct elf_x86_link_hash_entry *eh;
3278 Elf_Internal_Sym *sym;
3280 bfd_vma off, offplt, plt_offset;
3282 bfd_boolean unresolved_reloc;
3283 bfd_reloc_status_type r;
3287 asection *resolved_plt;
3288 bfd_boolean resolved_to_zero;
3289 bfd_boolean relative_reloc;
3291 r_type = ELF32_R_TYPE (rel->r_info);
3292 if (r_type == R_386_GNU_VTINHERIT
3293 || r_type == R_386_GNU_VTENTRY)
3300 if ((indx = r_type) >= R_386_standard
3301 && ((indx = r_type - R_386_ext_offset) - R_386_standard
3302 >= R_386_ext - R_386_standard)
3303 && ((indx = r_type - R_386_tls_offset) - R_386_ext
3304 >= R_386_ext2 - R_386_ext))
3305 return _bfd_unrecognized_reloc (input_bfd, input_section, r_type);
3307 howto = elf_howto_table + indx;
3309 r_symndx = ELF32_R_SYM (rel->r_info);
3313 unresolved_reloc = FALSE;
3314 if (r_symndx < symtab_hdr->sh_info)
3316 sym = local_syms + r_symndx;
3317 sec = local_sections[r_symndx];
3318 relocation = (sec->output_section->vma
3319 + sec->output_offset
3321 st_size = sym->st_size;
3323 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
3324 && ((sec->flags & SEC_MERGE) != 0
3325 || (bfd_link_relocatable (info)
3326 && sec->output_offset != 0)))
3329 bfd_byte *where = contents + rel->r_offset;
3331 switch (howto->size)
3334 addend = bfd_get_8 (input_bfd, where);
3335 if (howto->pc_relative)
3337 addend = (addend ^ 0x80) - 0x80;
3342 addend = bfd_get_16 (input_bfd, where);
3343 if (howto->pc_relative)
3345 addend = (addend ^ 0x8000) - 0x8000;
3350 addend = bfd_get_32 (input_bfd, where);
3351 if (howto->pc_relative)
3353 addend = (addend ^ 0x80000000) - 0x80000000;
3361 if (bfd_link_relocatable (info))
3362 addend += sec->output_offset;
3365 asection *msec = sec;
3366 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
3368 addend -= relocation;
3369 addend += msec->output_section->vma + msec->output_offset;
3372 switch (howto->size)
3375 /* FIXME: overflow checks. */
3376 if (howto->pc_relative)
3378 bfd_put_8 (input_bfd, addend, where);
3381 if (howto->pc_relative)
3383 bfd_put_16 (input_bfd, addend, where);
3386 if (howto->pc_relative)
3388 bfd_put_32 (input_bfd, addend, where);
3392 else if (!bfd_link_relocatable (info)
3393 && ELF32_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3395 /* Relocate against local STT_GNU_IFUNC symbol. */
3396 h = _bfd_elf_x86_get_local_sym_hash (htab, input_bfd, rel,
3401 /* Set STT_GNU_IFUNC symbol value. */
3402 h->root.u.def.value = sym->st_value;
3403 h->root.u.def.section = sec;
3408 bfd_boolean warned ATTRIBUTE_UNUSED;
3409 bfd_boolean ignored ATTRIBUTE_UNUSED;
3411 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3412 r_symndx, symtab_hdr, sym_hashes,
3414 unresolved_reloc, warned, ignored);
3418 if (sec != NULL && discarded_section (sec))
3420 _bfd_clear_contents (howto, input_bfd, input_section,
3421 contents + rel->r_offset);
3422 wrel->r_offset = rel->r_offset;
3426 /* For ld -r, remove relocations in debug sections against
3427 sections defined in discarded sections. Not done for
3428 eh_frame editing code expects to be present. */
3429 if (bfd_link_relocatable (info)
3430 && (input_section->flags & SEC_DEBUGGING))
3436 if (bfd_link_relocatable (info))
3443 eh = (struct elf_x86_link_hash_entry *) h;
3445 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3446 it here if it is defined in a non-shared object. */
3448 && h->type == STT_GNU_IFUNC
3451 asection *gotplt, *base_got;
3455 if ((input_section->flags & SEC_ALLOC) == 0)
3457 /* Dynamic relocs are not propagated for SEC_DEBUGGING
3458 sections because such sections are not SEC_ALLOC and
3459 thus ld.so will not process them. */
3460 if ((input_section->flags & SEC_DEBUGGING) != 0)
3465 /* STT_GNU_IFUNC symbol must go through PLT. */
3466 if (htab->elf.splt != NULL)
3468 if (htab->plt_second != NULL)
3470 resolved_plt = htab->plt_second;
3471 plt_offset = eh->plt_second.offset;
3475 resolved_plt = htab->elf.splt;
3476 plt_offset = h->plt.offset;
3478 gotplt = htab->elf.sgotplt;
3482 resolved_plt = htab->elf.iplt;
3483 plt_offset = h->plt.offset;
3484 gotplt = htab->elf.igotplt;
3494 base_got = htab->elf.sgot;
3495 off = h->got.offset;
3497 if (base_got == NULL)
3500 if (off == (bfd_vma) -1)
3502 /* We can't use h->got.offset here to save state, or
3503 even just remember the offset, as finish_dynamic_symbol
3504 would use that as offset into .got. */
3506 if (h->plt.offset == (bfd_vma) -1)
3509 if (htab->elf.splt != NULL)
3511 plt_index = (h->plt.offset / plt_entry_size
3512 - htab->plt.has_plt0);
3513 off = (plt_index + 3) * 4;
3514 base_got = htab->elf.sgotplt;
3518 plt_index = h->plt.offset / plt_entry_size;
3519 off = plt_index * 4;
3520 base_got = htab->elf.igotplt;
3523 if (h->dynindx == -1
3527 /* This references the local defitionion. We must
3528 initialize this entry in the global offset table.
3529 Since the offset must always be a multiple of 8,
3530 we use the least significant bit to record
3531 whether we have initialized it already.
3533 When doing a dynamic link, we create a .rela.got
3534 relocation entry to initialize the value. This
3535 is done in the finish_dynamic_symbol routine. */
3540 bfd_put_32 (output_bfd, relocation,
3541 base_got->contents + off);
3549 relocation = (base_got->output_section->vma
3550 + base_got->output_offset + off
3551 - gotplt->output_section->vma
3552 - gotplt->output_offset);
3554 if (rel->r_offset > 1
3555 && (*(contents + rel->r_offset - 1) & 0xc7) == 0x5
3556 && *(contents + rel->r_offset - 2) != 0x8d)
3558 if (bfd_link_pic (info))
3559 goto disallow_got32;
3561 /* Add the GOT base if there is no base register. */
3562 relocation += (gotplt->output_section->vma
3563 + gotplt->output_offset);
3565 else if (htab->elf.splt == NULL)
3567 /* Adjust for static executables. */
3568 relocation += gotplt->output_offset;
3574 if (h->plt.offset == (bfd_vma) -1)
3576 /* Handle static pointers of STT_GNU_IFUNC symbols. */
3577 if (r_type == R_386_32
3578 && (input_section->flags & SEC_CODE) == 0)
3579 goto do_ifunc_pointer;
3580 goto bad_ifunc_reloc;
3583 relocation = (resolved_plt->output_section->vma
3584 + resolved_plt->output_offset + plt_offset);
3590 if (h->root.root.string)
3591 name = h->root.root.string;
3593 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3596 /* xgettext:c-format */
3597 (_("%B: relocation %s against STT_GNU_IFUNC "
3598 "symbol `%s' isn't supported"), input_bfd,
3600 bfd_set_error (bfd_error_bad_value);
3604 /* Generate dynamic relcoation only when there is a
3605 non-GOT reference in a shared object. */
3606 if ((bfd_link_pic (info) && h->non_got_ref)
3607 || h->plt.offset == (bfd_vma) -1)
3609 Elf_Internal_Rela outrel;
3614 /* Need a dynamic relocation to get the real function
3616 offset = _bfd_elf_section_offset (output_bfd,
3620 if (offset == (bfd_vma) -1
3621 || offset == (bfd_vma) -2)
3624 outrel.r_offset = (input_section->output_section->vma
3625 + input_section->output_offset
3628 if (h->dynindx == -1
3630 || bfd_link_executable (info))
3632 info->callbacks->minfo (_("Local IFUNC function `%s' in %B\n"),
3633 h->root.root.string,
3634 h->root.u.def.section->owner);
3636 /* This symbol is resolved locally. */
3637 outrel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
3638 bfd_put_32 (output_bfd,
3639 (h->root.u.def.value
3640 + h->root.u.def.section->output_section->vma
3641 + h->root.u.def.section->output_offset),
3645 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3647 /* Dynamic relocations are stored in
3648 1. .rel.ifunc section in PIC object.
3649 2. .rel.got section in dynamic executable.
3650 3. .rel.iplt section in static executable. */
3651 if (bfd_link_pic (info))
3652 sreloc = htab->elf.irelifunc;
3653 else if (htab->elf.splt != NULL)
3654 sreloc = htab->elf.srelgot;
3656 sreloc = htab->elf.irelplt;
3657 elf_append_rel (output_bfd, sreloc, &outrel);
3659 /* If this reloc is against an external symbol, we
3660 do not want to fiddle with the addend. Otherwise,
3661 we need to include the symbol value so that it
3662 becomes an addend for the dynamic reloc. For an
3663 internal symbol, we have updated addend. */
3672 relocation -= (gotplt->output_section->vma
3673 + gotplt->output_offset);
3678 resolved_to_zero = (eh != NULL
3679 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
3687 /* Avoid optimizing _DYNAMIC since ld.so may use its
3688 link-time address. */
3689 if (h == htab->elf.hdynamic)
3692 if (bfd_link_pic (info))
3694 /* It is OK to convert mov to lea and convert indirect
3695 branch to direct branch. It is OK to convert adc,
3696 add, and, cmp, or, sbb, sub, test, xor only when PIC
3698 unsigned int opcode, addend;
3699 addend = bfd_get_32 (input_bfd, contents + rel->r_offset);
3702 opcode = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
3703 if (opcode != 0x8b && opcode != 0xff)
3707 /* Resolve "mov GOT[(%reg)], %reg",
3708 "call/jmp *GOT[(%reg)]", "test %reg, foo@GOT[(%reg)]"
3709 and "binop foo@GOT[(%reg)], %reg". */
3711 || (h->plt.offset == (bfd_vma) -1
3712 && h->got.offset == (bfd_vma) -1)
3713 || htab->elf.sgotplt == NULL)
3716 offplt = (htab->elf.sgotplt->output_section->vma
3717 + htab->elf.sgotplt->output_offset);
3719 /* It is relative to .got.plt section. */
3720 if (h->got.offset != (bfd_vma) -1)
3721 /* Use GOT entry. Mask off the least significant bit in
3722 GOT offset which may be set by R_386_GOT32 processing
3724 relocation = (htab->elf.sgot->output_section->vma
3725 + htab->elf.sgot->output_offset
3726 + (h->got.offset & ~1) - offplt);
3728 /* Use GOTPLT entry. */
3729 relocation = (h->plt.offset / plt_entry_size
3730 - htab->plt.has_plt0 + 3) * 4;
3732 if (!bfd_link_pic (info))
3734 /* If not PIC, add the .got.plt section address for
3735 baseless addressing. */
3737 modrm = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
3738 if ((modrm & 0xc7) == 0x5)
3739 relocation += offplt;
3742 unresolved_reloc = FALSE;
3747 /* Relocation is to the entry for this symbol in the global
3749 if (htab->elf.sgot == NULL)
3752 relative_reloc = FALSE;
3757 off = h->got.offset;
3758 dyn = htab->elf.dynamic_sections_created;
3759 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
3760 bfd_link_pic (info),
3762 || (bfd_link_pic (info)
3763 && SYMBOL_REFERENCES_LOCAL (info, h))
3764 || (ELF_ST_VISIBILITY (h->other)
3765 && h->root.type == bfd_link_hash_undefweak))
3767 /* This is actually a static link, or it is a
3768 -Bsymbolic link and the symbol is defined
3769 locally, or the symbol was forced to be local
3770 because of a version file. We must initialize
3771 this entry in the global offset table. Since the
3772 offset must always be a multiple of 4, we use the
3773 least significant bit to record whether we have
3774 initialized it already.
3776 When doing a dynamic link, we create a .rel.got
3777 relocation entry to initialize the value. This
3778 is done in the finish_dynamic_symbol routine. */
3783 bfd_put_32 (output_bfd, relocation,
3784 htab->elf.sgot->contents + off);
3787 if (h->dynindx == -1
3789 && h->root.type != bfd_link_hash_undefweak
3790 && bfd_link_pic (info))
3792 /* PR ld/21402: If this symbol isn't dynamic
3793 in PIC, generate R_386_RELATIVE here. */
3794 eh->no_finish_dynamic_symbol = 1;
3795 relative_reloc = TRUE;
3800 unresolved_reloc = FALSE;
3804 if (local_got_offsets == NULL)
3807 off = local_got_offsets[r_symndx];
3809 /* The offset must always be a multiple of 4. We use
3810 the least significant bit to record whether we have
3811 already generated the necessary reloc. */
3816 bfd_put_32 (output_bfd, relocation,
3817 htab->elf.sgot->contents + off);
3818 local_got_offsets[r_symndx] |= 1;
3820 if (bfd_link_pic (info))
3821 relative_reloc = TRUE;
3828 Elf_Internal_Rela outrel;
3830 s = htab->elf.srelgot;
3834 outrel.r_offset = (htab->elf.sgot->output_section->vma
3835 + htab->elf.sgot->output_offset
3837 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
3838 elf_append_rel (output_bfd, s, &outrel);
3841 if (off >= (bfd_vma) -2)
3844 relocation = (htab->elf.sgot->output_section->vma
3845 + htab->elf.sgot->output_offset + off);
3846 if (rel->r_offset > 1
3847 && (*(contents + rel->r_offset - 1) & 0xc7) == 0x5
3848 && *(contents + rel->r_offset - 2) != 0x8d)
3850 if (bfd_link_pic (info))
3852 /* For PIC, disallow R_386_GOT32 without a base
3853 register, except for "lea foo@GOT, %reg", since
3854 we don't know what the GOT base is. */
3858 if (h == NULL || h->root.root.string == NULL)
3859 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3862 name = h->root.root.string;
3865 /* xgettext:c-format */
3866 (_("%B: direct GOT relocation %s against `%s'"
3867 " without base register can not be used"
3868 " when making a shared object"),
3869 input_bfd, howto->name, name);
3870 bfd_set_error (bfd_error_bad_value);
3876 /* Subtract the .got.plt section address only with a base
3878 relocation -= (htab->elf.sgotplt->output_section->vma
3879 + htab->elf.sgotplt->output_offset);
3885 /* Relocation is relative to the start of the global offset
3888 /* Check to make sure it isn't a protected function or data
3889 symbol for shared library since it may not be local when
3890 used as function address or with copy relocation. We also
3891 need to make sure that a symbol is referenced locally. */
3892 if (!bfd_link_executable (info) && h)
3894 if (!h->def_regular)
3898 switch (ELF_ST_VISIBILITY (h->other))
3901 v = _("hidden symbol");
3904 v = _("internal symbol");
3907 v = _("protected symbol");
3915 /* xgettext:c-format */
3916 (_("%B: relocation R_386_GOTOFF against undefined %s"
3917 " `%s' can not be used when making a shared object"),
3918 input_bfd, v, h->root.root.string);
3919 bfd_set_error (bfd_error_bad_value);
3922 else if (!SYMBOL_REFERENCES_LOCAL (info, h)
3923 && (h->type == STT_FUNC
3924 || h->type == STT_OBJECT)
3925 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
3928 /* xgettext:c-format */
3929 (_("%B: relocation R_386_GOTOFF against protected %s"
3930 " `%s' can not be used when making a shared object"),
3932 h->type == STT_FUNC ? "function" : "data",
3933 h->root.root.string);
3934 bfd_set_error (bfd_error_bad_value);
3939 /* Note that sgot is not involved in this
3940 calculation. We always want the start of .got.plt. If we
3941 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3942 permitted by the ABI, we might have to change this
3944 relocation -= htab->elf.sgotplt->output_section->vma
3945 + htab->elf.sgotplt->output_offset;
3949 /* Use global offset table as symbol value. */
3950 relocation = htab->elf.sgotplt->output_section->vma
3951 + htab->elf.sgotplt->output_offset;
3952 unresolved_reloc = FALSE;
3956 /* Relocation is to the entry for this symbol in the
3957 procedure linkage table. */
3959 /* Resolve a PLT32 reloc against a local symbol directly,
3960 without using the procedure linkage table. */
3964 if ((h->plt.offset == (bfd_vma) -1
3965 && eh->plt_got.offset == (bfd_vma) -1)
3966 || htab->elf.splt == NULL)
3968 /* We didn't make a PLT entry for this symbol. This
3969 happens when statically linking PIC code, or when
3970 using -Bsymbolic. */
3974 if (h->plt.offset != (bfd_vma) -1)
3976 if (htab->plt_second != NULL)
3978 resolved_plt = htab->plt_second;
3979 plt_offset = eh->plt_second.offset;
3983 resolved_plt = htab->elf.splt;
3984 plt_offset = h->plt.offset;
3989 resolved_plt = htab->plt_got;
3990 plt_offset = eh->plt_got.offset;
3993 relocation = (resolved_plt->output_section->vma
3994 + resolved_plt->output_offset
3996 unresolved_reloc = FALSE;
4000 /* Set to symbol size. */
4001 relocation = st_size;
4006 if ((input_section->flags & SEC_ALLOC) == 0
4010 /* Copy dynamic function pointer relocations. Don't generate
4011 dynamic relocations against resolved undefined weak symbols
4012 in PIE, except for R_386_PC32. */
4013 if ((bfd_link_pic (info)
4015 || ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4016 && (!resolved_to_zero
4017 || r_type == R_386_PC32))
4018 || h->root.type != bfd_link_hash_undefweak))
4019 && ((r_type != R_386_PC32 && r_type != R_386_SIZE32)
4020 || !SYMBOL_CALLS_LOCAL (info, h)))
4021 || (ELIMINATE_COPY_RELOCS
4022 && !bfd_link_pic (info)
4026 || eh->func_pointer_refcount > 0
4027 || (h->root.type == bfd_link_hash_undefweak
4028 && !resolved_to_zero))
4029 && ((h->def_dynamic && !h->def_regular)
4030 /* Undefined weak symbol is bound locally when
4032 || h->root.type == bfd_link_hash_undefweak)))
4034 Elf_Internal_Rela outrel;
4035 bfd_boolean skip, relocate;
4038 /* When generating a shared object, these relocations
4039 are copied into the output file to be resolved at run
4046 _bfd_elf_section_offset (output_bfd, info, input_section,
4048 if (outrel.r_offset == (bfd_vma) -1)
4050 else if (outrel.r_offset == (bfd_vma) -2)
4051 skip = TRUE, relocate = TRUE;
4052 outrel.r_offset += (input_section->output_section->vma
4053 + input_section->output_offset);
4056 memset (&outrel, 0, sizeof outrel);
4059 && (r_type == R_386_PC32
4060 || !(bfd_link_executable (info)
4061 || SYMBOLIC_BIND (info, h))
4062 || !h->def_regular))
4063 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4066 /* This symbol is local, or marked to become local. */
4068 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4071 sreloc = elf_section_data (input_section)->sreloc;
4073 if (sreloc == NULL || sreloc->contents == NULL)
4075 r = bfd_reloc_notsupported;
4076 goto check_relocation_error;
4079 elf_append_rel (output_bfd, sreloc, &outrel);
4081 /* If this reloc is against an external symbol, we do
4082 not want to fiddle with the addend. Otherwise, we
4083 need to include the symbol value so that it becomes
4084 an addend for the dynamic reloc. */
4091 if (!bfd_link_executable (info))
4093 Elf_Internal_Rela outrel;
4096 outrel.r_offset = rel->r_offset
4097 + input_section->output_section->vma
4098 + input_section->output_offset;
4099 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4100 sreloc = elf_section_data (input_section)->sreloc;
4103 elf_append_rel (output_bfd, sreloc, &outrel);
4108 case R_386_TLS_GOTDESC:
4109 case R_386_TLS_DESC_CALL:
4110 case R_386_TLS_IE_32:
4111 case R_386_TLS_GOTIE:
4112 tls_type = GOT_UNKNOWN;
4113 if (h == NULL && local_got_offsets)
4114 tls_type = elf_x86_local_got_tls_type (input_bfd) [r_symndx];
4116 tls_type = elf_x86_hash_entry(h)->tls_type;
4117 if (tls_type == GOT_TLS_IE)
4118 tls_type = GOT_TLS_IE_NEG;
4120 if (! elf_i386_tls_transition (info, input_bfd,
4121 input_section, contents,
4122 symtab_hdr, sym_hashes,
4123 &r_type, tls_type, rel,
4124 relend, h, r_symndx, TRUE))
4127 if (r_type == R_386_TLS_LE_32)
4129 BFD_ASSERT (! unresolved_reloc);
4130 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
4135 /* GD->LE transition. */
4136 type = *(contents + rel->r_offset - 2);
4140 leal foo@tlsgd(,%ebx,1), %eax
4141 call ___tls_get_addr@PLT
4144 subl $foo@tpoff, %eax
4145 (6 byte form of subl). */
4146 roff = rel->r_offset + 5;
4151 leal foo@tlsgd(%ebx), %eax
4152 call ___tls_get_addr@PLT
4155 leal foo@tlsgd(%reg), %eax
4156 call *___tls_get_addr@GOT(%reg)
4157 which may be converted to
4158 addr32 call ___tls_get_addr
4160 movl %gs:0, %eax; subl $foo@tpoff, %eax
4161 (6 byte form of subl). */
4162 roff = rel->r_offset + 6;
4164 memcpy (contents + roff - 8,
4165 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
4166 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
4168 /* Skip R_386_PC32, R_386_PLT32 and R_386_GOT32X. */
4173 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4175 /* GDesc -> LE transition.
4176 It's originally something like:
4177 leal x@tlsdesc(%ebx), %eax
4181 Registers other than %eax may be set up here. */
4186 roff = rel->r_offset;
4187 val = bfd_get_8 (input_bfd, contents + roff - 1);
4189 /* Now modify the instruction as appropriate. */
4190 /* aoliva FIXME: remove the above and xor the byte
4192 bfd_put_8 (output_bfd, val ^ 0x86,
4193 contents + roff - 1);
4194 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
4198 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4200 /* GDesc -> LE transition.
4208 roff = rel->r_offset;
4209 bfd_put_8 (output_bfd, 0x66, contents + roff);
4210 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4213 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
4217 /* IE->LE transition:
4218 Originally it can be one of:
4226 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4229 /* movl foo, %eax. */
4230 bfd_put_8 (output_bfd, 0xb8,
4231 contents + rel->r_offset - 1);
4237 type = bfd_get_8 (input_bfd,
4238 contents + rel->r_offset - 2);
4243 bfd_put_8 (output_bfd, 0xc7,
4244 contents + rel->r_offset - 2);
4245 bfd_put_8 (output_bfd,
4246 0xc0 | ((val >> 3) & 7),
4247 contents + rel->r_offset - 1);
4251 bfd_put_8 (output_bfd, 0x81,
4252 contents + rel->r_offset - 2);
4253 bfd_put_8 (output_bfd,
4254 0xc0 | ((val >> 3) & 7),
4255 contents + rel->r_offset - 1);
4262 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
4263 contents + rel->r_offset);
4268 unsigned int val, type;
4270 /* {IE_32,GOTIE}->LE transition:
4271 Originally it can be one of:
4272 subl foo(%reg1), %reg2
4273 movl foo(%reg1), %reg2
4274 addl foo(%reg1), %reg2
4277 movl $foo, %reg2 (6 byte form)
4278 addl $foo, %reg2. */
4279 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
4280 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4284 bfd_put_8 (output_bfd, 0xc7,
4285 contents + rel->r_offset - 2);
4286 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4287 contents + rel->r_offset - 1);
4289 else if (type == 0x2b)
4292 bfd_put_8 (output_bfd, 0x81,
4293 contents + rel->r_offset - 2);
4294 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
4295 contents + rel->r_offset - 1);
4297 else if (type == 0x03)
4300 bfd_put_8 (output_bfd, 0x81,
4301 contents + rel->r_offset - 2);
4302 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4303 contents + rel->r_offset - 1);
4307 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
4308 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
4309 contents + rel->r_offset);
4311 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
4312 contents + rel->r_offset);
4317 if (htab->elf.sgot == NULL)
4322 off = h->got.offset;
4323 offplt = elf_x86_hash_entry (h)->tlsdesc_got;
4327 if (local_got_offsets == NULL)
4330 off = local_got_offsets[r_symndx];
4331 offplt = local_tlsdesc_gotents[r_symndx];
4338 Elf_Internal_Rela outrel;
4342 if (htab->elf.srelgot == NULL)
4345 indx = h && h->dynindx != -1 ? h->dynindx : 0;
4347 if (GOT_TLS_GDESC_P (tls_type))
4350 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
4351 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
4352 <= htab->elf.sgotplt->size);
4353 outrel.r_offset = (htab->elf.sgotplt->output_section->vma
4354 + htab->elf.sgotplt->output_offset
4356 + htab->sgotplt_jump_table_size);
4357 sreloc = htab->elf.srelplt;
4358 loc = sreloc->contents;
4359 loc += (htab->next_tls_desc_index++
4360 * sizeof (Elf32_External_Rel));
4361 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
4362 <= sreloc->contents + sreloc->size);
4363 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4366 BFD_ASSERT (! unresolved_reloc);
4367 bfd_put_32 (output_bfd,
4368 relocation - _bfd_x86_elf_dtpoff_base (info),
4369 htab->elf.sgotplt->contents + offplt
4370 + htab->sgotplt_jump_table_size + 4);
4374 bfd_put_32 (output_bfd, 0,
4375 htab->elf.sgotplt->contents + offplt
4376 + htab->sgotplt_jump_table_size + 4);
4380 sreloc = htab->elf.srelgot;
4382 outrel.r_offset = (htab->elf.sgot->output_section->vma
4383 + htab->elf.sgot->output_offset + off);
4385 if (GOT_TLS_GD_P (tls_type))
4386 dr_type = R_386_TLS_DTPMOD32;
4387 else if (GOT_TLS_GDESC_P (tls_type))
4389 else if (tls_type == GOT_TLS_IE_POS)
4390 dr_type = R_386_TLS_TPOFF;
4392 dr_type = R_386_TLS_TPOFF32;
4394 if (dr_type == R_386_TLS_TPOFF && indx == 0)
4395 bfd_put_32 (output_bfd,
4396 relocation - _bfd_x86_elf_dtpoff_base (info),
4397 htab->elf.sgot->contents + off);
4398 else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
4399 bfd_put_32 (output_bfd,
4400 _bfd_x86_elf_dtpoff_base (info) - relocation,
4401 htab->elf.sgot->contents + off);
4402 else if (dr_type != R_386_TLS_DESC)
4403 bfd_put_32 (output_bfd, 0,
4404 htab->elf.sgot->contents + off);
4405 outrel.r_info = ELF32_R_INFO (indx, dr_type);
4407 elf_append_rel (output_bfd, sreloc, &outrel);
4409 if (GOT_TLS_GD_P (tls_type))
4413 BFD_ASSERT (! unresolved_reloc);
4414 bfd_put_32 (output_bfd,
4415 relocation - _bfd_x86_elf_dtpoff_base (info),
4416 htab->elf.sgot->contents + off + 4);
4420 bfd_put_32 (output_bfd, 0,
4421 htab->elf.sgot->contents + off + 4);
4422 outrel.r_info = ELF32_R_INFO (indx,
4423 R_386_TLS_DTPOFF32);
4424 outrel.r_offset += 4;
4425 elf_append_rel (output_bfd, sreloc, &outrel);
4428 else if (tls_type == GOT_TLS_IE_BOTH)
4430 bfd_put_32 (output_bfd,
4432 ? relocation - _bfd_x86_elf_dtpoff_base (info)
4434 htab->elf.sgot->contents + off + 4);
4435 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4436 outrel.r_offset += 4;
4437 elf_append_rel (output_bfd, sreloc, &outrel);
4444 local_got_offsets[r_symndx] |= 1;
4447 if (off >= (bfd_vma) -2
4448 && ! GOT_TLS_GDESC_P (tls_type))
4450 if (r_type == R_386_TLS_GOTDESC
4451 || r_type == R_386_TLS_DESC_CALL)
4453 relocation = htab->sgotplt_jump_table_size + offplt;
4454 unresolved_reloc = FALSE;
4456 else if (r_type == ELF32_R_TYPE (rel->r_info))
4458 bfd_vma g_o_t = htab->elf.sgotplt->output_section->vma
4459 + htab->elf.sgotplt->output_offset;
4460 relocation = htab->elf.sgot->output_section->vma
4461 + htab->elf.sgot->output_offset + off - g_o_t;
4462 if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
4463 && tls_type == GOT_TLS_IE_BOTH)
4465 if (r_type == R_386_TLS_IE)
4466 relocation += g_o_t;
4467 unresolved_reloc = FALSE;
4469 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
4471 unsigned int val, type;
4474 /* GD->IE transition. */
4475 type = *(contents + rel->r_offset - 2);
4476 val = *(contents + rel->r_offset - 1);
4480 leal foo@tlsgd(,%ebx,1), %eax
4481 call ___tls_get_addr@PLT
4484 subl $foo@gottpoff(%ebx), %eax. */
4486 roff = rel->r_offset - 3;
4491 leal foo@tlsgd(%ebx), %eax
4492 call ___tls_get_addr@PLT
4495 leal foo@tlsgd(%reg), %eax
4496 call *___tls_get_addr@GOT(%reg)
4497 which may be converted to
4498 addr32 call ___tls_get_addr
4501 subl $foo@gottpoff(%reg), %eax. */
4502 roff = rel->r_offset - 2;
4504 memcpy (contents + roff,
4505 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
4506 contents[roff + 7] = 0x80 | (val & 7);
4507 /* If foo is used only with foo@gotntpoff(%reg) and
4508 foo@indntpoff, but not with foo@gottpoff(%reg), change
4509 subl $foo@gottpoff(%reg), %eax
4511 addl $foo@gotntpoff(%reg), %eax. */
4512 if (tls_type == GOT_TLS_IE_POS)
4513 contents[roff + 6] = 0x03;
4514 bfd_put_32 (output_bfd,
4515 htab->elf.sgot->output_section->vma
4516 + htab->elf.sgot->output_offset + off
4517 - htab->elf.sgotplt->output_section->vma
4518 - htab->elf.sgotplt->output_offset,
4519 contents + roff + 8);
4520 /* Skip R_386_PLT32 and R_386_GOT32X. */
4525 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4527 /* GDesc -> IE transition.
4528 It's originally something like:
4529 leal x@tlsdesc(%ebx), %eax
4532 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
4534 movl x@gottpoff(%ebx), %eax # before negl %eax
4536 Registers other than %eax may be set up here. */
4540 /* First, make sure it's a leal adding ebx to a 32-bit
4541 offset into any register, although it's probably
4542 almost always going to be eax. */
4543 roff = rel->r_offset;
4545 /* Now modify the instruction as appropriate. */
4546 /* To turn a leal into a movl in the form we use it, it
4547 suffices to change the first byte from 0x8d to 0x8b.
4548 aoliva FIXME: should we decide to keep the leal, all
4549 we have to do is remove the statement below, and
4550 adjust the relaxation of R_386_TLS_DESC_CALL. */
4551 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4553 if (tls_type == GOT_TLS_IE_BOTH)
4556 bfd_put_32 (output_bfd,
4557 htab->elf.sgot->output_section->vma
4558 + htab->elf.sgot->output_offset + off
4559 - htab->elf.sgotplt->output_section->vma
4560 - htab->elf.sgotplt->output_offset,
4564 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4566 /* GDesc -> IE transition.
4574 depending on how we transformed the TLS_GOTDESC above.
4579 roff = rel->r_offset;
4581 /* Now modify the instruction as appropriate. */
4582 if (tls_type != GOT_TLS_IE_NEG)
4585 bfd_put_8 (output_bfd, 0x66, contents + roff);
4586 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4591 bfd_put_8 (output_bfd, 0xf7, contents + roff);
4592 bfd_put_8 (output_bfd, 0xd8, contents + roff + 1);
4602 if (! elf_i386_tls_transition (info, input_bfd,
4603 input_section, contents,
4604 symtab_hdr, sym_hashes,
4605 &r_type, GOT_UNKNOWN, rel,
4606 relend, h, r_symndx, TRUE))
4609 if (r_type != R_386_TLS_LDM)
4611 /* LD->LE transition. Change
4612 leal foo@tlsldm(%ebx) %eax
4613 call ___tls_get_addr@PLT
4617 leal 0(%esi,1), %esi
4619 leal foo@tlsldm(%reg) %eax
4620 call *___tls_get_addr@GOT(%reg)
4621 which may be converted to
4622 addr32 call ___tls_get_addr
4625 leal 0(%esi), %esi */
4626 BFD_ASSERT (r_type == R_386_TLS_LE_32);
4627 if (*(contents + rel->r_offset + 4) == 0xff
4628 || *(contents + rel->r_offset + 4) == 0x67)
4629 memcpy (contents + rel->r_offset - 2,
4630 "\x65\xa1\0\0\0\0\x8d\xb6\0\0\0", 12);
4632 memcpy (contents + rel->r_offset - 2,
4633 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
4634 /* Skip R_386_PC32/R_386_PLT32. */
4640 if (htab->elf.sgot == NULL)
4643 off = htab->tls_ld_or_ldm_got.offset;
4648 Elf_Internal_Rela outrel;
4650 if (htab->elf.srelgot == NULL)
4653 outrel.r_offset = (htab->elf.sgot->output_section->vma
4654 + htab->elf.sgot->output_offset + off);
4656 bfd_put_32 (output_bfd, 0,
4657 htab->elf.sgot->contents + off);
4658 bfd_put_32 (output_bfd, 0,
4659 htab->elf.sgot->contents + off + 4);
4660 outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
4661 elf_append_rel (output_bfd, htab->elf.srelgot, &outrel);
4662 htab->tls_ld_or_ldm_got.offset |= 1;
4664 relocation = htab->elf.sgot->output_section->vma
4665 + htab->elf.sgot->output_offset + off
4666 - htab->elf.sgotplt->output_section->vma
4667 - htab->elf.sgotplt->output_offset;
4668 unresolved_reloc = FALSE;
4671 case R_386_TLS_LDO_32:
4672 if (!bfd_link_executable (info)
4673 || (input_section->flags & SEC_CODE) == 0)
4674 relocation -= _bfd_x86_elf_dtpoff_base (info);
4676 /* When converting LDO to LE, we must negate. */
4677 relocation = -elf_i386_tpoff (info, relocation);
4680 case R_386_TLS_LE_32:
4682 if (!bfd_link_executable (info))
4684 Elf_Internal_Rela outrel;
4687 outrel.r_offset = rel->r_offset
4688 + input_section->output_section->vma
4689 + input_section->output_offset;
4690 if (h != NULL && h->dynindx != -1)
4694 if (r_type == R_386_TLS_LE_32)
4695 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
4697 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4698 sreloc = elf_section_data (input_section)->sreloc;
4701 elf_append_rel (output_bfd, sreloc, &outrel);
4704 else if (r_type == R_386_TLS_LE_32)
4705 relocation = _bfd_x86_elf_dtpoff_base (info) - relocation;
4707 relocation -= _bfd_x86_elf_dtpoff_base (info);
4709 else if (r_type == R_386_TLS_LE_32)
4710 relocation = elf_i386_tpoff (info, relocation);
4712 relocation = -elf_i386_tpoff (info, relocation);
4719 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4720 because such sections are not SEC_ALLOC and thus ld.so will
4721 not process them. */
4722 if (unresolved_reloc
4723 && !((input_section->flags & SEC_DEBUGGING) != 0
4725 && _bfd_elf_section_offset (output_bfd, info, input_section,
4726 rel->r_offset) != (bfd_vma) -1)
4729 /* xgettext:c-format */
4730 (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
4735 h->root.root.string);
4740 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4741 contents, rel->r_offset,
4744 check_relocation_error:
4745 if (r != bfd_reloc_ok)
4750 name = h->root.root.string;
4753 name = bfd_elf_string_from_elf_section (input_bfd,
4754 symtab_hdr->sh_link,
4759 name = bfd_section_name (input_bfd, sec);
4762 if (r == bfd_reloc_overflow)
4763 (*info->callbacks->reloc_overflow)
4764 (info, (h ? &h->root : NULL), name, howto->name,
4765 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
4769 /* xgettext:c-format */
4770 (_("%B(%A+%#Lx): reloc against `%s': error %d"),
4771 input_bfd, input_section,
4772 rel->r_offset, name, (int) r);
4783 Elf_Internal_Shdr *rel_hdr;
4784 size_t deleted = rel - wrel;
4786 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
4787 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
4788 if (rel_hdr->sh_size == 0)
4790 /* It is too late to remove an empty reloc section. Leave
4792 ??? What is wrong with an empty section??? */
4793 rel_hdr->sh_size = rel_hdr->sh_entsize;
4796 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
4797 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
4798 input_section->reloc_count -= deleted;
4804 /* Finish up dynamic symbol handling. We set the contents of various
4805 dynamic sections here. */
4808 elf_i386_finish_dynamic_symbol (bfd *output_bfd,
4809 struct bfd_link_info *info,
4810 struct elf_link_hash_entry *h,
4811 Elf_Internal_Sym *sym)
4813 struct elf_x86_link_hash_table *htab;
4814 unsigned plt_entry_size;
4815 const struct elf_i386_backend_data *abed;
4816 struct elf_x86_link_hash_entry *eh;
4817 bfd_boolean local_undefweak;
4818 bfd_boolean use_plt_second;
4820 htab = elf_x86_hash_table (info, I386_ELF_DATA);
4824 abed = get_elf_i386_backend_data (output_bfd);
4825 plt_entry_size = htab->plt.plt_entry_size;
4827 /* Use the second PLT section only if there is .plt section. */
4828 use_plt_second = htab->elf.splt != NULL && htab->plt_second != NULL;
4830 eh = (struct elf_x86_link_hash_entry *) h;
4831 if (eh->no_finish_dynamic_symbol)
4834 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
4835 resolved undefined weak symbols in executable so that their
4836 references have value 0 at run-time. */
4837 local_undefweak = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, I386_ELF_DATA,
4841 if (h->plt.offset != (bfd_vma) -1)
4843 bfd_vma plt_index, plt_offset;
4845 Elf_Internal_Rela rel;
4847 asection *plt, *resolved_plt, *gotplt, *relplt;
4849 /* When building a static executable, use .iplt, .igot.plt and
4850 .rel.iplt sections for STT_GNU_IFUNC symbols. */
4851 if (htab->elf.splt != NULL)
4853 plt = htab->elf.splt;
4854 gotplt = htab->elf.sgotplt;
4855 relplt = htab->elf.srelplt;
4859 plt = htab->elf.iplt;
4860 gotplt = htab->elf.igotplt;
4861 relplt = htab->elf.irelplt;
4864 /* This symbol has an entry in the procedure linkage table. Set
4867 if ((h->dynindx == -1
4869 && !((h->forced_local || bfd_link_executable (info))
4871 && h->type == STT_GNU_IFUNC))
4877 /* Get the index in the procedure linkage table which
4878 corresponds to this symbol. This is the index of this symbol
4879 in all the symbols for which we are making plt entries. The
4880 first entry in the procedure linkage table is reserved.
4882 Get the offset into the .got table of the entry that
4883 corresponds to this function. Each .got entry is 4 bytes.
4884 The first three are reserved.
4886 For static executables, we don't reserve anything. */
4888 if (plt == htab->elf.splt)
4890 got_offset = (h->plt.offset / plt_entry_size
4891 - htab->plt.has_plt0);
4892 got_offset = (got_offset + 3) * 4;
4896 got_offset = h->plt.offset / plt_entry_size;
4897 got_offset = got_offset * 4;
4900 /* Fill in the entry in the procedure linkage table and update
4902 memcpy (plt->contents + h->plt.offset, htab->plt.plt_entry,
4907 const bfd_byte *plt_entry;
4908 if (bfd_link_pic (info))
4909 plt_entry = htab->non_lazy_plt->pic_plt_entry;
4911 plt_entry = htab->non_lazy_plt->plt_entry;
4912 memcpy (htab->plt_second->contents + eh->plt_second.offset,
4913 plt_entry, htab->non_lazy_plt->plt_entry_size);
4915 resolved_plt = htab->plt_second;
4916 plt_offset = eh->plt_second.offset;
4921 plt_offset = h->plt.offset;
4924 if (! bfd_link_pic (info))
4926 bfd_put_32 (output_bfd,
4927 (gotplt->output_section->vma
4928 + gotplt->output_offset
4930 resolved_plt->contents + plt_offset
4931 + htab->plt.plt_got_offset);
4933 if (abed->os == is_vxworks)
4935 int s, k, reloc_index;
4937 /* Create the R_386_32 relocation referencing the GOT
4938 for this PLT entry. */
4940 /* S: Current slot number (zero-based). */
4941 s = ((h->plt.offset - htab->plt.plt_entry_size)
4942 / htab->plt.plt_entry_size);
4943 /* K: Number of relocations for PLTResolve. */
4944 if (bfd_link_pic (info))
4945 k = PLTRESOLVE_RELOCS_SHLIB;
4947 k = PLTRESOLVE_RELOCS;
4948 /* Skip the PLTresolve relocations, and the relocations for
4949 the other PLT slots. */
4950 reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
4951 loc = (htab->srelplt2->contents + reloc_index
4952 * sizeof (Elf32_External_Rel));
4954 rel.r_offset = (plt->output_section->vma
4955 + plt->output_offset
4956 + h->plt.offset + 2),
4957 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
4958 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
4960 /* Create the R_386_32 relocation referencing the beginning of
4961 the PLT for this GOT entry. */
4962 rel.r_offset = (htab->elf.sgotplt->output_section->vma
4963 + htab->elf.sgotplt->output_offset
4965 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
4966 bfd_elf32_swap_reloc_out (output_bfd, &rel,
4967 loc + sizeof (Elf32_External_Rel));
4972 bfd_put_32 (output_bfd, got_offset,
4973 resolved_plt->contents + plt_offset
4974 + htab->plt.plt_got_offset);
4977 /* Fill in the entry in the global offset table. Leave the entry
4978 as zero for undefined weak symbol in PIE. No PLT relocation
4979 against undefined weak symbol in PIE. */
4980 if (!local_undefweak)
4982 if (htab->plt.has_plt0)
4983 bfd_put_32 (output_bfd,
4984 (plt->output_section->vma
4985 + plt->output_offset
4987 + htab->lazy_plt->plt_lazy_offset),
4988 gotplt->contents + got_offset);
4990 /* Fill in the entry in the .rel.plt section. */
4991 rel.r_offset = (gotplt->output_section->vma
4992 + gotplt->output_offset
4994 if (h->dynindx == -1
4995 || ((bfd_link_executable (info)
4996 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4998 && h->type == STT_GNU_IFUNC))
5000 info->callbacks->minfo (_("Local IFUNC function `%s' in %B\n"),
5001 h->root.root.string,
5002 h->root.u.def.section->owner);
5004 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5005 R_386_IRELATIVE instead of R_386_JUMP_SLOT. Store addend
5006 in the .got.plt section. */
5007 bfd_put_32 (output_bfd,
5008 (h->root.u.def.value
5009 + h->root.u.def.section->output_section->vma
5010 + h->root.u.def.section->output_offset),
5011 gotplt->contents + got_offset);
5012 rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
5013 /* R_386_IRELATIVE comes last. */
5014 plt_index = htab->next_irelative_index--;
5018 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
5019 plt_index = htab->next_jump_slot_index++;
5022 loc = relplt->contents + plt_index * sizeof (Elf32_External_Rel);
5023 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5025 /* Don't fill the second and third slots in PLT entry for
5026 static executables nor without PLT0. */
5027 if (plt == htab->elf.splt && htab->plt.has_plt0)
5029 bfd_put_32 (output_bfd,
5030 plt_index * sizeof (Elf32_External_Rel),
5031 plt->contents + h->plt.offset
5032 + htab->lazy_plt->plt_reloc_offset);
5033 bfd_put_32 (output_bfd,
5035 + htab->lazy_plt->plt_plt_offset + 4),
5036 (plt->contents + h->plt.offset
5037 + htab->lazy_plt->plt_plt_offset));
5041 else if (eh->plt_got.offset != (bfd_vma) -1)
5043 bfd_vma got_offset, plt_offset;
5044 asection *plt, *got, *gotplt;
5045 const bfd_byte *got_plt_entry;
5047 /* Set the entry in the GOT procedure linkage table. */
5048 plt = htab->plt_got;
5049 got = htab->elf.sgot;
5050 gotplt = htab->elf.sgotplt;
5051 got_offset = h->got.offset;
5053 if (got_offset == (bfd_vma) -1
5059 /* Fill in the entry in the GOT procedure linkage table. */
5060 if (! bfd_link_pic (info))
5062 got_plt_entry = htab->non_lazy_plt->plt_entry;
5063 got_offset += got->output_section->vma + got->output_offset;
5067 got_plt_entry = htab->non_lazy_plt->pic_plt_entry;
5068 got_offset += (got->output_section->vma
5069 + got->output_offset
5070 - gotplt->output_section->vma
5071 - gotplt->output_offset);
5074 plt_offset = eh->plt_got.offset;
5075 memcpy (plt->contents + plt_offset, got_plt_entry,
5076 htab->non_lazy_plt->plt_entry_size);
5077 bfd_put_32 (output_bfd, got_offset,
5078 (plt->contents + plt_offset
5079 + htab->non_lazy_plt->plt_got_offset));
5082 if (!local_undefweak
5084 && (h->plt.offset != (bfd_vma) -1
5085 || eh->plt_got.offset != (bfd_vma) -1))
5087 /* Mark the symbol as undefined, rather than as defined in
5088 the .plt section. Leave the value if there were any
5089 relocations where pointer equality matters (this is a clue
5090 for the dynamic linker, to make function pointer
5091 comparisons work between an application and shared
5092 library), otherwise set it to zero. If a function is only
5093 called from a binary, there is no need to slow down
5094 shared libraries because of that. */
5095 sym->st_shndx = SHN_UNDEF;
5096 if (!h->pointer_equality_needed)
5100 /* Don't generate dynamic GOT relocation against undefined weak
5101 symbol in executable. */
5102 if (h->got.offset != (bfd_vma) -1
5103 && ! GOT_TLS_GD_ANY_P (elf_x86_hash_entry(h)->tls_type)
5104 && (elf_x86_hash_entry(h)->tls_type & GOT_TLS_IE) == 0
5105 && !local_undefweak)
5107 Elf_Internal_Rela rel;
5108 asection *relgot = htab->elf.srelgot;
5110 /* This symbol has an entry in the global offset table. Set it
5113 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
5116 rel.r_offset = (htab->elf.sgot->output_section->vma
5117 + htab->elf.sgot->output_offset
5118 + (h->got.offset & ~(bfd_vma) 1));
5120 /* If this is a static link, or it is a -Bsymbolic link and the
5121 symbol is defined locally or was forced to be local because
5122 of a version file, we just want to emit a RELATIVE reloc.
5123 The entry in the global offset table will already have been
5124 initialized in the relocate_section function. */
5126 && h->type == STT_GNU_IFUNC)
5128 if (h->plt.offset == (bfd_vma) -1)
5130 /* STT_GNU_IFUNC is referenced without PLT. */
5131 if (htab->elf.splt == NULL)
5133 /* use .rel[a].iplt section to store .got relocations
5134 in static executable. */
5135 relgot = htab->elf.irelplt;
5137 if (SYMBOL_REFERENCES_LOCAL (info, h))
5139 info->callbacks->minfo (_("Local IFUNC function `%s' in %B\n"),
5140 h->root.root.string,
5141 h->root.u.def.section->owner);
5143 bfd_put_32 (output_bfd,
5144 (h->root.u.def.value
5145 + h->root.u.def.section->output_section->vma
5146 + h->root.u.def.section->output_offset),
5147 htab->elf.sgot->contents + h->got.offset);
5148 rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
5153 else if (bfd_link_pic (info))
5155 /* Generate R_386_GLOB_DAT. */
5163 if (!h->pointer_equality_needed)
5166 /* For non-shared object, we can't use .got.plt, which
5167 contains the real function addres if we need pointer
5168 equality. We load the GOT entry with the PLT entry. */
5169 if (htab->plt_second != NULL)
5171 plt = htab->plt_second;
5172 plt_offset = eh->plt_second.offset;
5176 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
5177 plt_offset = h->plt.offset;
5179 bfd_put_32 (output_bfd,
5180 (plt->output_section->vma
5181 + plt->output_offset + plt_offset),
5182 htab->elf.sgot->contents + h->got.offset);
5186 else if (bfd_link_pic (info)
5187 && SYMBOL_REFERENCES_LOCAL (info, h))
5189 BFD_ASSERT((h->got.offset & 1) != 0);
5190 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
5194 BFD_ASSERT((h->got.offset & 1) == 0);
5196 bfd_put_32 (output_bfd, (bfd_vma) 0,
5197 htab->elf.sgot->contents + h->got.offset);
5198 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
5201 elf_append_rel (output_bfd, relgot, &rel);
5206 Elf_Internal_Rela rel;
5209 /* This symbol needs a copy reloc. Set it up. */
5211 if (h->dynindx == -1
5212 || (h->root.type != bfd_link_hash_defined
5213 && h->root.type != bfd_link_hash_defweak)
5214 || htab->elf.srelbss == NULL
5215 || htab->elf.sreldynrelro == NULL)
5218 rel.r_offset = (h->root.u.def.value
5219 + h->root.u.def.section->output_section->vma
5220 + h->root.u.def.section->output_offset);
5221 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
5222 if (h->root.u.def.section == htab->elf.sdynrelro)
5223 s = htab->elf.sreldynrelro;
5225 s = htab->elf.srelbss;
5226 elf_append_rel (output_bfd, s, &rel);
5232 /* Finish up local dynamic symbol handling. We set the contents of
5233 various dynamic sections here. */
5236 elf_i386_finish_local_dynamic_symbol (void **slot, void *inf)
5238 struct elf_link_hash_entry *h
5239 = (struct elf_link_hash_entry *) *slot;
5240 struct bfd_link_info *info
5241 = (struct bfd_link_info *) inf;
5243 return elf_i386_finish_dynamic_symbol (info->output_bfd, info,
5247 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5248 here since undefined weak symbol may not be dynamic and may not be
5249 called for elf_i386_finish_dynamic_symbol. */
5252 elf_i386_pie_finish_undefweak_symbol (struct bfd_hash_entry *bh,
5255 struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
5256 struct bfd_link_info *info = (struct bfd_link_info *) inf;
5258 if (h->root.type != bfd_link_hash_undefweak
5259 || h->dynindx != -1)
5262 return elf_i386_finish_dynamic_symbol (info->output_bfd,
5266 /* Used to decide how to sort relocs in an optimal manner for the
5267 dynamic linker, before writing them out. */
5269 static enum elf_reloc_type_class
5270 elf_i386_reloc_type_class (const struct bfd_link_info *info,
5271 const asection *rel_sec ATTRIBUTE_UNUSED,
5272 const Elf_Internal_Rela *rela)
5274 bfd *abfd = info->output_bfd;
5275 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5276 struct elf_link_hash_table *htab = elf_hash_table (info);
5278 if (htab->dynsym != NULL
5279 && htab->dynsym->contents != NULL)
5281 /* Check relocation against STT_GNU_IFUNC symbol if there are
5283 unsigned long r_symndx = ELF32_R_SYM (rela->r_info);
5284 if (r_symndx != STN_UNDEF)
5286 Elf_Internal_Sym sym;
5287 if (!bed->s->swap_symbol_in (abfd,
5288 (htab->dynsym->contents
5289 + r_symndx * sizeof (Elf32_External_Sym)),
5293 if (ELF32_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
5294 return reloc_class_ifunc;
5298 switch (ELF32_R_TYPE (rela->r_info))
5300 case R_386_IRELATIVE:
5301 return reloc_class_ifunc;
5302 case R_386_RELATIVE:
5303 return reloc_class_relative;
5304 case R_386_JUMP_SLOT:
5305 return reloc_class_plt;
5307 return reloc_class_copy;
5309 return reloc_class_normal;
5313 /* Finish up the dynamic sections. */
5316 elf_i386_finish_dynamic_sections (bfd *output_bfd,
5317 struct bfd_link_info *info)
5319 struct elf_x86_link_hash_table *htab;
5322 const struct elf_i386_backend_data *abed;
5324 htab = elf_x86_hash_table (info, I386_ELF_DATA);
5328 dynobj = htab->elf.dynobj;
5329 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
5330 abed = get_elf_i386_backend_data (output_bfd);
5332 if (htab->elf.dynamic_sections_created)
5334 Elf32_External_Dyn *dyncon, *dynconend;
5336 if (sdyn == NULL || htab->elf.sgot == NULL)
5339 dyncon = (Elf32_External_Dyn *) sdyn->contents;
5340 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5341 for (; dyncon < dynconend; dyncon++)
5343 Elf_Internal_Dyn dyn;
5346 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5351 if (abed->os == is_vxworks
5352 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
5357 s = htab->elf.sgotplt;
5358 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5362 s = htab->elf.srelplt;
5363 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5367 s = htab->elf.srelplt;
5368 dyn.d_un.d_val = s->size;
5372 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5375 if (htab->elf.splt && htab->elf.splt->size > 0)
5377 /* UnixWare sets the entsize of .plt to 4, although that doesn't
5378 really seem like the right value. */
5379 elf_section_data (htab->elf.splt->output_section)
5380 ->this_hdr.sh_entsize = 4;
5382 if (htab->plt.has_plt0)
5384 /* Fill in the special first entry in the procedure linkage
5386 memcpy (htab->elf.splt->contents, htab->plt.plt0_entry,
5387 htab->lazy_plt->plt0_entry_size);
5388 memset (htab->elf.splt->contents + htab->lazy_plt->plt0_entry_size,
5389 abed->plt0_pad_byte,
5390 htab->plt.plt_entry_size - htab->lazy_plt->plt0_entry_size);
5391 if (!bfd_link_pic (info))
5393 bfd_put_32 (output_bfd,
5394 (htab->elf.sgotplt->output_section->vma
5395 + htab->elf.sgotplt->output_offset
5397 htab->elf.splt->contents
5398 + htab->lazy_plt->plt0_got1_offset);
5399 bfd_put_32 (output_bfd,
5400 (htab->elf.sgotplt->output_section->vma
5401 + htab->elf.sgotplt->output_offset
5403 htab->elf.splt->contents
5404 + htab->lazy_plt->plt0_got2_offset);
5406 if (abed->os == is_vxworks)
5408 Elf_Internal_Rela rel;
5409 int num_plts = (htab->elf.splt->size
5410 / htab->plt.plt_entry_size) - 1;
5412 asection *srelplt2 = htab->srelplt2;
5414 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_
5415 + 4. On IA32 we use REL relocations so the
5416 addend goes in the PLT directly. */
5417 rel.r_offset = (htab->elf.splt->output_section->vma
5418 + htab->elf.splt->output_offset
5419 + htab->lazy_plt->plt0_got1_offset);
5420 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
5422 bfd_elf32_swap_reloc_out (output_bfd, &rel,
5423 srelplt2->contents);
5424 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_
5426 rel.r_offset = (htab->elf.splt->output_section->vma
5427 + htab->elf.splt->output_offset
5428 + htab->lazy_plt->plt0_got2_offset);
5429 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
5431 bfd_elf32_swap_reloc_out (output_bfd, &rel,
5432 srelplt2->contents +
5433 sizeof (Elf32_External_Rel));
5434 /* Correct the .rel.plt.unloaded relocations. */
5435 p = srelplt2->contents;
5436 if (bfd_link_pic (info))
5437 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
5439 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
5441 for (; num_plts; num_plts--)
5443 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
5444 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx,
5446 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
5447 p += sizeof (Elf32_External_Rel);
5449 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
5450 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx,
5452 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
5453 p += sizeof (Elf32_External_Rel);
5460 if (htab->plt_got != NULL && htab->plt_got->size > 0)
5461 elf_section_data (htab->plt_got->output_section)
5462 ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size;
5464 if (htab->plt_second != NULL && htab->plt_second->size > 0)
5465 elf_section_data (htab->plt_second->output_section)
5466 ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size;
5469 /* Fill in the first three entries in the global offset table. */
5470 if (htab->elf.sgotplt && htab->elf.sgotplt->size > 0)
5472 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
5475 (_("discarded output section: `%A'"), htab->elf.sgotplt);
5479 bfd_put_32 (output_bfd,
5481 : sdyn->output_section->vma + sdyn->output_offset),
5482 htab->elf.sgotplt->contents);
5483 bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 4);
5484 bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 8);
5486 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize = 4;
5489 /* Adjust .eh_frame for .plt section. */
5490 if (htab->plt_eh_frame != NULL
5491 && htab->plt_eh_frame->contents != NULL)
5493 if (htab->elf.splt != NULL
5494 && htab->elf.splt->size != 0
5495 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
5496 && htab->elf.splt->output_section != NULL
5497 && htab->plt_eh_frame->output_section != NULL)
5499 bfd_vma plt_start = htab->elf.splt->output_section->vma;
5500 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
5501 + htab->plt_eh_frame->output_offset
5502 + PLT_FDE_START_OFFSET;
5503 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
5504 htab->plt_eh_frame->contents
5505 + PLT_FDE_START_OFFSET);
5507 if (htab->plt_eh_frame->sec_info_type
5508 == SEC_INFO_TYPE_EH_FRAME)
5510 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
5512 htab->plt_eh_frame->contents))
5517 /* Adjust .eh_frame for .plt.got section. */
5518 if (htab->plt_got_eh_frame != NULL
5519 && htab->plt_got_eh_frame->contents != NULL)
5521 if (htab->plt_got != NULL
5522 && htab->plt_got->size != 0
5523 && (htab->plt_got->flags & SEC_EXCLUDE) == 0
5524 && htab->plt_got->output_section != NULL
5525 && htab->plt_got_eh_frame->output_section != NULL)
5527 bfd_vma plt_start = htab->plt_got->output_section->vma;
5528 bfd_vma eh_frame_start = htab->plt_got_eh_frame->output_section->vma
5529 + htab->plt_got_eh_frame->output_offset
5530 + PLT_FDE_START_OFFSET;
5531 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
5532 htab->plt_got_eh_frame->contents
5533 + PLT_FDE_START_OFFSET);
5535 if (htab->plt_got_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
5537 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
5538 htab->plt_got_eh_frame,
5539 htab->plt_got_eh_frame->contents))
5544 /* Adjust .eh_frame for the second PLT section. */
5545 if (htab->plt_second_eh_frame != NULL
5546 && htab->plt_second_eh_frame->contents != NULL)
5548 if (htab->plt_second != NULL
5549 && htab->plt_second->size != 0
5550 && (htab->plt_second->flags & SEC_EXCLUDE) == 0
5551 && htab->plt_second->output_section != NULL
5552 && htab->plt_second_eh_frame->output_section != NULL)
5554 bfd_vma plt_start = htab->plt_second->output_section->vma;
5555 bfd_vma eh_frame_start
5556 = (htab->plt_second_eh_frame->output_section->vma
5557 + htab->plt_second_eh_frame->output_offset
5558 + PLT_FDE_START_OFFSET);
5559 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
5560 htab->plt_second_eh_frame->contents
5561 + PLT_FDE_START_OFFSET);
5563 if (htab->plt_second_eh_frame->sec_info_type
5564 == SEC_INFO_TYPE_EH_FRAME)
5566 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
5567 htab->plt_second_eh_frame,
5568 htab->plt_second_eh_frame->contents))
5573 if (htab->elf.sgot && htab->elf.sgot->size > 0)
5574 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 4;
5576 /* Fill PLT entries for undefined weak symbols in PIE. */
5577 if (bfd_link_pie (info))
5578 bfd_hash_traverse (&info->hash->table,
5579 elf_i386_pie_finish_undefweak_symbol,
5585 /* Fill PLT/GOT entries and allocate dynamic relocations for local
5586 STT_GNU_IFUNC symbols, which aren't in the ELF linker hash table.
5587 It has to be done before elf_link_sort_relocs is called so that
5588 dynamic relocations are properly sorted. */
5591 elf_i386_output_arch_local_syms
5592 (bfd *output_bfd ATTRIBUTE_UNUSED,
5593 struct bfd_link_info *info,
5594 void *flaginfo ATTRIBUTE_UNUSED,
5595 int (*func) (void *, const char *,
5598 struct elf_link_hash_entry *) ATTRIBUTE_UNUSED)
5600 struct elf_x86_link_hash_table *htab
5601 = elf_x86_hash_table (info, I386_ELF_DATA);
5605 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5606 htab_traverse (htab->loc_hash_table,
5607 elf_i386_finish_local_dynamic_symbol,
5613 /* Forward declaration. */
5614 static const struct elf_x86_lazy_plt_layout elf_i386_nacl_plt;
5616 /* Similar to _bfd_elf_get_synthetic_symtab. Support PLTs with all
5617 dynamic relocations. */
5620 elf_i386_get_synthetic_symtab (bfd *abfd,
5621 long symcount ATTRIBUTE_UNUSED,
5622 asymbol **syms ATTRIBUTE_UNUSED,
5629 bfd_byte *plt_contents;
5631 const struct elf_x86_lazy_plt_layout *lazy_plt;
5632 const struct elf_x86_non_lazy_plt_layout *non_lazy_plt;
5633 const struct elf_x86_lazy_plt_layout *lazy_ibt_plt;
5634 const struct elf_x86_non_lazy_plt_layout *non_lazy_ibt_plt;
5637 enum elf_x86_plt_type plt_type;
5638 struct elf_x86_plt plts[] =
5640 { ".plt", NULL, NULL, plt_unknown, 0, 0, 0, 0 },
5641 { ".plt.got", NULL, NULL, plt_non_lazy, 0, 0, 0, 0 },
5642 { ".plt.sec", NULL, NULL, plt_second, 0, 0, 0, 0 },
5643 { NULL, NULL, NULL, plt_non_lazy, 0, 0, 0, 0 }
5648 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
5651 if (dynsymcount <= 0)
5654 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
5658 non_lazy_plt = NULL;
5659 /* Silence GCC 6. */
5661 non_lazy_ibt_plt = NULL;
5662 lazy_ibt_plt = NULL;
5663 switch (get_elf_i386_backend_data (abfd)->os)
5666 non_lazy_plt = &elf_i386_non_lazy_plt;
5667 lazy_ibt_plt = &elf_i386_lazy_ibt_plt;
5668 non_lazy_ibt_plt = &elf_i386_non_lazy_ibt_plt;
5671 lazy_plt = &elf_i386_lazy_plt;
5674 lazy_plt = &elf_i386_nacl_plt;
5681 for (j = 0; plts[j].name != NULL; j++)
5683 plt = bfd_get_section_by_name (abfd, plts[j].name);
5684 if (plt == NULL || plt->size == 0)
5687 /* Get the PLT section contents. */
5688 plt_contents = (bfd_byte *) bfd_malloc (plt->size);
5689 if (plt_contents == NULL)
5691 if (!bfd_get_section_contents (abfd, (asection *) plt,
5692 plt_contents, 0, plt->size))
5694 free (plt_contents);
5698 /* Check what kind of PLT it is. */
5699 plt_type = plt_unknown;
5700 if (plts[j].type == plt_unknown
5701 && (plt->size >= (lazy_plt->plt0_entry_size
5702 + lazy_plt->plt_entry_size)))
5704 /* Match lazy PLT first. */
5705 if (memcmp (plt_contents, lazy_plt->plt0_entry,
5706 lazy_plt->plt0_got1_offset) == 0)
5708 /* The fist entry in the lazy IBT PLT is the same as the
5710 if (lazy_ibt_plt != NULL
5711 && (memcmp (plt_contents + lazy_ibt_plt->plt0_entry_size,
5712 lazy_ibt_plt->plt_entry,
5713 lazy_ibt_plt->plt_got_offset) == 0))
5714 plt_type = plt_lazy | plt_second;
5716 plt_type = plt_lazy;
5718 else if (memcmp (plt_contents, lazy_plt->pic_plt0_entry,
5719 lazy_plt->plt0_got1_offset) == 0)
5721 /* The fist entry in the PIC lazy IBT PLT is the same as
5722 the normal PIC lazy PLT. */
5723 if (lazy_ibt_plt != NULL
5724 && (memcmp (plt_contents + lazy_ibt_plt->plt0_entry_size,
5725 lazy_ibt_plt->pic_plt_entry,
5726 lazy_ibt_plt->plt_got_offset) == 0))
5727 plt_type = plt_lazy | plt_pic | plt_second;
5729 plt_type = plt_lazy | plt_pic;
5733 if (non_lazy_plt != NULL
5734 && (plt_type == plt_unknown || plt_type == plt_non_lazy)
5735 && plt->size >= non_lazy_plt->plt_entry_size)
5737 /* Match non-lazy PLT. */
5738 if (memcmp (plt_contents, non_lazy_plt->plt_entry,
5739 non_lazy_plt->plt_got_offset) == 0)
5740 plt_type = plt_non_lazy;
5741 else if (memcmp (plt_contents, non_lazy_plt->pic_plt_entry,
5742 non_lazy_plt->plt_got_offset) == 0)
5746 if ((non_lazy_ibt_plt != NULL)
5747 && (plt_type == plt_unknown || plt_type == plt_second)
5748 && plt->size >= non_lazy_ibt_plt->plt_entry_size)
5750 if (memcmp (plt_contents,
5751 non_lazy_ibt_plt->plt_entry,
5752 non_lazy_ibt_plt->plt_got_offset) == 0)
5754 /* Match IBT PLT. */
5755 plt_type = plt_second;
5756 non_lazy_plt = non_lazy_ibt_plt;
5758 else if (memcmp (plt_contents,
5759 non_lazy_ibt_plt->pic_plt_entry,
5760 non_lazy_ibt_plt->plt_got_offset) == 0)
5762 /* Match PIC IBT PLT. */
5763 plt_type = plt_second | plt_pic;
5764 non_lazy_plt = non_lazy_ibt_plt;
5768 if (plt_type == plt_unknown)
5770 free (plt_contents);
5775 plts[j].type = plt_type;
5777 if ((plt_type & plt_lazy))
5779 plts[j].plt_got_offset = lazy_plt->plt_got_offset;
5780 plts[j].plt_entry_size = lazy_plt->plt_entry_size;
5781 /* Skip PLT0 in lazy PLT. */
5786 plts[j].plt_got_offset = non_lazy_plt->plt_got_offset;
5787 plts[j].plt_entry_size = non_lazy_plt->plt_entry_size;
5791 /* Skip lazy PLT when the second PLT is used. */
5792 if ((plt_type & (plt_lazy | plt_second))
5793 == (plt_lazy | plt_second))
5797 n = plt->size / plts[j].plt_entry_size;
5802 plts[j].contents = plt_contents;
5804 /* The _GLOBAL_OFFSET_TABLE_ address is needed. */
5805 if ((plt_type & plt_pic))
5806 got_addr = (bfd_vma) -1;
5809 return _bfd_x86_elf_get_synthetic_symtab (abfd, count, relsize,
5810 got_addr, plts, dynsyms,
5814 /* Set up i386 GNU properties. Return the first relocatable ELF input
5815 with GNU properties if found. Otherwise, return NULL. */
5818 elf_i386_link_setup_gnu_properties (struct bfd_link_info *info)
5820 struct elf_x86_plt_layout_table plt_layout;
5822 plt_layout.normal_target = FALSE;
5823 plt_layout.is_vxworks = FALSE;
5824 switch (get_elf_i386_backend_data (info->output_bfd)->os)
5827 plt_layout.lazy_plt = &elf_i386_lazy_plt;
5828 plt_layout.non_lazy_plt = &elf_i386_non_lazy_plt;
5829 plt_layout.lazy_ibt_plt = &elf_i386_lazy_ibt_plt;
5830 plt_layout.non_lazy_ibt_plt = &elf_i386_non_lazy_ibt_plt;
5831 plt_layout.normal_target = TRUE;
5834 plt_layout.lazy_plt = &elf_i386_lazy_plt;
5835 plt_layout.non_lazy_plt = NULL;
5836 plt_layout.lazy_ibt_plt = NULL;
5837 plt_layout.non_lazy_ibt_plt = NULL;
5838 plt_layout.is_vxworks = TRUE;
5841 plt_layout.lazy_plt = &elf_i386_nacl_plt;
5842 plt_layout.non_lazy_plt = NULL;
5843 plt_layout.lazy_ibt_plt = NULL;
5844 plt_layout.non_lazy_ibt_plt = NULL;
5848 return _bfd_x86_elf_link_setup_gnu_properties (info, &plt_layout);
5851 #define TARGET_LITTLE_SYM i386_elf32_vec
5852 #define TARGET_LITTLE_NAME "elf32-i386"
5853 #define ELF_ARCH bfd_arch_i386
5854 #define ELF_TARGET_ID I386_ELF_DATA
5855 #define ELF_MACHINE_CODE EM_386
5856 #define ELF_MAXPAGESIZE 0x1000
5858 #define elf_backend_can_gc_sections 1
5859 #define elf_backend_can_refcount 1
5860 #define elf_backend_want_got_plt 1
5861 #define elf_backend_plt_readonly 1
5862 #define elf_backend_want_plt_sym 0
5863 #define elf_backend_got_header_size 12
5864 #define elf_backend_plt_alignment 4
5865 #define elf_backend_dtrel_excludes_plt 1
5866 #define elf_backend_extern_protected_data 1
5867 #define elf_backend_caches_rawsize 1
5868 #define elf_backend_want_dynrelro 1
5870 /* Support RELA for objdump of prelink objects. */
5871 #define elf_info_to_howto elf_i386_info_to_howto_rel
5872 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
5874 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
5875 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
5876 #define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
5877 #define bfd_elf32_get_synthetic_symtab elf_i386_get_synthetic_symtab
5879 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
5880 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
5881 #define elf_backend_check_relocs elf_i386_check_relocs
5882 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
5883 #define elf_backend_fake_sections elf_i386_fake_sections
5884 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
5885 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
5886 #define elf_backend_output_arch_local_syms elf_i386_output_arch_local_syms
5887 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
5888 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
5889 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
5890 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
5891 #define elf_backend_relocate_section elf_i386_relocate_section
5892 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
5893 #define elf_backend_setup_gnu_properties elf_i386_link_setup_gnu_properties
5895 #include "elf32-target.h"
5897 /* FreeBSD support. */
5899 #undef TARGET_LITTLE_SYM
5900 #define TARGET_LITTLE_SYM i386_elf32_fbsd_vec
5901 #undef TARGET_LITTLE_NAME
5902 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
5904 #define ELF_OSABI ELFOSABI_FREEBSD
5906 /* The kernel recognizes executables as valid only if they carry a
5907 "FreeBSD" label in the ELF header. So we put this label on all
5908 executables and (for simplicity) also all other object files. */
5911 elf_i386_fbsd_post_process_headers (bfd *abfd, struct bfd_link_info *info)
5913 _bfd_elf_post_process_headers (abfd, info);
5915 #ifdef OLD_FREEBSD_ABI_LABEL
5917 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
5918 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
5919 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
5924 #undef elf_backend_post_process_headers
5925 #define elf_backend_post_process_headers elf_i386_fbsd_post_process_headers
5927 #define elf32_bed elf32_i386_fbsd_bed
5929 #undef elf_backend_add_symbol_hook
5931 #include "elf32-target.h"
5935 #undef TARGET_LITTLE_SYM
5936 #define TARGET_LITTLE_SYM i386_elf32_sol2_vec
5937 #undef TARGET_LITTLE_NAME
5938 #define TARGET_LITTLE_NAME "elf32-i386-sol2"
5940 #undef elf_backend_post_process_headers
5942 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5943 objects won't be recognized. */
5947 #define elf32_bed elf32_i386_sol2_bed
5949 /* The 32-bit static TLS arena size is rounded to the nearest 8-byte
5951 #undef elf_backend_static_tls_alignment
5952 #define elf_backend_static_tls_alignment 8
5954 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5956 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5958 #undef elf_backend_want_plt_sym
5959 #define elf_backend_want_plt_sym 1
5961 #undef elf_backend_strtab_flags
5962 #define elf_backend_strtab_flags SHF_STRINGS
5964 /* Called to set the sh_flags, sh_link and sh_info fields of OSECTION which
5965 has a type >= SHT_LOOS. Returns TRUE if these fields were initialised
5966 FALSE otherwise. ISECTION is the best guess matching section from the
5967 input bfd IBFD, but it might be NULL. */
5970 elf32_i386_copy_solaris_special_section_fields (const bfd *ibfd ATTRIBUTE_UNUSED,
5971 bfd *obfd ATTRIBUTE_UNUSED,
5972 const Elf_Internal_Shdr *isection ATTRIBUTE_UNUSED,
5973 Elf_Internal_Shdr *osection ATTRIBUTE_UNUSED)
5975 /* PR 19938: FIXME: Need to add code for setting the sh_info
5976 and sh_link fields of Solaris specific section types. */
5979 /* Based upon Oracle Solaris 11.3 Linkers and Libraries Guide, Ch. 13,
5980 Object File Format, Table 13-9 ELF sh_link and sh_info Interpretation:
5982 http://docs.oracle.com/cd/E53394_01/html/E54813/chapter6-94076.html#scrolltoc
5984 The following values should be set:
5987 -----------------------------------------------------------------------------
5988 SHT_SUNW_ancillary The section header index of 0
5989 [0x6fffffee] the associated string table.
5991 SHT_SUNW_capinfo The section header index of For a dynamic object, the
5992 [0x6ffffff0] the associated symbol table. section header index of
5994 SHT_SUNW_capchain table,
5997 SHT_SUNW_symsort The section header index of 0
5998 [0x6ffffff1] the associated symbol table.
6000 SHT_SUNW_tlssort The section header index of 0
6001 [0x6ffffff2] the associated symbol table.
6003 SHT_SUNW_LDYNSYM The section header index of One greater than the
6004 [0x6ffffff3] the associated string table. symbol table index of the
6005 This index is the same string last local symbol,
6006 table used by the SHT_DYNSYM STB_LOCAL. Since
6007 section. SHT_SUNW_LDYNSYM only
6008 contains local symbols,
6009 sh_info is equivalent to
6010 the number of symbols in
6013 SHT_SUNW_cap If symbol capabilities exist, If any capabilities refer
6014 [0x6ffffff5] the section header index of to named strings, the
6015 the associated section header index of
6016 SHT_SUNW_capinfo table, the associated string
6017 otherwise 0. table, otherwise 0.
6019 SHT_SUNW_move The section header index of 0
6020 [0x6ffffffa] the associated symbol table.
6025 SHT_SUNW_syminfo The section header index of The section header index
6026 [0x6ffffffc] the associated symbol table. of the associated
6029 SHT_SUNW_verdef The section header index of The number of version
6030 [0x6ffffffd] the associated string table. definitions within the
6033 SHT_SUNW_verneed The section header index of The number of version
6034 [0x6ffffffe] the associated string table. dependencies within the
6037 SHT_SUNW_versym The section header index of 0
6038 [0x6fffffff] the associated symbol table. */
6041 #undef elf_backend_copy_special_section_fields
6042 #define elf_backend_copy_special_section_fields elf32_i386_copy_solaris_special_section_fields
6044 #include "elf32-target.h"
6046 /* Intel MCU support. */
6049 elf32_iamcu_elf_object_p (bfd *abfd)
6051 /* Set the right machine number for an IAMCU elf32 file. */
6052 bfd_default_set_arch_mach (abfd, bfd_arch_iamcu, bfd_mach_i386_iamcu);
6056 #undef TARGET_LITTLE_SYM
6057 #define TARGET_LITTLE_SYM iamcu_elf32_vec
6058 #undef TARGET_LITTLE_NAME
6059 #define TARGET_LITTLE_NAME "elf32-iamcu"
6061 #define ELF_ARCH bfd_arch_iamcu
6063 #undef ELF_MACHINE_CODE
6064 #define ELF_MACHINE_CODE EM_IAMCU
6069 #define elf32_bed elf32_iamcu_bed
6071 #undef elf_backend_object_p
6072 #define elf_backend_object_p elf32_iamcu_elf_object_p
6074 #undef elf_backend_static_tls_alignment
6076 #undef elf_backend_want_plt_sym
6077 #define elf_backend_want_plt_sym 0
6079 #undef elf_backend_strtab_flags
6080 #undef elf_backend_copy_special_section_fields
6082 #include "elf32-target.h"
6084 /* Restore defaults. */
6086 #define ELF_ARCH bfd_arch_i386
6087 #undef ELF_MACHINE_CODE
6088 #define ELF_MACHINE_CODE EM_386
6090 /* Native Client support. */
6092 #undef TARGET_LITTLE_SYM
6093 #define TARGET_LITTLE_SYM i386_elf32_nacl_vec
6094 #undef TARGET_LITTLE_NAME
6095 #define TARGET_LITTLE_NAME "elf32-i386-nacl"
6097 #define elf32_bed elf32_i386_nacl_bed
6099 #undef ELF_MAXPAGESIZE
6100 #define ELF_MAXPAGESIZE 0x10000
6102 /* Restore defaults. */
6104 #undef elf_backend_want_plt_sym
6105 #define elf_backend_want_plt_sym 0
6106 #undef elf_backend_post_process_headers
6107 #undef elf_backend_static_tls_alignment
6109 /* NaCl uses substantially different PLT entries for the same effects. */
6111 #undef elf_backend_plt_alignment
6112 #define elf_backend_plt_alignment 5
6113 #define NACL_PLT_ENTRY_SIZE 64
6114 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6116 static const bfd_byte elf_i386_nacl_plt0_entry[] =
6118 0xff, 0x35, /* pushl contents of address */
6119 0, 0, 0, 0, /* replaced with address of .got + 4. */
6120 0x8b, 0x0d, /* movl contents of address, %ecx */
6121 0, 0, 0, 0, /* replaced with address of .got + 8. */
6122 0x83, 0xe1, NACLMASK, /* andl $NACLMASK, %ecx */
6123 0xff, 0xe1 /* jmp *%ecx */
6126 static const bfd_byte elf_i386_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
6128 0x8b, 0x0d, /* movl contents of address, %ecx */
6129 0, 0, 0, 0, /* replaced with GOT slot address. */
6130 0x83, 0xe1, NACLMASK, /* andl $NACLMASK, %ecx */
6131 0xff, 0xe1, /* jmp *%ecx */
6133 /* Pad to the next 32-byte boundary with nop instructions. */
6135 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6136 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6138 /* Lazy GOT entries point here (32-byte aligned). */
6139 0x68, /* pushl immediate */
6140 0, 0, 0, 0, /* replaced with reloc offset. */
6141 0xe9, /* jmp relative */
6142 0, 0, 0, 0, /* replaced with offset to .plt. */
6144 /* Pad to the next 32-byte boundary with nop instructions. */
6145 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6146 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6150 static const bfd_byte
6151 elf_i386_nacl_pic_plt0_entry[sizeof (elf_i386_nacl_plt0_entry)] =
6153 0xff, 0x73, 0x04, /* pushl 4(%ebx) */
6154 0x8b, 0x4b, 0x08, /* mov 0x8(%ebx), %ecx */
6155 0x83, 0xe1, 0xe0, /* and $NACLMASK, %ecx */
6156 0xff, 0xe1, /* jmp *%ecx */
6158 /* This is expected to be the same size as elf_i386_nacl_plt0_entry,
6159 so pad to that size with nop instructions. */
6160 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
6163 static const bfd_byte elf_i386_nacl_pic_plt_entry[NACL_PLT_ENTRY_SIZE] =
6165 0x8b, 0x8b, /* movl offset(%ebx), %ecx */
6166 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
6167 0x83, 0xe1, 0xe0, /* andl $NACLMASK, %ecx */
6168 0xff, 0xe1, /* jmp *%ecx */
6170 /* Pad to the next 32-byte boundary with nop instructions. */
6172 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6173 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6175 /* Lazy GOT entries point here (32-byte aligned). */
6176 0x68, /* pushl immediate */
6177 0, 0, 0, 0, /* replaced with offset into relocation table. */
6178 0xe9, /* jmp relative */
6179 0, 0, 0, 0, /* replaced with offset to start of .plt. */
6181 /* Pad to the next 32-byte boundary with nop instructions. */
6182 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6183 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6187 static const bfd_byte elf_i386_nacl_eh_frame_plt[] =
6189 #if (PLT_CIE_LENGTH != 20 \
6190 || PLT_FDE_LENGTH != 36 \
6191 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6192 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6193 # error "Need elf_i386_backend_data parameters for eh_frame_plt offsets!"
6195 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
6196 0, 0, 0, 0, /* CIE ID */
6197 1, /* CIE version */
6198 'z', 'R', 0, /* Augmentation string */
6199 1, /* Code alignment factor */
6200 0x7c, /* Data alignment factor: -4 */
6201 8, /* Return address column */
6202 1, /* Augmentation size */
6203 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
6204 DW_CFA_def_cfa, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
6205 DW_CFA_offset + 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
6206 DW_CFA_nop, DW_CFA_nop,
6208 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
6209 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
6210 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
6211 0, 0, 0, 0, /* .plt size goes here */
6212 0, /* Augmentation size */
6213 DW_CFA_def_cfa_offset, 8, /* DW_CFA_def_cfa_offset: 8 */
6214 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6215 DW_CFA_def_cfa_offset, 12, /* DW_CFA_def_cfa_offset: 12 */
6216 DW_CFA_advance_loc + 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6217 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
6218 13, /* Block length */
6219 DW_OP_breg4, 4, /* DW_OP_breg4 (esp): 4 */
6220 DW_OP_breg8, 0, /* DW_OP_breg8 (eip): 0 */
6221 DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
6222 DW_OP_lit2, DW_OP_shl, DW_OP_plus,
6223 DW_CFA_nop, DW_CFA_nop
6226 static const struct elf_x86_lazy_plt_layout elf_i386_nacl_plt =
6228 elf_i386_nacl_plt0_entry, /* plt0_entry */
6229 sizeof (elf_i386_nacl_plt0_entry), /* plt0_entry_size */
6230 elf_i386_nacl_plt_entry, /* plt_entry */
6231 NACL_PLT_ENTRY_SIZE, /* plt_entry_size */
6232 2, /* plt0_got1_offset */
6233 8, /* plt0_got2_offset */
6234 0, /* plt0_got2_insn_end */
6235 2, /* plt_got_offset */
6236 33, /* plt_reloc_offset */
6237 38, /* plt_plt_offset */
6238 0, /* plt_got_insn_size */
6239 0, /* plt_plt_insn_end */
6240 32, /* plt_lazy_offset */
6241 elf_i386_nacl_pic_plt0_entry, /* pic_plt0_entry */
6242 elf_i386_nacl_pic_plt_entry, /* pic_plt_entry */
6243 elf_i386_nacl_eh_frame_plt, /* eh_frame_plt */
6244 sizeof (elf_i386_nacl_eh_frame_plt) /* eh_frame_plt_size */
6247 static const struct elf_i386_backend_data elf_i386_nacl_arch_bed =
6249 0x90, /* plt0_pad_byte: nop insn */
6254 elf32_i386_nacl_elf_object_p (bfd *abfd)
6256 /* Set the right machine number for a NaCl i386 ELF32 file. */
6257 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_i386_i386_nacl);
6261 #undef elf_backend_arch_data
6262 #define elf_backend_arch_data &elf_i386_nacl_arch_bed
6264 #undef elf_backend_object_p
6265 #define elf_backend_object_p elf32_i386_nacl_elf_object_p
6266 #undef elf_backend_modify_segment_map
6267 #define elf_backend_modify_segment_map nacl_modify_segment_map
6268 #undef elf_backend_modify_program_headers
6269 #define elf_backend_modify_program_headers nacl_modify_program_headers
6270 #undef elf_backend_final_write_processing
6271 #define elf_backend_final_write_processing nacl_final_write_processing
6273 #include "elf32-target.h"
6275 /* Restore defaults. */
6276 #undef elf_backend_object_p
6277 #undef elf_backend_modify_segment_map
6278 #undef elf_backend_modify_program_headers
6279 #undef elf_backend_final_write_processing
6281 /* VxWorks support. */
6283 #undef TARGET_LITTLE_SYM
6284 #define TARGET_LITTLE_SYM i386_elf32_vxworks_vec
6285 #undef TARGET_LITTLE_NAME
6286 #define TARGET_LITTLE_NAME "elf32-i386-vxworks"
6288 #undef ELF_MAXPAGESIZE
6289 #define ELF_MAXPAGESIZE 0x1000
6290 #undef elf_backend_plt_alignment
6291 #define elf_backend_plt_alignment 4
6293 static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed =
6295 0x90, /* plt0_pad_byte */
6299 #undef elf_backend_arch_data
6300 #define elf_backend_arch_data &elf_i386_vxworks_arch_bed
6302 #undef elf_backend_relocs_compatible
6303 #undef elf_backend_add_symbol_hook
6304 #define elf_backend_add_symbol_hook \
6305 elf_vxworks_add_symbol_hook
6306 #undef elf_backend_link_output_symbol_hook
6307 #define elf_backend_link_output_symbol_hook \
6308 elf_vxworks_link_output_symbol_hook
6309 #undef elf_backend_emit_relocs
6310 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
6311 #undef elf_backend_final_write_processing
6312 #define elf_backend_final_write_processing \
6313 elf_vxworks_final_write_processing
6314 #undef elf_backend_static_tls_alignment
6316 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
6318 #undef elf_backend_want_plt_sym
6319 #define elf_backend_want_plt_sym 1
6322 #define elf32_bed elf32_i386_vxworks_bed
6324 #include "elf32-target.h"