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. */
27 #include "elf-vxworks.h"
28 #include "bfd_stdint.h"
32 #include "opcode/i386.h"
34 /* 386 uses REL relocations instead of RELA. */
39 static reloc_howto_type elf_howto_table[]=
41 HOWTO(R_386_NONE, 0, 3, 0, FALSE, 0, complain_overflow_dont,
42 bfd_elf_generic_reloc, "R_386_NONE",
43 TRUE, 0x00000000, 0x00000000, FALSE),
44 HOWTO(R_386_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
45 bfd_elf_generic_reloc, "R_386_32",
46 TRUE, 0xffffffff, 0xffffffff, FALSE),
47 HOWTO(R_386_PC32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
48 bfd_elf_generic_reloc, "R_386_PC32",
49 TRUE, 0xffffffff, 0xffffffff, TRUE),
50 HOWTO(R_386_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
51 bfd_elf_generic_reloc, "R_386_GOT32",
52 TRUE, 0xffffffff, 0xffffffff, FALSE),
53 HOWTO(R_386_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
54 bfd_elf_generic_reloc, "R_386_PLT32",
55 TRUE, 0xffffffff, 0xffffffff, TRUE),
56 HOWTO(R_386_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
57 bfd_elf_generic_reloc, "R_386_COPY",
58 TRUE, 0xffffffff, 0xffffffff, FALSE),
59 HOWTO(R_386_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
60 bfd_elf_generic_reloc, "R_386_GLOB_DAT",
61 TRUE, 0xffffffff, 0xffffffff, FALSE),
62 HOWTO(R_386_JUMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
63 bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
64 TRUE, 0xffffffff, 0xffffffff, FALSE),
65 HOWTO(R_386_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
66 bfd_elf_generic_reloc, "R_386_RELATIVE",
67 TRUE, 0xffffffff, 0xffffffff, FALSE),
68 HOWTO(R_386_GOTOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
69 bfd_elf_generic_reloc, "R_386_GOTOFF",
70 TRUE, 0xffffffff, 0xffffffff, FALSE),
71 HOWTO(R_386_GOTPC, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
72 bfd_elf_generic_reloc, "R_386_GOTPC",
73 TRUE, 0xffffffff, 0xffffffff, TRUE),
75 /* We have a gap in the reloc numbers here.
76 R_386_standard counts the number up to this point, and
77 R_386_ext_offset is the value to subtract from a reloc type of
78 R_386_16 thru R_386_PC8 to form an index into this table. */
79 #define R_386_standard (R_386_GOTPC + 1)
80 #define R_386_ext_offset (R_386_TLS_TPOFF - R_386_standard)
82 /* These relocs are a GNU extension. */
83 HOWTO(R_386_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
84 bfd_elf_generic_reloc, "R_386_TLS_TPOFF",
85 TRUE, 0xffffffff, 0xffffffff, FALSE),
86 HOWTO(R_386_TLS_IE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
87 bfd_elf_generic_reloc, "R_386_TLS_IE",
88 TRUE, 0xffffffff, 0xffffffff, FALSE),
89 HOWTO(R_386_TLS_GOTIE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
90 bfd_elf_generic_reloc, "R_386_TLS_GOTIE",
91 TRUE, 0xffffffff, 0xffffffff, FALSE),
92 HOWTO(R_386_TLS_LE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
93 bfd_elf_generic_reloc, "R_386_TLS_LE",
94 TRUE, 0xffffffff, 0xffffffff, FALSE),
95 HOWTO(R_386_TLS_GD, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
96 bfd_elf_generic_reloc, "R_386_TLS_GD",
97 TRUE, 0xffffffff, 0xffffffff, FALSE),
98 HOWTO(R_386_TLS_LDM, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
99 bfd_elf_generic_reloc, "R_386_TLS_LDM",
100 TRUE, 0xffffffff, 0xffffffff, FALSE),
101 HOWTO(R_386_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
102 bfd_elf_generic_reloc, "R_386_16",
103 TRUE, 0xffff, 0xffff, FALSE),
104 HOWTO(R_386_PC16, 0, 1, 16, TRUE, 0, complain_overflow_bitfield,
105 bfd_elf_generic_reloc, "R_386_PC16",
106 TRUE, 0xffff, 0xffff, TRUE),
107 HOWTO(R_386_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
108 bfd_elf_generic_reloc, "R_386_8",
109 TRUE, 0xff, 0xff, FALSE),
110 HOWTO(R_386_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
111 bfd_elf_generic_reloc, "R_386_PC8",
112 TRUE, 0xff, 0xff, TRUE),
114 #define R_386_ext (R_386_PC8 + 1 - R_386_ext_offset)
115 #define R_386_tls_offset (R_386_TLS_LDO_32 - R_386_ext)
116 /* These are common with Solaris TLS implementation. */
117 HOWTO(R_386_TLS_LDO_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
118 bfd_elf_generic_reloc, "R_386_TLS_LDO_32",
119 TRUE, 0xffffffff, 0xffffffff, FALSE),
120 HOWTO(R_386_TLS_IE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
121 bfd_elf_generic_reloc, "R_386_TLS_IE_32",
122 TRUE, 0xffffffff, 0xffffffff, FALSE),
123 HOWTO(R_386_TLS_LE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
124 bfd_elf_generic_reloc, "R_386_TLS_LE_32",
125 TRUE, 0xffffffff, 0xffffffff, FALSE),
126 HOWTO(R_386_TLS_DTPMOD32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
127 bfd_elf_generic_reloc, "R_386_TLS_DTPMOD32",
128 TRUE, 0xffffffff, 0xffffffff, FALSE),
129 HOWTO(R_386_TLS_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
130 bfd_elf_generic_reloc, "R_386_TLS_DTPOFF32",
131 TRUE, 0xffffffff, 0xffffffff, FALSE),
132 HOWTO(R_386_TLS_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
133 bfd_elf_generic_reloc, "R_386_TLS_TPOFF32",
134 TRUE, 0xffffffff, 0xffffffff, FALSE),
135 HOWTO(R_386_SIZE32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
136 bfd_elf_generic_reloc, "R_386_SIZE32",
137 TRUE, 0xffffffff, 0xffffffff, FALSE),
138 HOWTO(R_386_TLS_GOTDESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
139 bfd_elf_generic_reloc, "R_386_TLS_GOTDESC",
140 TRUE, 0xffffffff, 0xffffffff, FALSE),
141 HOWTO(R_386_TLS_DESC_CALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
142 bfd_elf_generic_reloc, "R_386_TLS_DESC_CALL",
144 HOWTO(R_386_TLS_DESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
145 bfd_elf_generic_reloc, "R_386_TLS_DESC",
146 TRUE, 0xffffffff, 0xffffffff, FALSE),
147 HOWTO(R_386_IRELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
148 bfd_elf_generic_reloc, "R_386_IRELATIVE",
149 TRUE, 0xffffffff, 0xffffffff, FALSE),
150 HOWTO(R_386_GOT32X, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
151 bfd_elf_generic_reloc, "R_386_GOT32X",
152 TRUE, 0xffffffff, 0xffffffff, FALSE),
155 #define R_386_ext2 (R_386_GOT32X + 1 - R_386_tls_offset)
156 #define R_386_vt_offset (R_386_GNU_VTINHERIT - R_386_ext2)
158 /* GNU extension to record C++ vtable hierarchy. */
159 HOWTO (R_386_GNU_VTINHERIT, /* type */
161 2, /* size (0 = byte, 1 = short, 2 = long) */
163 FALSE, /* pc_relative */
165 complain_overflow_dont, /* complain_on_overflow */
166 NULL, /* special_function */
167 "R_386_GNU_VTINHERIT", /* name */
168 FALSE, /* partial_inplace */
171 FALSE), /* pcrel_offset */
173 /* GNU extension to record C++ vtable member usage. */
174 HOWTO (R_386_GNU_VTENTRY, /* type */
176 2, /* size (0 = byte, 1 = short, 2 = long) */
178 FALSE, /* pc_relative */
180 complain_overflow_dont, /* complain_on_overflow */
181 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
182 "R_386_GNU_VTENTRY", /* name */
183 FALSE, /* partial_inplace */
186 FALSE) /* pcrel_offset */
188 #define R_386_vt (R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
192 #ifdef DEBUG_GEN_RELOC
194 fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
199 static reloc_howto_type *
200 elf_i386_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
201 bfd_reloc_code_real_type code)
206 TRACE ("BFD_RELOC_NONE");
207 return &elf_howto_table[R_386_NONE];
210 TRACE ("BFD_RELOC_32");
211 return &elf_howto_table[R_386_32];
214 TRACE ("BFD_RELOC_CTOR");
215 return &elf_howto_table[R_386_32];
217 case BFD_RELOC_32_PCREL:
218 TRACE ("BFD_RELOC_PC32");
219 return &elf_howto_table[R_386_PC32];
221 case BFD_RELOC_386_GOT32:
222 TRACE ("BFD_RELOC_386_GOT32");
223 return &elf_howto_table[R_386_GOT32];
225 case BFD_RELOC_386_PLT32:
226 TRACE ("BFD_RELOC_386_PLT32");
227 return &elf_howto_table[R_386_PLT32];
229 case BFD_RELOC_386_COPY:
230 TRACE ("BFD_RELOC_386_COPY");
231 return &elf_howto_table[R_386_COPY];
233 case BFD_RELOC_386_GLOB_DAT:
234 TRACE ("BFD_RELOC_386_GLOB_DAT");
235 return &elf_howto_table[R_386_GLOB_DAT];
237 case BFD_RELOC_386_JUMP_SLOT:
238 TRACE ("BFD_RELOC_386_JUMP_SLOT");
239 return &elf_howto_table[R_386_JUMP_SLOT];
241 case BFD_RELOC_386_RELATIVE:
242 TRACE ("BFD_RELOC_386_RELATIVE");
243 return &elf_howto_table[R_386_RELATIVE];
245 case BFD_RELOC_386_GOTOFF:
246 TRACE ("BFD_RELOC_386_GOTOFF");
247 return &elf_howto_table[R_386_GOTOFF];
249 case BFD_RELOC_386_GOTPC:
250 TRACE ("BFD_RELOC_386_GOTPC");
251 return &elf_howto_table[R_386_GOTPC];
253 /* These relocs are a GNU extension. */
254 case BFD_RELOC_386_TLS_TPOFF:
255 TRACE ("BFD_RELOC_386_TLS_TPOFF");
256 return &elf_howto_table[R_386_TLS_TPOFF - R_386_ext_offset];
258 case BFD_RELOC_386_TLS_IE:
259 TRACE ("BFD_RELOC_386_TLS_IE");
260 return &elf_howto_table[R_386_TLS_IE - R_386_ext_offset];
262 case BFD_RELOC_386_TLS_GOTIE:
263 TRACE ("BFD_RELOC_386_TLS_GOTIE");
264 return &elf_howto_table[R_386_TLS_GOTIE - R_386_ext_offset];
266 case BFD_RELOC_386_TLS_LE:
267 TRACE ("BFD_RELOC_386_TLS_LE");
268 return &elf_howto_table[R_386_TLS_LE - R_386_ext_offset];
270 case BFD_RELOC_386_TLS_GD:
271 TRACE ("BFD_RELOC_386_TLS_GD");
272 return &elf_howto_table[R_386_TLS_GD - R_386_ext_offset];
274 case BFD_RELOC_386_TLS_LDM:
275 TRACE ("BFD_RELOC_386_TLS_LDM");
276 return &elf_howto_table[R_386_TLS_LDM - R_386_ext_offset];
279 TRACE ("BFD_RELOC_16");
280 return &elf_howto_table[R_386_16 - R_386_ext_offset];
282 case BFD_RELOC_16_PCREL:
283 TRACE ("BFD_RELOC_16_PCREL");
284 return &elf_howto_table[R_386_PC16 - R_386_ext_offset];
287 TRACE ("BFD_RELOC_8");
288 return &elf_howto_table[R_386_8 - R_386_ext_offset];
290 case BFD_RELOC_8_PCREL:
291 TRACE ("BFD_RELOC_8_PCREL");
292 return &elf_howto_table[R_386_PC8 - R_386_ext_offset];
294 /* Common with Sun TLS implementation. */
295 case BFD_RELOC_386_TLS_LDO_32:
296 TRACE ("BFD_RELOC_386_TLS_LDO_32");
297 return &elf_howto_table[R_386_TLS_LDO_32 - R_386_tls_offset];
299 case BFD_RELOC_386_TLS_IE_32:
300 TRACE ("BFD_RELOC_386_TLS_IE_32");
301 return &elf_howto_table[R_386_TLS_IE_32 - R_386_tls_offset];
303 case BFD_RELOC_386_TLS_LE_32:
304 TRACE ("BFD_RELOC_386_TLS_LE_32");
305 return &elf_howto_table[R_386_TLS_LE_32 - R_386_tls_offset];
307 case BFD_RELOC_386_TLS_DTPMOD32:
308 TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
309 return &elf_howto_table[R_386_TLS_DTPMOD32 - R_386_tls_offset];
311 case BFD_RELOC_386_TLS_DTPOFF32:
312 TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
313 return &elf_howto_table[R_386_TLS_DTPOFF32 - R_386_tls_offset];
315 case BFD_RELOC_386_TLS_TPOFF32:
316 TRACE ("BFD_RELOC_386_TLS_TPOFF32");
317 return &elf_howto_table[R_386_TLS_TPOFF32 - R_386_tls_offset];
319 case BFD_RELOC_SIZE32:
320 TRACE ("BFD_RELOC_SIZE32");
321 return &elf_howto_table[R_386_SIZE32 - R_386_tls_offset];
323 case BFD_RELOC_386_TLS_GOTDESC:
324 TRACE ("BFD_RELOC_386_TLS_GOTDESC");
325 return &elf_howto_table[R_386_TLS_GOTDESC - R_386_tls_offset];
327 case BFD_RELOC_386_TLS_DESC_CALL:
328 TRACE ("BFD_RELOC_386_TLS_DESC_CALL");
329 return &elf_howto_table[R_386_TLS_DESC_CALL - R_386_tls_offset];
331 case BFD_RELOC_386_TLS_DESC:
332 TRACE ("BFD_RELOC_386_TLS_DESC");
333 return &elf_howto_table[R_386_TLS_DESC - R_386_tls_offset];
335 case BFD_RELOC_386_IRELATIVE:
336 TRACE ("BFD_RELOC_386_IRELATIVE");
337 return &elf_howto_table[R_386_IRELATIVE - R_386_tls_offset];
339 case BFD_RELOC_386_GOT32X:
340 TRACE ("BFD_RELOC_386_GOT32X");
341 return &elf_howto_table[R_386_GOT32X - R_386_tls_offset];
343 case BFD_RELOC_VTABLE_INHERIT:
344 TRACE ("BFD_RELOC_VTABLE_INHERIT");
345 return &elf_howto_table[R_386_GNU_VTINHERIT - R_386_vt_offset];
347 case BFD_RELOC_VTABLE_ENTRY:
348 TRACE ("BFD_RELOC_VTABLE_ENTRY");
349 return &elf_howto_table[R_386_GNU_VTENTRY - R_386_vt_offset];
359 static reloc_howto_type *
360 elf_i386_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
365 for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
366 if (elf_howto_table[i].name != NULL
367 && strcasecmp (elf_howto_table[i].name, r_name) == 0)
368 return &elf_howto_table[i];
373 static reloc_howto_type *
374 elf_i386_rtype_to_howto (bfd *abfd, unsigned r_type)
378 if ((indx = r_type) >= R_386_standard
379 && ((indx = r_type - R_386_ext_offset) - R_386_standard
380 >= R_386_ext - R_386_standard)
381 && ((indx = r_type - R_386_tls_offset) - R_386_ext
382 >= R_386_ext2 - R_386_ext)
383 && ((indx = r_type - R_386_vt_offset) - R_386_ext2
384 >= R_386_vt - R_386_ext2))
386 /* xgettext:c-format */
387 _bfd_error_handler (_("%B: invalid relocation type %d"),
391 /* PR 17512: file: 0f67f69d. */
392 if (elf_howto_table [indx].type != r_type)
394 return &elf_howto_table[indx];
398 elf_i386_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
400 Elf_Internal_Rela *dst)
402 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
403 cache_ptr->howto = elf_i386_rtype_to_howto (abfd, r_type);
406 /* Return whether a symbol name implies a local label. The UnixWare
407 2.1 cc generates temporary symbols that start with .X, so we
408 recognize them here. FIXME: do other SVR4 compilers also use .X?.
409 If so, we should move the .X recognition into
410 _bfd_elf_is_local_label_name. */
413 elf_i386_is_local_label_name (bfd *abfd, const char *name)
415 if (name[0] == '.' && name[1] == 'X')
418 return _bfd_elf_is_local_label_name (abfd, name);
421 /* Support for core dump NOTE sections. */
424 elf_i386_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
429 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
431 int pr_version = bfd_get_32 (abfd, note->descdata);
437 elf_tdata (abfd)->core->signal = bfd_get_32 (abfd, note->descdata + 20);
440 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
444 size = bfd_get_32 (abfd, note->descdata + 8);
448 switch (note->descsz)
453 case 144: /* Linux/i386 */
455 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
458 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
468 /* Make a ".reg/999" section. */
469 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
470 size, note->descpos + offset);
474 elf_i386_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
476 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
478 int pr_version = bfd_get_32 (abfd, note->descdata);
483 elf_tdata (abfd)->core->program
484 = _bfd_elfcore_strndup (abfd, note->descdata + 8, 17);
485 elf_tdata (abfd)->core->command
486 = _bfd_elfcore_strndup (abfd, note->descdata + 25, 81);
490 switch (note->descsz)
495 case 124: /* Linux/i386 elf_prpsinfo. */
496 elf_tdata (abfd)->core->pid
497 = bfd_get_32 (abfd, note->descdata + 12);
498 elf_tdata (abfd)->core->program
499 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
500 elf_tdata (abfd)->core->command
501 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
505 /* Note that for some reason, a spurious space is tacked
506 onto the end of the args in some (at least one anyway)
507 implementations, so strip it off if it exists. */
509 char *command = elf_tdata (abfd)->core->command;
510 int n = strlen (command);
512 if (0 < n && command[n - 1] == ' ')
513 command[n - 1] = '\0';
519 /* Functions for the i386 ELF linker.
521 In order to gain some understanding of code in this file without
522 knowing all the intricate details of the linker, note the
525 Functions named elf_i386_* are called by external routines, other
526 functions are only called locally. elf_i386_* functions appear
527 in this file more or less in the order in which they are called
528 from external routines. eg. elf_i386_check_relocs is called
529 early in the link process, elf_i386_finish_dynamic_sections is
530 one of the last functions. */
533 /* The name of the dynamic interpreter. This is put in the .interp
536 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
538 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
539 copying dynamic variables from a shared lib into an app's dynbss
540 section, and instead use a dynamic relocation to point into the
542 #define ELIMINATE_COPY_RELOCS 1
544 /* The size in bytes of an entry in the procedure linkage table. */
546 #define PLT_ENTRY_SIZE 16
548 /* The first entry in an absolute procedure linkage table looks like
549 this. See the SVR4 ABI i386 supplement to see how this works.
550 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
552 static const bfd_byte elf_i386_plt0_entry[12] =
554 0xff, 0x35, /* pushl contents of address */
555 0, 0, 0, 0, /* replaced with address of .got + 4. */
556 0xff, 0x25, /* jmp indirect */
557 0, 0, 0, 0 /* replaced with address of .got + 8. */
560 /* Subsequent entries in an absolute procedure linkage table look like
563 static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
565 0xff, 0x25, /* jmp indirect */
566 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
567 0x68, /* pushl immediate */
568 0, 0, 0, 0, /* replaced with offset into relocation table. */
569 0xe9, /* jmp relative */
570 0, 0, 0, 0 /* replaced with offset to start of .plt. */
573 /* The first entry in a PIC procedure linkage table look like this.
574 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
576 static const bfd_byte elf_i386_pic_plt0_entry[12] =
578 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
579 0xff, 0xa3, 8, 0, 0, 0 /* jmp *8(%ebx) */
582 /* Subsequent entries in a PIC procedure linkage table look like this. */
584 static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
586 0xff, 0xa3, /* jmp *offset(%ebx) */
587 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
588 0x68, /* pushl immediate */
589 0, 0, 0, 0, /* replaced with offset into relocation table. */
590 0xe9, /* jmp relative */
591 0, 0, 0, 0 /* replaced with offset to start of .plt. */
594 /* Entries in the GOT procedure linkage table look like this. */
596 static const bfd_byte elf_i386_got_plt_entry[8] =
598 0xff, 0x25, /* jmp indirect */
599 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
600 0x66, 0x90 /* xchg %ax,%ax */
603 /* Entries in the PIC GOT procedure linkage table look like this. */
605 static const bfd_byte elf_i386_pic_got_plt_entry[8] =
607 0xff, 0xa3, /* jmp *offset(%ebx) */
608 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
609 0x66, 0x90 /* xchg %ax,%ax */
612 /* .eh_frame covering the .plt section. */
614 static const bfd_byte elf_i386_eh_frame_plt[] =
616 #define PLT_CIE_LENGTH 20
617 #define PLT_FDE_LENGTH 36
618 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
619 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
620 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
621 0, 0, 0, 0, /* CIE ID */
623 'z', 'R', 0, /* Augmentation string */
624 1, /* Code alignment factor */
625 0x7c, /* Data alignment factor */
626 8, /* Return address column */
627 1, /* Augmentation size */
628 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
629 DW_CFA_def_cfa, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
630 DW_CFA_offset + 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
631 DW_CFA_nop, DW_CFA_nop,
633 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
634 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
635 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
636 0, 0, 0, 0, /* .plt size goes here */
637 0, /* Augmentation size */
638 DW_CFA_def_cfa_offset, 8, /* DW_CFA_def_cfa_offset: 8 */
639 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
640 DW_CFA_def_cfa_offset, 12, /* DW_CFA_def_cfa_offset: 12 */
641 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
642 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
643 11, /* Block length */
644 DW_OP_breg4, 4, /* DW_OP_breg4 (esp): 4 */
645 DW_OP_breg8, 0, /* DW_OP_breg8 (eip): 0 */
646 DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
647 DW_OP_lit2, DW_OP_shl, DW_OP_plus,
648 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
651 struct elf_i386_plt_layout
653 /* The first entry in an absolute procedure linkage table looks like this. */
654 const bfd_byte *plt0_entry;
655 unsigned int plt0_entry_size;
657 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
658 unsigned int plt0_got1_offset;
659 unsigned int plt0_got2_offset;
661 /* Later entries in an absolute procedure linkage table look like this. */
662 const bfd_byte *plt_entry;
663 unsigned int plt_entry_size;
665 /* Offsets into plt_entry that are to be replaced with... */
666 unsigned int plt_got_offset; /* ... address of this symbol in .got. */
667 unsigned int plt_reloc_offset; /* ... offset into relocation table. */
668 unsigned int plt_plt_offset; /* ... offset to start of .plt. */
670 /* Offset into plt_entry where the initial value of the GOT entry points. */
671 unsigned int plt_lazy_offset;
673 /* The first entry in a PIC procedure linkage table looks like this. */
674 const bfd_byte *pic_plt0_entry;
676 /* Subsequent entries in a PIC procedure linkage table look like this. */
677 const bfd_byte *pic_plt_entry;
679 /* .eh_frame covering the .plt section. */
680 const bfd_byte *eh_frame_plt;
681 unsigned int eh_frame_plt_size;
684 #define GET_PLT_ENTRY_SIZE(abfd) \
685 get_elf_i386_backend_data (abfd)->plt->plt_entry_size
687 /* These are the standard parameters. */
688 static const struct elf_i386_plt_layout elf_i386_plt =
690 elf_i386_plt0_entry, /* plt0_entry */
691 sizeof (elf_i386_plt0_entry), /* plt0_entry_size */
692 2, /* plt0_got1_offset */
693 8, /* plt0_got2_offset */
694 elf_i386_plt_entry, /* plt_entry */
695 PLT_ENTRY_SIZE, /* plt_entry_size */
696 2, /* plt_got_offset */
697 7, /* plt_reloc_offset */
698 12, /* plt_plt_offset */
699 6, /* plt_lazy_offset */
700 elf_i386_pic_plt0_entry, /* pic_plt0_entry */
701 elf_i386_pic_plt_entry, /* pic_plt_entry */
702 elf_i386_eh_frame_plt, /* eh_frame_plt */
703 sizeof (elf_i386_eh_frame_plt), /* eh_frame_plt_size */
707 /* On VxWorks, the .rel.plt.unloaded section has absolute relocations
708 for the PLTResolve stub and then for each PLT entry. */
709 #define PLTRESOLVE_RELOCS_SHLIB 0
710 #define PLTRESOLVE_RELOCS 2
711 #define PLT_NON_JUMP_SLOT_RELOCS 2
713 /* Architecture-specific backend data for i386. */
715 struct elf_i386_backend_data
717 /* Parameters describing PLT generation. */
718 const struct elf_i386_plt_layout *plt;
720 /* Value used to fill the unused bytes of the first PLT entry. */
721 bfd_byte plt0_pad_byte;
723 /* True if the target system is VxWorks. */
727 #define get_elf_i386_backend_data(abfd) \
728 ((const struct elf_i386_backend_data *) \
729 get_elf_backend_data (abfd)->arch_data)
731 /* These are the standard parameters. */
732 static const struct elf_i386_backend_data elf_i386_arch_bed =
734 &elf_i386_plt, /* plt */
735 0, /* plt0_pad_byte */
739 #define elf_backend_arch_data &elf_i386_arch_bed
741 /* Is a undefined weak symbol which is resolved to 0. Reference to an
742 undefined weak symbol is resolved to 0 when building executable if
744 1. Has non-GOT/non-PLT relocations in text section. Or
745 2. Has no GOT/PLT relocation.
747 #define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, GOT_RELOC, EH) \
748 ((EH)->elf.root.type == bfd_link_hash_undefweak \
749 && bfd_link_executable (INFO) \
750 && (elf_i386_hash_table (INFO)->interp == NULL \
752 || (EH)->has_non_got_reloc \
753 || !(INFO)->dynamic_undefined_weak))
755 /* i386 ELF linker hash entry. */
757 struct elf_i386_link_hash_entry
759 struct elf_link_hash_entry elf;
761 /* Track dynamic relocs copied for this symbol. */
762 struct elf_dyn_relocs *dyn_relocs;
764 #define GOT_UNKNOWN 0
768 #define GOT_TLS_IE_POS 5
769 #define GOT_TLS_IE_NEG 6
770 #define GOT_TLS_IE_BOTH 7
771 #define GOT_TLS_GDESC 8
772 #define GOT_TLS_GD_BOTH_P(type) \
773 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
774 #define GOT_TLS_GD_P(type) \
775 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
776 #define GOT_TLS_GDESC_P(type) \
777 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
778 #define GOT_TLS_GD_ANY_P(type) \
779 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
780 unsigned char tls_type;
782 /* Symbol is referenced by R_386_GOTOFF relocation. */
783 unsigned int gotoff_ref : 1;
785 /* Symbol has GOT or PLT relocations. */
786 unsigned int has_got_reloc : 1;
788 /* Symbol has non-GOT/non-PLT relocations in text sections. */
789 unsigned int has_non_got_reloc : 1;
791 /* 0: symbol isn't ___tls_get_addr.
792 1: symbol is ___tls_get_addr.
793 2: symbol is unknown. */
794 unsigned int tls_get_addr : 2;
796 /* Reference count of C/C++ function pointer relocations in read-write
797 section which can be resolved at run-time. */
798 bfd_signed_vma func_pointer_refcount;
800 /* Information about the GOT PLT entry. Filled when there are both
801 GOT and PLT relocations against the same function. */
802 union gotplt_union plt_got;
804 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
805 starting at the end of the jump table. */
809 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
811 struct elf_i386_obj_tdata
813 struct elf_obj_tdata root;
815 /* tls_type for each local got entry. */
816 char *local_got_tls_type;
818 /* GOTPLT entries for TLS descriptors. */
819 bfd_vma *local_tlsdesc_gotent;
822 #define elf_i386_tdata(abfd) \
823 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
825 #define elf_i386_local_got_tls_type(abfd) \
826 (elf_i386_tdata (abfd)->local_got_tls_type)
828 #define elf_i386_local_tlsdesc_gotent(abfd) \
829 (elf_i386_tdata (abfd)->local_tlsdesc_gotent)
831 #define is_i386_elf(bfd) \
832 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
833 && elf_tdata (bfd) != NULL \
834 && elf_object_id (bfd) == I386_ELF_DATA)
837 elf_i386_mkobject (bfd *abfd)
839 return bfd_elf_allocate_object (abfd, sizeof (struct elf_i386_obj_tdata),
843 /* i386 ELF linker hash table. */
845 struct elf_i386_link_hash_table
847 struct elf_link_hash_table elf;
849 /* Short-cuts to get to dynamic linker sections. */
851 asection *plt_eh_frame;
856 bfd_signed_vma refcount;
860 /* The amount of space used by the reserved portion of the sgotplt
861 section, plus whatever space is used by the jump slots. */
862 bfd_vma sgotplt_jump_table_size;
864 /* Small local sym cache. */
865 struct sym_cache sym_cache;
867 /* _TLS_MODULE_BASE_ symbol. */
868 struct bfd_link_hash_entry *tls_module_base;
870 /* Used by local STT_GNU_IFUNC symbols. */
871 htab_t loc_hash_table;
872 void * loc_hash_memory;
874 /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */
877 /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */
878 bfd_vma next_tls_desc_index;
880 /* The index of the next unused R_386_JUMP_SLOT slot in .rel.plt. */
881 bfd_vma next_jump_slot_index;
883 /* The index of the next unused R_386_IRELATIVE slot in .rel.plt. */
884 bfd_vma next_irelative_index;
886 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
887 to read-only sections. */
888 bfd_boolean readonly_dynrelocs_against_ifunc;
891 /* Get the i386 ELF linker hash table from a link_info structure. */
893 #define elf_i386_hash_table(p) \
894 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
895 == I386_ELF_DATA ? ((struct elf_i386_link_hash_table *) ((p)->hash)) : NULL)
897 #define elf_i386_compute_jump_table_size(htab) \
898 ((htab)->elf.srelplt->reloc_count * 4)
900 /* Create an entry in an i386 ELF linker hash table. */
902 static struct bfd_hash_entry *
903 elf_i386_link_hash_newfunc (struct bfd_hash_entry *entry,
904 struct bfd_hash_table *table,
907 /* Allocate the structure if it has not already been allocated by a
911 entry = (struct bfd_hash_entry *)
912 bfd_hash_allocate (table, sizeof (struct elf_i386_link_hash_entry));
917 /* Call the allocation method of the superclass. */
918 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
921 struct elf_i386_link_hash_entry *eh;
923 eh = (struct elf_i386_link_hash_entry *) entry;
924 eh->dyn_relocs = NULL;
925 eh->tls_type = GOT_UNKNOWN;
927 eh->has_got_reloc = 0;
928 eh->has_non_got_reloc = 0;
929 eh->tls_get_addr = 2;
930 eh->func_pointer_refcount = 0;
931 eh->plt_got.offset = (bfd_vma) -1;
932 eh->tlsdesc_got = (bfd_vma) -1;
938 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
939 for local symbol so that we can handle local STT_GNU_IFUNC symbols
940 as global symbol. We reuse indx and dynstr_index for local symbol
941 hash since they aren't used by global symbols in this backend. */
944 elf_i386_local_htab_hash (const void *ptr)
946 struct elf_link_hash_entry *h
947 = (struct elf_link_hash_entry *) ptr;
948 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
951 /* Compare local hash entries. */
954 elf_i386_local_htab_eq (const void *ptr1, const void *ptr2)
956 struct elf_link_hash_entry *h1
957 = (struct elf_link_hash_entry *) ptr1;
958 struct elf_link_hash_entry *h2
959 = (struct elf_link_hash_entry *) ptr2;
961 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
964 /* Find and/or create a hash entry for local symbol. */
966 static struct elf_link_hash_entry *
967 elf_i386_get_local_sym_hash (struct elf_i386_link_hash_table *htab,
968 bfd *abfd, const Elf_Internal_Rela *rel,
971 struct elf_i386_link_hash_entry e, *ret;
972 asection *sec = abfd->sections;
973 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
974 ELF32_R_SYM (rel->r_info));
977 e.elf.indx = sec->id;
978 e.elf.dynstr_index = ELF32_R_SYM (rel->r_info);
979 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
980 create ? INSERT : NO_INSERT);
987 ret = (struct elf_i386_link_hash_entry *) *slot;
991 ret = (struct elf_i386_link_hash_entry *)
992 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
993 sizeof (struct elf_i386_link_hash_entry));
996 memset (ret, 0, sizeof (*ret));
997 ret->elf.indx = sec->id;
998 ret->elf.dynstr_index = ELF32_R_SYM (rel->r_info);
999 ret->elf.dynindx = -1;
1000 ret->func_pointer_refcount = 0;
1001 ret->plt_got.offset = (bfd_vma) -1;
1007 /* Destroy an i386 ELF linker hash table. */
1010 elf_i386_link_hash_table_free (bfd *obfd)
1012 struct elf_i386_link_hash_table *htab
1013 = (struct elf_i386_link_hash_table *) obfd->link.hash;
1015 if (htab->loc_hash_table)
1016 htab_delete (htab->loc_hash_table);
1017 if (htab->loc_hash_memory)
1018 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
1019 _bfd_elf_link_hash_table_free (obfd);
1022 /* Create an i386 ELF linker hash table. */
1024 static struct bfd_link_hash_table *
1025 elf_i386_link_hash_table_create (bfd *abfd)
1027 struct elf_i386_link_hash_table *ret;
1028 bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
1030 ret = (struct elf_i386_link_hash_table *) bfd_zmalloc (amt);
1034 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
1035 elf_i386_link_hash_newfunc,
1036 sizeof (struct elf_i386_link_hash_entry),
1043 ret->loc_hash_table = htab_try_create (1024,
1044 elf_i386_local_htab_hash,
1045 elf_i386_local_htab_eq,
1047 ret->loc_hash_memory = objalloc_create ();
1048 if (!ret->loc_hash_table || !ret->loc_hash_memory)
1050 elf_i386_link_hash_table_free (abfd);
1053 ret->elf.root.hash_table_free = elf_i386_link_hash_table_free;
1055 return &ret->elf.root;
1058 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
1059 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
1063 elf_i386_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
1065 struct elf_i386_link_hash_table *htab;
1067 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1070 htab = elf_i386_hash_table (info);
1074 /* Set the contents of the .interp section to the interpreter. */
1075 if (bfd_link_executable (info) && !info->nointerp)
1077 asection *s = bfd_get_linker_section (dynobj, ".interp");
1080 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1081 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1085 if (get_elf_i386_backend_data (dynobj)->is_vxworks
1086 && !elf_vxworks_create_dynamic_sections (dynobj, info,
1090 if (!info->no_ld_generated_unwind_info
1091 && htab->plt_eh_frame == NULL
1092 && htab->elf.splt != NULL)
1094 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
1095 | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1096 | SEC_LINKER_CREATED);
1098 = bfd_make_section_anyway_with_flags (dynobj, ".eh_frame", flags);
1099 if (htab->plt_eh_frame == NULL
1100 || !bfd_set_section_alignment (dynobj, htab->plt_eh_frame, 2))
1107 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1110 elf_i386_copy_indirect_symbol (struct bfd_link_info *info,
1111 struct elf_link_hash_entry *dir,
1112 struct elf_link_hash_entry *ind)
1114 struct elf_i386_link_hash_entry *edir, *eind;
1116 edir = (struct elf_i386_link_hash_entry *) dir;
1117 eind = (struct elf_i386_link_hash_entry *) ind;
1119 if (eind->dyn_relocs != NULL)
1121 if (edir->dyn_relocs != NULL)
1123 struct elf_dyn_relocs **pp;
1124 struct elf_dyn_relocs *p;
1126 /* Add reloc counts against the indirect sym to the direct sym
1127 list. Merge any entries against the same section. */
1128 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1130 struct elf_dyn_relocs *q;
1132 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1133 if (q->sec == p->sec)
1135 q->pc_count += p->pc_count;
1136 q->count += p->count;
1143 *pp = edir->dyn_relocs;
1146 edir->dyn_relocs = eind->dyn_relocs;
1147 eind->dyn_relocs = NULL;
1150 if (ind->root.type == bfd_link_hash_indirect
1151 && dir->got.refcount <= 0)
1153 edir->tls_type = eind->tls_type;
1154 eind->tls_type = GOT_UNKNOWN;
1157 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1158 generate a R_386_COPY reloc. */
1159 edir->gotoff_ref |= eind->gotoff_ref;
1161 edir->has_got_reloc |= eind->has_got_reloc;
1162 edir->has_non_got_reloc |= eind->has_non_got_reloc;
1164 if (ELIMINATE_COPY_RELOCS
1165 && ind->root.type != bfd_link_hash_indirect
1166 && dir->dynamic_adjusted)
1168 /* If called to transfer flags for a weakdef during processing
1169 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1170 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1171 if (dir->versioned != versioned_hidden)
1172 dir->ref_dynamic |= ind->ref_dynamic;
1173 dir->ref_regular |= ind->ref_regular;
1174 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1175 dir->needs_plt |= ind->needs_plt;
1176 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1180 if (eind->func_pointer_refcount > 0)
1182 edir->func_pointer_refcount += eind->func_pointer_refcount;
1183 eind->func_pointer_refcount = 0;
1186 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1190 /* Return TRUE if the TLS access code sequence support transition
1194 elf_i386_check_tls_transition (asection *sec,
1196 Elf_Internal_Shdr *symtab_hdr,
1197 struct elf_link_hash_entry **sym_hashes,
1198 unsigned int r_type,
1199 const Elf_Internal_Rela *rel,
1200 const Elf_Internal_Rela *relend)
1202 unsigned int val, type, reg;
1203 unsigned long r_symndx;
1204 struct elf_link_hash_entry *h;
1207 bfd_boolean indirect_call, tls_get_addr;
1209 offset = rel->r_offset;
1214 if (offset < 2 || (rel + 1) >= relend)
1217 indirect_call = FALSE;
1218 call = contents + offset + 4;
1221 if (r_type == R_386_TLS_GD)
1223 /* Check transition from GD access model. Only
1224 leal foo@tlsgd(,%ebx,1), %eax
1225 call ___tls_get_addr@PLT
1227 leal foo@tlsgd(%ebx) %eax
1228 call ___tls_get_addr@PLT
1231 leal foo@tlsgd(%reg), %eax
1232 call *___tls_get_addr@GOT(%reg)
1233 which may be converted to
1234 addr32 call ___tls_get_addr
1235 can transit to different access model. */
1236 if ((offset + 10) > sec->size
1237 || (type != 0x8d && type != 0x04))
1242 /* leal foo@tlsgd(,%ebx,1), %eax
1243 call ___tls_get_addr@PLT */
1247 if (*(call - 7) != 0x8d
1255 leal foo@tlsgd(%ebx), %eax
1256 call ___tls_get_addr@PLT
1259 leal foo@tlsgd(%reg), %eax
1260 call *___tls_get_addr@GOT(%reg)
1261 which may be converted to
1262 addr32 call ___tls_get_addr
1264 %eax can't be used as the GOT base register since it
1265 is used to pass parameter to ___tls_get_addr. */
1267 if ((val & 0xf8) != 0x80 || reg == 4 || reg == 0)
1270 indirect_call = call[0] == 0xff;
1271 if (!(reg == 3 && call[0] == 0xe8 && call[5] == 0x90)
1272 && !(call[0] == 0x67 && call[1] == 0xe8)
1274 && (call[1] & 0xf8) == 0x90
1275 && (call[1] & 0x7) == reg))
1281 /* Check transition from LD access model. Only
1282 leal foo@tlsldm(%ebx), %eax
1283 call ___tls_get_addr@PLT
1285 leal foo@tlsldm(%reg), %eax
1286 call *___tls_get_addr@GOT(%reg)
1287 which may be converted to
1288 addr32 call ___tls_get_addr
1289 can transit to different access model. */
1290 if (type != 0x8d || (offset + 9) > sec->size)
1293 /* %eax can't be used as the GOT base register since it is
1294 used to pass parameter to ___tls_get_addr. */
1296 if ((val & 0xf8) != 0x80 || reg == 4 || reg == 0)
1299 indirect_call = call[0] == 0xff;
1300 if (!(reg == 3 && call[0] == 0xe8)
1301 && !(call[0] == 0x67 && call[1] == 0xe8)
1303 && (call[1] & 0xf8) == 0x90
1304 && (call[1] & 0x7) == reg))
1308 r_symndx = ELF32_R_SYM (rel[1].r_info);
1309 if (r_symndx < symtab_hdr->sh_info)
1312 tls_get_addr = FALSE;
1313 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1314 if (h != NULL && h->root.root.string != NULL)
1316 struct elf_i386_link_hash_entry *eh
1317 = (struct elf_i386_link_hash_entry *) h;
1318 tls_get_addr = eh->tls_get_addr == 1;
1319 if (eh->tls_get_addr > 1)
1321 /* Use strncmp to check ___tls_get_addr since
1322 ___tls_get_addr may be versioned. */
1323 if (strncmp (h->root.root.string, "___tls_get_addr", 15)
1326 eh->tls_get_addr = 1;
1327 tls_get_addr = TRUE;
1330 eh->tls_get_addr = 0;
1336 else if (indirect_call)
1337 return (ELF32_R_TYPE (rel[1].r_info) == R_386_GOT32X);
1339 return (ELF32_R_TYPE (rel[1].r_info) == R_386_PC32
1340 || ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
1343 /* Check transition from IE access model:
1344 movl foo@indntpoff(%rip), %eax
1345 movl foo@indntpoff(%rip), %reg
1346 addl foo@indntpoff(%rip), %reg
1349 if (offset < 1 || (offset + 4) > sec->size)
1352 /* Check "movl foo@tpoff(%rip), %eax" first. */
1353 val = bfd_get_8 (abfd, contents + offset - 1);
1360 /* Check movl|addl foo@tpoff(%rip), %reg. */
1361 type = bfd_get_8 (abfd, contents + offset - 2);
1362 return ((type == 0x8b || type == 0x03)
1363 && (val & 0xc7) == 0x05);
1365 case R_386_TLS_GOTIE:
1366 case R_386_TLS_IE_32:
1367 /* Check transition from {IE_32,GOTIE} access model:
1368 subl foo@{tpoff,gontoff}(%reg1), %reg2
1369 movl foo@{tpoff,gontoff}(%reg1), %reg2
1370 addl foo@{tpoff,gontoff}(%reg1), %reg2
1373 if (offset < 2 || (offset + 4) > sec->size)
1376 val = bfd_get_8 (abfd, contents + offset - 1);
1377 if ((val & 0xc0) != 0x80 || (val & 7) == 4)
1380 type = bfd_get_8 (abfd, contents + offset - 2);
1381 return type == 0x8b || type == 0x2b || type == 0x03;
1383 case R_386_TLS_GOTDESC:
1384 /* Check transition from GDesc access model:
1385 leal x@tlsdesc(%ebx), %eax
1387 Make sure it's a leal adding ebx to a 32-bit offset
1388 into any register, although it's probably almost always
1391 if (offset < 2 || (offset + 4) > sec->size)
1394 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1397 val = bfd_get_8 (abfd, contents + offset - 1);
1398 return (val & 0xc7) == 0x83;
1400 case R_386_TLS_DESC_CALL:
1401 /* Check transition from GDesc access model:
1402 call *x@tlsdesc(%eax)
1404 if (offset + 2 <= sec->size)
1406 /* Make sure that it's a call *x@tlsdesc(%eax). */
1407 call = contents + offset;
1408 return call[0] == 0xff && call[1] == 0x10;
1418 /* Return TRUE if the TLS access transition is OK or no transition
1419 will be performed. Update R_TYPE if there is a transition. */
1422 elf_i386_tls_transition (struct bfd_link_info *info, bfd *abfd,
1423 asection *sec, bfd_byte *contents,
1424 Elf_Internal_Shdr *symtab_hdr,
1425 struct elf_link_hash_entry **sym_hashes,
1426 unsigned int *r_type, int tls_type,
1427 const Elf_Internal_Rela *rel,
1428 const Elf_Internal_Rela *relend,
1429 struct elf_link_hash_entry *h,
1430 unsigned long r_symndx,
1431 bfd_boolean from_relocate_section)
1433 unsigned int from_type = *r_type;
1434 unsigned int to_type = from_type;
1435 bfd_boolean check = TRUE;
1437 /* Skip TLS transition for functions. */
1439 && (h->type == STT_FUNC
1440 || h->type == STT_GNU_IFUNC))
1446 case R_386_TLS_GOTDESC:
1447 case R_386_TLS_DESC_CALL:
1448 case R_386_TLS_IE_32:
1450 case R_386_TLS_GOTIE:
1451 if (bfd_link_executable (info))
1454 to_type = R_386_TLS_LE_32;
1455 else if (from_type != R_386_TLS_IE
1456 && from_type != R_386_TLS_GOTIE)
1457 to_type = R_386_TLS_IE_32;
1460 /* When we are called from elf_i386_relocate_section, there may
1461 be additional transitions based on TLS_TYPE. */
1462 if (from_relocate_section)
1464 unsigned int new_to_type = to_type;
1466 if (bfd_link_executable (info)
1469 && (tls_type & GOT_TLS_IE))
1470 new_to_type = R_386_TLS_LE_32;
1472 if (to_type == R_386_TLS_GD
1473 || to_type == R_386_TLS_GOTDESC
1474 || to_type == R_386_TLS_DESC_CALL)
1476 if (tls_type == GOT_TLS_IE_POS)
1477 new_to_type = R_386_TLS_GOTIE;
1478 else if (tls_type & GOT_TLS_IE)
1479 new_to_type = R_386_TLS_IE_32;
1482 /* We checked the transition before when we were called from
1483 elf_i386_check_relocs. We only want to check the new
1484 transition which hasn't been checked before. */
1485 check = new_to_type != to_type && from_type == to_type;
1486 to_type = new_to_type;
1492 if (bfd_link_executable (info))
1493 to_type = R_386_TLS_LE_32;
1500 /* Return TRUE if there is no transition. */
1501 if (from_type == to_type)
1504 /* Check if the transition can be performed. */
1506 && ! elf_i386_check_tls_transition (sec, contents,
1507 symtab_hdr, sym_hashes,
1508 from_type, rel, relend))
1510 reloc_howto_type *from, *to;
1513 from = elf_i386_rtype_to_howto (abfd, from_type);
1514 to = elf_i386_rtype_to_howto (abfd, to_type);
1517 name = h->root.root.string;
1520 struct elf_i386_link_hash_table *htab;
1522 htab = elf_i386_hash_table (info);
1527 Elf_Internal_Sym *isym;
1529 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1531 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1536 /* xgettext:c-format */
1537 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1538 "in section `%A' failed"),
1539 abfd, sec, from->name, to->name, name,
1540 (unsigned long) rel->r_offset);
1541 bfd_set_error (bfd_error_bad_value);
1549 /* With the local symbol, foo, we convert
1550 mov foo@GOT[(%reg1)], %reg2
1552 lea foo[@GOTOFF(%reg1)], %reg2
1554 call/jmp *foo@GOT[(%reg)]
1556 nop call foo/jmp foo nop
1557 When PIC is false, convert
1558 test %reg1, foo@GOT[(%reg2)]
1562 binop foo@GOT[(%reg1)], %reg2
1565 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1570 elf_i386_convert_load_reloc (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
1572 Elf_Internal_Rela *irel,
1573 struct elf_link_hash_entry *h,
1574 bfd_boolean *converted,
1575 struct bfd_link_info *link_info)
1577 struct elf_i386_link_hash_table *htab;
1578 unsigned int opcode;
1580 bfd_boolean baseless;
1581 Elf_Internal_Sym *isym;
1582 unsigned int addend;
1586 bfd_boolean to_reloc_32;
1587 unsigned int r_type;
1588 unsigned int r_symndx;
1589 bfd_vma roff = irel->r_offset;
1594 /* Addend for R_386_GOT32X relocations must be 0. */
1595 addend = bfd_get_32 (abfd, contents + roff);
1599 htab = elf_i386_hash_table (link_info);
1600 is_pic = bfd_link_pic (link_info);
1602 r_type = ELF32_R_TYPE (irel->r_info);
1603 r_symndx = ELF32_R_SYM (irel->r_info);
1605 modrm = bfd_get_8 (abfd, contents + roff - 1);
1606 baseless = (modrm & 0xc7) == 0x5;
1608 if (baseless && is_pic)
1610 /* For PIC, disallow R_386_GOT32X without a base register
1611 since we don't know what the GOT base is. */
1616 isym = bfd_sym_from_r_symndx (&htab->sym_cache, abfd,
1618 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1621 name = h->root.root.string;
1624 /* xgettext:c-format */
1625 (_("%B: direct GOT relocation R_386_GOT32X against `%s' without base register can not be used when making a shared object"),
1630 opcode = bfd_get_8 (abfd, contents + roff - 2);
1632 /* Convert to R_386_32 if PIC is false or there is no base
1634 to_reloc_32 = !is_pic || baseless;
1636 /* Try to convert R_386_GOT32X. Get the symbol referred to by the
1640 if (opcode == 0x0ff)
1641 /* Convert "call/jmp *foo@GOT[(%reg)]". */
1642 goto convert_branch;
1644 /* Convert "mov foo@GOT[(%reg1)], %reg2",
1645 "test %reg1, foo@GOT(%reg2)" and
1646 "binop foo@GOT[(%reg1)], %reg2". */
1650 /* Undefined weak symbol is only bound locally in executable
1651 and its reference is resolved as 0. */
1652 if (UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info, TRUE,
1653 elf_i386_hash_entry (h)))
1657 /* No direct branch to 0 for PIC. */
1661 goto convert_branch;
1665 /* We can convert load of address 0 to R_386_32. */
1673 /* We have "call/jmp *foo@GOT[(%reg)]". */
1674 if ((h->root.type == bfd_link_hash_defined
1675 || h->root.type == bfd_link_hash_defweak)
1676 && SYMBOL_REFERENCES_LOCAL (link_info, h))
1678 /* The function is locally defined. */
1680 /* Convert R_386_GOT32X to R_386_PC32. */
1681 if (modrm == 0x15 || (modrm & 0xf8) == 0x90)
1683 struct elf_i386_link_hash_entry *eh
1684 = (struct elf_i386_link_hash_entry *) h;
1686 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
1689 /* To support TLS optimization, always use addr32 prefix
1690 for "call *___tls_get_addr@GOT(%reg)". */
1691 if (eh && eh->tls_get_addr == 1)
1694 nop_offset = irel->r_offset - 2;
1698 nop = link_info->call_nop_byte;
1699 if (link_info->call_nop_as_suffix)
1701 nop_offset = roff + 3;
1702 irel->r_offset -= 1;
1705 nop_offset = roff - 2;
1710 /* Convert to "jmp foo nop". */
1713 nop_offset = roff + 3;
1714 irel->r_offset -= 1;
1717 bfd_put_8 (abfd, nop, contents + nop_offset);
1718 bfd_put_8 (abfd, modrm, contents + irel->r_offset - 1);
1719 /* When converting to PC-relative relocation, we
1720 need to adjust addend by -4. */
1721 bfd_put_32 (abfd, -4, contents + irel->r_offset);
1722 irel->r_info = ELF32_R_INFO (r_symndx, R_386_PC32);
1729 /* We have "mov foo@GOT[(%re1g)], %reg2",
1730 "test %reg1, foo@GOT(%reg2)" and
1731 "binop foo@GOT[(%reg1)], %reg2".
1733 Avoid optimizing _DYNAMIC since ld.so may use its
1734 link-time address. */
1735 if (h == htab->elf.hdynamic)
1738 /* def_regular is set by an assignment in a linker script in
1739 bfd_elf_record_link_assignment. */
1741 || h->root.type == bfd_link_hash_defined
1742 || h->root.type == bfd_link_hash_defweak)
1743 && SYMBOL_REFERENCES_LOCAL (link_info, h))
1750 /* Convert "mov foo@GOT[(%reg1)], %reg2" to
1751 "mov $foo, %reg2" with R_386_32. */
1753 modrm = 0xc0 | (modrm & 0x38) >> 3;
1754 bfd_put_8 (abfd, modrm, contents + roff - 1);
1759 /* Convert "mov foo@GOT(%reg1), %reg2" to
1760 "lea foo@GOTOFF(%reg1), %reg2". */
1761 r_type = R_386_GOTOFF;
1767 /* Only R_386_32 is supported. */
1773 /* Convert "test %reg1, foo@GOT(%reg2)" to
1774 "test $foo, %reg1". */
1775 modrm = 0xc0 | (modrm & 0x38) >> 3;
1780 /* Convert "binop foo@GOT(%reg1), %reg2" to
1781 "binop $foo, %reg2". */
1783 | (modrm & 0x38) >> 3
1787 bfd_put_8 (abfd, modrm, contents + roff - 1);
1791 bfd_put_8 (abfd, opcode, contents + roff - 2);
1792 irel->r_info = ELF32_R_INFO (r_symndx, r_type);
1801 /* Rename some of the generic section flags to better document how they
1803 #define need_convert_load sec_flg0
1804 #define check_relocs_failed sec_flg1
1806 /* Look through the relocs for a section during the first phase, and
1807 calculate needed space in the global offset table, procedure linkage
1808 table, and dynamic reloc sections. */
1811 elf_i386_check_relocs (bfd *abfd,
1812 struct bfd_link_info *info,
1814 const Elf_Internal_Rela *relocs)
1816 struct elf_i386_link_hash_table *htab;
1817 Elf_Internal_Shdr *symtab_hdr;
1818 struct elf_link_hash_entry **sym_hashes;
1819 const Elf_Internal_Rela *rel;
1820 const Elf_Internal_Rela *rel_end;
1823 bfd_boolean use_plt_got;
1825 if (bfd_link_relocatable (info))
1828 /* Don't do anything special with non-loaded, non-alloced sections.
1829 In particular, any relocs in such sections should not affect GOT
1830 and PLT reference counting (ie. we don't allow them to create GOT
1831 or PLT entries), there's no possibility or desire to optimize TLS
1832 relocs, and there's not much point in propagating relocs to shared
1833 libs that the dynamic linker won't relocate. */
1834 if ((sec->flags & SEC_ALLOC) == 0)
1837 BFD_ASSERT (is_i386_elf (abfd));
1839 htab = elf_i386_hash_table (info);
1842 sec->check_relocs_failed = 1;
1846 /* Get the section contents. */
1847 if (elf_section_data (sec)->this_hdr.contents != NULL)
1848 contents = elf_section_data (sec)->this_hdr.contents;
1849 else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1851 sec->check_relocs_failed = 1;
1855 use_plt_got = (!get_elf_i386_backend_data (abfd)->is_vxworks
1856 && (get_elf_i386_backend_data (abfd)
1857 == &elf_i386_arch_bed));
1859 symtab_hdr = &elf_symtab_hdr (abfd);
1860 sym_hashes = elf_sym_hashes (abfd);
1864 rel_end = relocs + sec->reloc_count;
1865 for (rel = relocs; rel < rel_end; rel++)
1867 unsigned int r_type;
1868 unsigned long r_symndx;
1869 struct elf_link_hash_entry *h;
1870 struct elf_i386_link_hash_entry *eh;
1871 Elf_Internal_Sym *isym;
1873 bfd_boolean size_reloc;
1875 r_symndx = ELF32_R_SYM (rel->r_info);
1876 r_type = ELF32_R_TYPE (rel->r_info);
1878 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1880 /* xgettext:c-format */
1881 _bfd_error_handler (_("%B: bad symbol index: %d"),
1886 if (r_symndx < symtab_hdr->sh_info)
1888 /* A local symbol. */
1889 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1894 /* Check relocation against local STT_GNU_IFUNC symbol. */
1895 if (ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1897 h = elf_i386_get_local_sym_hash (htab, abfd, rel, TRUE);
1901 /* Fake a STT_GNU_IFUNC symbol. */
1902 h->type = STT_GNU_IFUNC;
1905 h->forced_local = 1;
1906 h->root.type = bfd_link_hash_defined;
1914 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1915 while (h->root.type == bfd_link_hash_indirect
1916 || h->root.type == bfd_link_hash_warning)
1917 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1920 eh = (struct elf_i386_link_hash_entry *) h;
1936 if (htab->elf.dynobj == NULL)
1937 htab->elf.dynobj = abfd;
1938 /* Create the ifunc sections for static executables. */
1939 if (h->type == STT_GNU_IFUNC
1940 && !_bfd_elf_create_ifunc_sections (htab->elf.dynobj,
1946 /* It is referenced by a non-shared object. */
1948 h->root.non_ir_ref = 1;
1950 if (h->type == STT_GNU_IFUNC)
1951 elf_tdata (info->output_bfd)->has_gnu_symbols
1952 |= elf_gnu_symbol_ifunc;
1955 if (! elf_i386_tls_transition (info, abfd, sec, contents,
1956 symtab_hdr, sym_hashes,
1957 &r_type, GOT_UNKNOWN,
1958 rel, rel_end, h, r_symndx, FALSE))
1964 htab->tls_ldm_got.refcount += 1;
1968 /* This symbol requires a procedure linkage table entry. We
1969 actually build the entry in adjust_dynamic_symbol,
1970 because this might be a case of linking PIC code which is
1971 never referenced by a dynamic object, in which case we
1972 don't need to generate a procedure linkage table entry
1975 /* If this is a local symbol, we resolve it directly without
1976 creating a procedure linkage table entry. */
1980 eh->has_got_reloc = 1;
1982 h->plt.refcount += 1;
1989 case R_386_TLS_IE_32:
1991 case R_386_TLS_GOTIE:
1992 if (!bfd_link_executable (info))
1993 info->flags |= DF_STATIC_TLS;
1999 case R_386_TLS_GOTDESC:
2000 case R_386_TLS_DESC_CALL:
2001 /* This symbol requires a global offset table entry. */
2003 int tls_type, old_tls_type;
2010 tls_type = GOT_NORMAL;
2012 case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
2013 case R_386_TLS_GOTDESC:
2014 case R_386_TLS_DESC_CALL:
2015 tls_type = GOT_TLS_GDESC; break;
2016 case R_386_TLS_IE_32:
2017 if (ELF32_R_TYPE (rel->r_info) == r_type)
2018 tls_type = GOT_TLS_IE_NEG;
2020 /* If this is a GD->IE transition, we may use either of
2021 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
2022 tls_type = GOT_TLS_IE;
2025 case R_386_TLS_GOTIE:
2026 tls_type = GOT_TLS_IE_POS; break;
2031 h->got.refcount += 1;
2032 old_tls_type = elf_i386_hash_entry(h)->tls_type;
2036 bfd_signed_vma *local_got_refcounts;
2038 /* This is a global offset table entry for a local symbol. */
2039 local_got_refcounts = elf_local_got_refcounts (abfd);
2040 if (local_got_refcounts == NULL)
2044 size = symtab_hdr->sh_info;
2045 size *= (sizeof (bfd_signed_vma)
2046 + sizeof (bfd_vma) + sizeof(char));
2047 local_got_refcounts = (bfd_signed_vma *)
2048 bfd_zalloc (abfd, size);
2049 if (local_got_refcounts == NULL)
2051 elf_local_got_refcounts (abfd) = local_got_refcounts;
2052 elf_i386_local_tlsdesc_gotent (abfd)
2053 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
2054 elf_i386_local_got_tls_type (abfd)
2055 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
2057 local_got_refcounts[r_symndx] += 1;
2058 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
2061 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
2062 tls_type |= old_tls_type;
2063 /* If a TLS symbol is accessed using IE at least once,
2064 there is no point to use dynamic model for it. */
2065 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
2066 && (! GOT_TLS_GD_ANY_P (old_tls_type)
2067 || (tls_type & GOT_TLS_IE) == 0))
2069 if ((old_tls_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (tls_type))
2070 tls_type = old_tls_type;
2071 else if (GOT_TLS_GD_ANY_P (old_tls_type)
2072 && GOT_TLS_GD_ANY_P (tls_type))
2073 tls_type |= old_tls_type;
2077 name = h->root.root.string;
2079 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
2082 /* xgettext:c-format */
2083 (_("%B: `%s' accessed both as normal and "
2084 "thread local symbol"),
2086 bfd_set_error (bfd_error_bad_value);
2091 if (old_tls_type != tls_type)
2094 elf_i386_hash_entry (h)->tls_type = tls_type;
2096 elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
2104 if (htab->elf.sgot == NULL)
2106 if (htab->elf.dynobj == NULL)
2107 htab->elf.dynobj = abfd;
2108 if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
2111 if (r_type != R_386_TLS_IE)
2114 eh->has_got_reloc = 1;
2119 case R_386_TLS_LE_32:
2122 eh->has_got_reloc = 1;
2123 if (bfd_link_executable (info))
2125 info->flags |= DF_STATIC_TLS;
2130 if (eh != NULL && (sec->flags & SEC_CODE) != 0)
2131 eh->has_non_got_reloc = 1;
2133 /* We are called after all symbols have been resolved. Only
2134 relocation against STT_GNU_IFUNC symbol must go through
2137 && (bfd_link_executable (info)
2138 || h->type == STT_GNU_IFUNC))
2140 /* If this reloc is in a read-only section, we might
2141 need a copy reloc. We can't check reliably at this
2142 stage whether the section is read-only, as input
2143 sections have not yet been mapped to output sections.
2144 Tentatively set the flag for now, and correct in
2145 adjust_dynamic_symbol. */
2148 /* We may need a .plt entry if the symbol is a function
2149 defined in a shared lib or is a STT_GNU_IFUNC function
2150 referenced from the code or read-only section. */
2152 || (sec->flags & (SEC_CODE | SEC_READONLY)) != 0)
2153 h->plt.refcount += 1;
2155 if (r_type == R_386_PC32)
2157 /* Since something like ".long foo - ." may be used
2158 as pointer, make sure that PLT is used if foo is
2159 a function defined in a shared library. */
2160 if ((sec->flags & SEC_CODE) == 0)
2161 h->pointer_equality_needed = 1;
2162 else if (h->type == STT_GNU_IFUNC
2163 && bfd_link_pic (info))
2166 name = h->root.root.string;
2168 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
2171 /* xgettext:c-format */
2172 (_("%B: unsupported non-PIC call to IFUNC `%s'"),
2174 bfd_set_error (bfd_error_bad_value);
2180 h->pointer_equality_needed = 1;
2181 /* R_386_32 can be resolved at run-time. */
2182 if (r_type == R_386_32
2183 && (sec->flags & SEC_READONLY) == 0)
2184 eh->func_pointer_refcount += 1;
2190 /* If we are creating a shared library, and this is a reloc
2191 against a global symbol, or a non PC relative reloc
2192 against a local symbol, then we need to copy the reloc
2193 into the shared library. However, if we are linking with
2194 -Bsymbolic, we do not need to copy a reloc against a
2195 global symbol which is defined in an object we are
2196 including in the link (i.e., DEF_REGULAR is set). At
2197 this point we have not seen all the input files, so it is
2198 possible that DEF_REGULAR is not set now but will be set
2199 later (it is never cleared). In case of a weak definition,
2200 DEF_REGULAR may be cleared later by a strong definition in
2201 a shared library. We account for that possibility below by
2202 storing information in the relocs_copied field of the hash
2203 table entry. A similar situation occurs when creating
2204 shared libraries and symbol visibility changes render the
2207 If on the other hand, we are creating an executable, we
2208 may need to keep relocations for symbols satisfied by a
2209 dynamic library if we manage to avoid copy relocs for the
2212 Generate dynamic pointer relocation against STT_GNU_IFUNC
2213 symbol in the non-code section. */
2214 if ((bfd_link_pic (info)
2215 && (r_type != R_386_PC32
2217 && (! (bfd_link_pie (info)
2218 || SYMBOLIC_BIND (info, h))
2219 || h->root.type == bfd_link_hash_defweak
2220 || !h->def_regular))))
2222 && h->type == STT_GNU_IFUNC
2223 && r_type == R_386_32
2224 && (sec->flags & SEC_CODE) == 0)
2225 || (ELIMINATE_COPY_RELOCS
2226 && !bfd_link_pic (info)
2228 && (h->root.type == bfd_link_hash_defweak
2229 || !h->def_regular)))
2231 struct elf_dyn_relocs *p;
2232 struct elf_dyn_relocs **head;
2234 /* We must copy these reloc types into the output file.
2235 Create a reloc section in dynobj and make room for
2239 if (htab->elf.dynobj == NULL)
2240 htab->elf.dynobj = abfd;
2242 sreloc = _bfd_elf_make_dynamic_reloc_section
2243 (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ FALSE);
2249 /* If this is a global symbol, we count the number of
2250 relocations we need for this symbol. */
2253 head = &eh->dyn_relocs;
2257 /* Track dynamic relocs needed for local syms too.
2258 We really need local syms available to do this
2263 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2268 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
2272 vpp = &elf_section_data (s)->local_dynrel;
2273 head = (struct elf_dyn_relocs **)vpp;
2277 if (p == NULL || p->sec != sec)
2279 bfd_size_type amt = sizeof *p;
2280 p = (struct elf_dyn_relocs *) bfd_alloc (htab->elf.dynobj,
2292 /* Count size relocation as PC-relative relocation. */
2293 if (r_type == R_386_PC32 || size_reloc)
2298 /* This relocation describes the C++ object vtable hierarchy.
2299 Reconstruct it for later use during GC. */
2300 case R_386_GNU_VTINHERIT:
2301 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2305 /* This relocation describes which C++ vtable entries are actually
2306 used. Record for later use during GC. */
2307 case R_386_GNU_VTENTRY:
2308 BFD_ASSERT (h != NULL);
2310 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
2320 && h->plt.refcount > 0
2321 && (((info->flags & DF_BIND_NOW) && !h->pointer_equality_needed)
2322 || h->got.refcount > 0)
2323 && htab->plt_got == NULL)
2325 /* Create the GOT procedure linkage table. */
2326 unsigned int plt_got_align;
2327 const struct elf_backend_data *bed;
2329 bed = get_elf_backend_data (info->output_bfd);
2330 BFD_ASSERT (sizeof (elf_i386_got_plt_entry) == 8
2331 && (sizeof (elf_i386_got_plt_entry)
2332 == sizeof (elf_i386_pic_got_plt_entry)));
2335 if (htab->elf.dynobj == NULL)
2336 htab->elf.dynobj = abfd;
2338 = bfd_make_section_anyway_with_flags (htab->elf.dynobj,
2340 (bed->dynamic_sec_flags
2345 if (htab->plt_got == NULL
2346 || !bfd_set_section_alignment (htab->elf.dynobj,
2352 if (r_type == R_386_GOT32X
2353 && (h == NULL || h->type != STT_GNU_IFUNC))
2354 sec->need_convert_load = 1;
2357 if (elf_section_data (sec)->this_hdr.contents != contents)
2359 if (!info->keep_memory)
2363 /* Cache the section contents for elf_link_input_bfd. */
2364 elf_section_data (sec)->this_hdr.contents = contents;
2371 if (elf_section_data (sec)->this_hdr.contents != contents)
2373 sec->check_relocs_failed = 1;
2377 /* Return the section that should be marked against GC for a given
2381 elf_i386_gc_mark_hook (asection *sec,
2382 struct bfd_link_info *info,
2383 Elf_Internal_Rela *rel,
2384 struct elf_link_hash_entry *h,
2385 Elf_Internal_Sym *sym)
2388 switch (ELF32_R_TYPE (rel->r_info))
2390 case R_386_GNU_VTINHERIT:
2391 case R_386_GNU_VTENTRY:
2395 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2398 /* Remove undefined weak symbol from the dynamic symbol table if it
2399 is resolved to 0. */
2402 elf_i386_fixup_symbol (struct bfd_link_info *info,
2403 struct elf_link_hash_entry *h)
2405 if (h->dynindx != -1
2406 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
2407 elf_i386_hash_entry (h)->has_got_reloc,
2408 elf_i386_hash_entry (h)))
2411 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
2417 /* Adjust a symbol defined by a dynamic object and referenced by a
2418 regular object. The current definition is in some section of the
2419 dynamic object, but we're not including those sections. We have to
2420 change the definition to something the rest of the link can
2424 elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info,
2425 struct elf_link_hash_entry *h)
2427 struct elf_i386_link_hash_table *htab;
2429 struct elf_i386_link_hash_entry *eh;
2430 struct elf_dyn_relocs *p;
2432 /* STT_GNU_IFUNC symbol must go through PLT. */
2433 if (h->type == STT_GNU_IFUNC)
2435 /* All local STT_GNU_IFUNC references must be treate as local
2436 calls via local PLT. */
2438 && SYMBOL_CALLS_LOCAL (info, h))
2440 bfd_size_type pc_count = 0, count = 0;
2441 struct elf_dyn_relocs **pp;
2443 eh = (struct elf_i386_link_hash_entry *) h;
2444 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2446 pc_count += p->pc_count;
2447 p->count -= p->pc_count;
2456 if (pc_count || count)
2461 /* Increment PLT reference count only for PC-relative
2464 if (h->plt.refcount <= 0)
2465 h->plt.refcount = 1;
2467 h->plt.refcount += 1;
2472 if (h->plt.refcount <= 0)
2474 h->plt.offset = (bfd_vma) -1;
2480 /* If this is a function, put it in the procedure linkage table. We
2481 will fill in the contents of the procedure linkage table later,
2482 when we know the address of the .got section. */
2483 if (h->type == STT_FUNC
2486 if (h->plt.refcount <= 0
2487 || SYMBOL_CALLS_LOCAL (info, h)
2488 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2489 && h->root.type == bfd_link_hash_undefweak))
2491 /* This case can occur if we saw a PLT32 reloc in an input
2492 file, but the symbol was never referred to by a dynamic
2493 object, or if all references were garbage collected. In
2494 such a case, we don't actually need to build a procedure
2495 linkage table, and we can just do a PC32 reloc instead. */
2496 h->plt.offset = (bfd_vma) -1;
2503 /* It's possible that we incorrectly decided a .plt reloc was
2504 needed for an R_386_PC32 reloc to a non-function sym in
2505 check_relocs. We can't decide accurately between function and
2506 non-function syms in check-relocs; Objects loaded later in
2507 the link may change h->type. So fix it now. */
2508 h->plt.offset = (bfd_vma) -1;
2510 /* If this is a weak symbol, and there is a real definition, the
2511 processor independent code will have arranged for us to see the
2512 real definition first, and we can just use the same value. */
2513 if (h->u.weakdef != NULL)
2515 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2516 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2517 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2518 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2519 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
2520 h->non_got_ref = h->u.weakdef->non_got_ref;
2524 /* This is a reference to a symbol defined by a dynamic object which
2525 is not a function. */
2527 /* If we are creating a shared library, we must presume that the
2528 only references to the symbol are via the global offset table.
2529 For such cases we need not do anything here; the relocations will
2530 be handled correctly by relocate_section. */
2531 if (!bfd_link_executable (info))
2534 /* If there are no references to this symbol that do not use the
2535 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
2537 eh = (struct elf_i386_link_hash_entry *) h;
2538 if (!h->non_got_ref && !eh->gotoff_ref)
2541 /* If -z nocopyreloc was given, we won't generate them either. */
2542 if (info->nocopyreloc)
2548 htab = elf_i386_hash_table (info);
2552 /* If there aren't any dynamic relocs in read-only sections nor
2553 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
2554 avoid the copy reloc. This doesn't work on VxWorks, where we can
2555 not have dynamic relocations (other than copy and jump slot
2556 relocations) in an executable. */
2557 if (ELIMINATE_COPY_RELOCS
2559 && !get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
2561 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2563 s = p->sec->output_section;
2564 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2575 /* We must allocate the symbol in our .dynbss section, which will
2576 become part of the .bss section of the executable. There will be
2577 an entry for this symbol in the .dynsym section. The dynamic
2578 object will contain position independent code, so all references
2579 from the dynamic object to this symbol will go through the global
2580 offset table. The dynamic linker will use the .dynsym entry to
2581 determine the address it must put in the global offset table, so
2582 both the dynamic object and the regular object will refer to the
2583 same memory location for the variable. */
2585 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
2586 copy the initial value out of the dynamic object and into the
2587 runtime process image. */
2588 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
2590 s = htab->elf.sdynrelro;
2591 srel = htab->elf.sreldynrelro;
2595 s = htab->elf.sdynbss;
2596 srel = htab->elf.srelbss;
2598 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2600 srel->size += sizeof (Elf32_External_Rel);
2604 return _bfd_elf_adjust_dynamic_copy (info, h, s);
2607 /* Allocate space in .plt, .got and associated reloc sections for
2611 elf_i386_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
2613 struct bfd_link_info *info;
2614 struct elf_i386_link_hash_table *htab;
2615 struct elf_i386_link_hash_entry *eh;
2616 struct elf_dyn_relocs *p;
2617 unsigned plt_entry_size;
2618 bfd_boolean resolved_to_zero;
2620 if (h->root.type == bfd_link_hash_indirect)
2623 eh = (struct elf_i386_link_hash_entry *) h;
2625 info = (struct bfd_link_info *) inf;
2626 htab = elf_i386_hash_table (info);
2630 plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
2632 resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
2636 /* Clear the reference count of function pointer relocations if
2637 symbol isn't a normal function. */
2638 if (h->type != STT_FUNC)
2639 eh->func_pointer_refcount = 0;
2641 /* We can't use the GOT PLT if pointer equality is needed since
2642 finish_dynamic_symbol won't clear symbol value and the dynamic
2643 linker won't update the GOT slot. We will get into an infinite
2644 loop at run-time. */
2645 if (htab->plt_got != NULL
2646 && h->type != STT_GNU_IFUNC
2647 && !h->pointer_equality_needed
2648 && h->plt.refcount > 0
2649 && h->got.refcount > 0)
2651 /* Don't use the regular PLT if there are both GOT and GOTPLT
2653 h->plt.offset = (bfd_vma) -1;
2655 /* Use the GOT PLT. */
2656 eh->plt_got.refcount = 1;
2659 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2660 here if it is defined and referenced in a non-shared object. */
2661 if (h->type == STT_GNU_IFUNC
2663 return _bfd_elf_allocate_ifunc_dyn_relocs (info, h, &eh->dyn_relocs,
2664 &htab->readonly_dynrelocs_against_ifunc,
2666 plt_entry_size, 4, TRUE);
2667 /* Don't create the PLT entry if there are only function pointer
2668 relocations which can be resolved at run-time. */
2669 else if (htab->elf.dynamic_sections_created
2670 && (h->plt.refcount > eh->func_pointer_refcount
2671 || eh->plt_got.refcount > 0))
2673 bfd_boolean use_plt_got;
2675 /* Clear the reference count of function pointer relocations
2677 eh->func_pointer_refcount = 0;
2679 if ((info->flags & DF_BIND_NOW) && !h->pointer_equality_needed)
2681 /* Don't use the regular PLT for DF_BIND_NOW. */
2682 h->plt.offset = (bfd_vma) -1;
2684 /* Use the GOT PLT. */
2685 h->got.refcount = 1;
2686 eh->plt_got.refcount = 1;
2689 use_plt_got = eh->plt_got.refcount > 0;
2691 /* Make sure this symbol is output as a dynamic symbol.
2692 Undefined weak syms won't yet be marked as dynamic. */
2693 if (h->dynindx == -1
2695 && !resolved_to_zero)
2697 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2701 if (bfd_link_pic (info)
2702 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2704 asection *s = htab->elf.splt;
2705 asection *got_s = htab->plt_got;
2707 /* If this is the first .plt entry, make room for the special
2708 first entry. The .plt section is used by prelink to undo
2709 prelinking for dynamic relocations. */
2711 s->size = plt_entry_size;
2714 eh->plt_got.offset = got_s->size;
2716 h->plt.offset = s->size;
2718 /* If this symbol is not defined in a regular file, and we are
2719 not generating a shared library, then set the symbol to this
2720 location in the .plt. This is required to make function
2721 pointers compare as equal between the normal executable and
2722 the shared library. */
2723 if (! bfd_link_pic (info)
2728 /* We need to make a call to the entry of the GOT PLT
2729 instead of regular PLT entry. */
2730 h->root.u.def.section = got_s;
2731 h->root.u.def.value = eh->plt_got.offset;
2735 h->root.u.def.section = s;
2736 h->root.u.def.value = h->plt.offset;
2740 /* Make room for this entry. */
2742 got_s->size += sizeof (elf_i386_got_plt_entry);
2745 s->size += plt_entry_size;
2747 /* We also need to make an entry in the .got.plt section,
2748 which will be placed in the .got section by the linker
2750 htab->elf.sgotplt->size += 4;
2752 /* There should be no PLT relocation against resolved
2753 undefined weak symbol in executable. */
2754 if (!resolved_to_zero)
2756 /* We also need to make an entry in the .rel.plt
2758 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2759 htab->elf.srelplt->reloc_count++;
2763 if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks
2764 && !bfd_link_pic (info))
2766 /* VxWorks has a second set of relocations for each PLT entry
2767 in executables. They go in a separate relocation section,
2768 which is processed by the kernel loader. */
2770 /* There are two relocations for the initial PLT entry: an
2771 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2772 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
2774 if (h->plt.offset == plt_entry_size)
2775 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2777 /* There are two extra relocations for each subsequent PLT entry:
2778 an R_386_32 relocation for the GOT entry, and an R_386_32
2779 relocation for the PLT entry. */
2781 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2786 eh->plt_got.offset = (bfd_vma) -1;
2787 h->plt.offset = (bfd_vma) -1;
2793 eh->plt_got.offset = (bfd_vma) -1;
2794 h->plt.offset = (bfd_vma) -1;
2798 eh->tlsdesc_got = (bfd_vma) -1;
2800 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
2801 make it a R_386_TLS_LE_32 requiring no TLS entry. */
2802 if (h->got.refcount > 0
2803 && bfd_link_executable (info)
2805 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
2806 h->got.offset = (bfd_vma) -1;
2807 else if (h->got.refcount > 0)
2811 int tls_type = elf_i386_hash_entry(h)->tls_type;
2813 /* Make sure this symbol is output as a dynamic symbol.
2814 Undefined weak syms won't yet be marked as dynamic. */
2815 if (h->dynindx == -1
2817 && !resolved_to_zero)
2819 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2824 if (GOT_TLS_GDESC_P (tls_type))
2826 eh->tlsdesc_got = htab->elf.sgotplt->size
2827 - elf_i386_compute_jump_table_size (htab);
2828 htab->elf.sgotplt->size += 8;
2829 h->got.offset = (bfd_vma) -2;
2831 if (! GOT_TLS_GDESC_P (tls_type)
2832 || GOT_TLS_GD_P (tls_type))
2834 h->got.offset = s->size;
2836 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
2837 if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
2840 dyn = htab->elf.dynamic_sections_created;
2841 /* R_386_TLS_IE_32 needs one dynamic relocation,
2842 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2843 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2844 need two), R_386_TLS_GD needs one if local symbol and two if
2845 global. No dynamic relocation against resolved undefined weak
2846 symbol in executable. */
2847 if (tls_type == GOT_TLS_IE_BOTH)
2848 htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
2849 else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
2850 || (tls_type & GOT_TLS_IE))
2851 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2852 else if (GOT_TLS_GD_P (tls_type))
2853 htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
2854 else if (! GOT_TLS_GDESC_P (tls_type)
2855 && ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2856 && !resolved_to_zero)
2857 || h->root.type != bfd_link_hash_undefweak)
2858 && (bfd_link_pic (info)
2859 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
2860 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2861 if (GOT_TLS_GDESC_P (tls_type))
2862 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2865 h->got.offset = (bfd_vma) -1;
2867 if (eh->dyn_relocs == NULL)
2870 /* In the shared -Bsymbolic case, discard space allocated for
2871 dynamic pc-relative relocs against symbols which turn out to be
2872 defined in regular objects. For the normal shared case, discard
2873 space for pc-relative relocs that have become local due to symbol
2874 visibility changes. */
2876 if (bfd_link_pic (info))
2878 /* The only reloc that uses pc_count is R_386_PC32, which will
2879 appear on a call or on something like ".long foo - .". We
2880 want calls to protected symbols to resolve directly to the
2881 function rather than going via the plt. If people want
2882 function pointer comparisons to work as expected then they
2883 should avoid writing assembly like ".long foo - .". */
2884 if (SYMBOL_CALLS_LOCAL (info, h))
2886 struct elf_dyn_relocs **pp;
2888 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2890 p->count -= p->pc_count;
2899 if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
2901 struct elf_dyn_relocs **pp;
2902 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2904 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2911 /* Also discard relocs on undefined weak syms with non-default
2912 visibility or in PIE. */
2913 if (eh->dyn_relocs != NULL
2914 && h->root.type == bfd_link_hash_undefweak)
2916 /* Undefined weak symbol is never bound locally in shared
2918 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2919 || resolved_to_zero)
2923 /* Keep dynamic non-GOT/non-PLT relocation so that we
2924 can branch to 0 without PLT. */
2925 struct elf_dyn_relocs **pp;
2927 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2928 if (p->pc_count == 0)
2932 /* Remove non-R_386_PC32 relocation. */
2933 p->count = p->pc_count;
2937 if (eh->dyn_relocs != NULL)
2939 /* Make sure undefined weak symbols are output
2940 as dynamic symbols in PIEs for dynamic non-GOT
2941 non-PLT reloations. */
2942 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2947 eh->dyn_relocs = NULL;
2949 else if (h->dynindx == -1
2950 && !h->forced_local)
2952 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2957 else if (ELIMINATE_COPY_RELOCS)
2959 /* For the non-shared case, discard space for relocs against
2960 symbols which turn out to need copy relocs or are not
2961 dynamic. Keep dynamic relocations for run-time function
2962 pointer initialization. */
2964 if ((!h->non_got_ref
2965 || eh->func_pointer_refcount > 0
2966 || (h->root.type == bfd_link_hash_undefweak
2967 && !resolved_to_zero))
2970 || (htab->elf.dynamic_sections_created
2971 && (h->root.type == bfd_link_hash_undefweak
2972 || h->root.type == bfd_link_hash_undefined))))
2974 /* Make sure this symbol is output as a dynamic symbol.
2975 Undefined weak syms won't yet be marked as dynamic. */
2976 if (h->dynindx == -1
2978 && !resolved_to_zero)
2980 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2984 /* If that succeeded, we know we'll be keeping all the
2986 if (h->dynindx != -1)
2990 eh->dyn_relocs = NULL;
2991 eh->func_pointer_refcount = 0;
2996 /* Finally, allocate space. */
2997 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3001 sreloc = elf_section_data (p->sec)->sreloc;
3003 BFD_ASSERT (sreloc != NULL);
3004 sreloc->size += p->count * sizeof (Elf32_External_Rel);
3010 /* Allocate space in .plt, .got and associated reloc sections for
3011 local dynamic relocs. */
3014 elf_i386_allocate_local_dynrelocs (void **slot, void *inf)
3016 struct elf_link_hash_entry *h
3017 = (struct elf_link_hash_entry *) *slot;
3019 if (h->type != STT_GNU_IFUNC
3023 || h->root.type != bfd_link_hash_defined)
3026 return elf_i386_allocate_dynrelocs (h, inf);
3029 /* Find any dynamic relocs that apply to read-only sections. */
3032 elf_i386_readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
3034 struct elf_i386_link_hash_entry *eh;
3035 struct elf_dyn_relocs *p;
3037 /* Skip local IFUNC symbols. */
3038 if (h->forced_local && h->type == STT_GNU_IFUNC)
3041 eh = (struct elf_i386_link_hash_entry *) h;
3042 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3044 asection *s = p->sec->output_section;
3046 if (s != NULL && (s->flags & SEC_READONLY) != 0)
3048 struct bfd_link_info *info = (struct bfd_link_info *) inf;
3050 info->flags |= DF_TEXTREL;
3052 if ((info->warn_shared_textrel && bfd_link_pic (info))
3053 || info->error_textrel)
3054 /* xgettext:c-format */
3055 info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
3056 p->sec->owner, h->root.root.string,
3059 /* Not an error, just cut short the traversal. */
3066 /* Convert load via the GOT slot to load immediate. */
3069 elf_i386_convert_load (bfd *abfd, asection *sec,
3070 struct bfd_link_info *link_info)
3072 struct elf_i386_link_hash_table *htab;
3073 Elf_Internal_Shdr *symtab_hdr;
3074 Elf_Internal_Rela *internal_relocs;
3075 Elf_Internal_Rela *irel, *irelend;
3077 bfd_boolean changed;
3078 bfd_signed_vma *local_got_refcounts;
3080 /* Don't even try to convert non-ELF outputs. */
3081 if (!is_elf_hash_table (link_info->hash))
3084 /* Nothing to do if there is no need or no output. */
3085 if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
3086 || sec->need_convert_load == 0
3087 || bfd_is_abs_section (sec->output_section))
3090 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3092 /* Load the relocations for this section. */
3093 internal_relocs = (_bfd_elf_link_read_relocs
3094 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
3095 link_info->keep_memory));
3096 if (internal_relocs == NULL)
3100 htab = elf_i386_hash_table (link_info);
3101 local_got_refcounts = elf_local_got_refcounts (abfd);
3103 /* Get the section contents. */
3104 if (elf_section_data (sec)->this_hdr.contents != NULL)
3105 contents = elf_section_data (sec)->this_hdr.contents;
3108 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
3112 irelend = internal_relocs + sec->reloc_count;
3113 for (irel = internal_relocs; irel < irelend; irel++)
3115 unsigned int r_type = ELF32_R_TYPE (irel->r_info);
3116 unsigned int r_symndx;
3117 struct elf_link_hash_entry *h;
3118 bfd_boolean converted;
3120 /* Don't convert R_386_GOT32 since we can't tell if it is applied
3121 to "mov $foo@GOT, %reg" which isn't a load via GOT. */
3122 if (r_type != R_386_GOT32X)
3125 r_symndx = ELF32_R_SYM (irel->r_info);
3126 if (r_symndx < symtab_hdr->sh_info)
3127 h = elf_i386_get_local_sym_hash (htab, sec->owner,
3128 (const Elf_Internal_Rela *) irel,
3132 h = elf_sym_hashes (abfd)[r_symndx - symtab_hdr->sh_info];
3133 while (h->root.type == bfd_link_hash_indirect
3134 || h->root.type == bfd_link_hash_warning)
3135 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3138 /* STT_GNU_IFUNC must keep GOT32 relocations. */
3139 if (h != NULL && h->type == STT_GNU_IFUNC)
3143 if (!elf_i386_convert_load_reloc (abfd, symtab_hdr, contents,
3144 irel, h, &converted, link_info))
3149 changed = converted;
3152 if (h->got.refcount > 0)
3153 h->got.refcount -= 1;
3157 if (local_got_refcounts != NULL
3158 && local_got_refcounts[r_symndx] > 0)
3159 local_got_refcounts[r_symndx] -= 1;
3164 if (contents != NULL
3165 && elf_section_data (sec)->this_hdr.contents != contents)
3167 if (!changed && !link_info->keep_memory)
3171 /* Cache the section contents for elf_link_input_bfd. */
3172 elf_section_data (sec)->this_hdr.contents = contents;
3176 if (elf_section_data (sec)->relocs != internal_relocs)
3179 free (internal_relocs);
3181 elf_section_data (sec)->relocs = internal_relocs;
3187 if (contents != NULL
3188 && elf_section_data (sec)->this_hdr.contents != contents)
3190 if (internal_relocs != NULL
3191 && elf_section_data (sec)->relocs != internal_relocs)
3192 free (internal_relocs);
3196 /* Set the sizes of the dynamic sections. */
3199 elf_i386_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
3201 struct elf_i386_link_hash_table *htab;
3207 htab = elf_i386_hash_table (info);
3210 dynobj = htab->elf.dynobj;
3214 /* Set up .got offsets for local syms, and space for local dynamic
3216 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3218 bfd_signed_vma *local_got;
3219 bfd_signed_vma *end_local_got;
3220 char *local_tls_type;
3221 bfd_vma *local_tlsdesc_gotent;
3222 bfd_size_type locsymcount;
3223 Elf_Internal_Shdr *symtab_hdr;
3226 if (! is_i386_elf (ibfd))
3229 for (s = ibfd->sections; s != NULL; s = s->next)
3231 struct elf_dyn_relocs *p;
3233 if (!elf_i386_convert_load (ibfd, s, info))
3236 for (p = ((struct elf_dyn_relocs *)
3237 elf_section_data (s)->local_dynrel);
3241 if (!bfd_is_abs_section (p->sec)
3242 && bfd_is_abs_section (p->sec->output_section))
3244 /* Input section has been discarded, either because
3245 it is a copy of a linkonce section or due to
3246 linker script /DISCARD/, so we'll be discarding
3249 else if (get_elf_i386_backend_data (output_bfd)->is_vxworks
3250 && strcmp (p->sec->output_section->name,
3253 /* Relocations in vxworks .tls_vars sections are
3254 handled specially by the loader. */
3256 else if (p->count != 0)
3258 srel = elf_section_data (p->sec)->sreloc;
3259 srel->size += p->count * sizeof (Elf32_External_Rel);
3260 if ((p->sec->output_section->flags & SEC_READONLY) != 0
3261 && (info->flags & DF_TEXTREL) == 0)
3263 info->flags |= DF_TEXTREL;
3264 if ((info->warn_shared_textrel && bfd_link_pic (info))
3265 || info->error_textrel)
3266 /* xgettext:c-format */
3267 info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3268 p->sec->owner, p->sec);
3274 local_got = elf_local_got_refcounts (ibfd);
3278 symtab_hdr = &elf_symtab_hdr (ibfd);
3279 locsymcount = symtab_hdr->sh_info;
3280 end_local_got = local_got + locsymcount;
3281 local_tls_type = elf_i386_local_got_tls_type (ibfd);
3282 local_tlsdesc_gotent = elf_i386_local_tlsdesc_gotent (ibfd);
3284 srel = htab->elf.srelgot;
3285 for (; local_got < end_local_got;
3286 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
3288 *local_tlsdesc_gotent = (bfd_vma) -1;
3291 if (GOT_TLS_GDESC_P (*local_tls_type))
3293 *local_tlsdesc_gotent = htab->elf.sgotplt->size
3294 - elf_i386_compute_jump_table_size (htab);
3295 htab->elf.sgotplt->size += 8;
3296 *local_got = (bfd_vma) -2;
3298 if (! GOT_TLS_GDESC_P (*local_tls_type)
3299 || GOT_TLS_GD_P (*local_tls_type))
3301 *local_got = s->size;
3303 if (GOT_TLS_GD_P (*local_tls_type)
3304 || *local_tls_type == GOT_TLS_IE_BOTH)
3307 if (bfd_link_pic (info)
3308 || GOT_TLS_GD_ANY_P (*local_tls_type)
3309 || (*local_tls_type & GOT_TLS_IE))
3311 if (*local_tls_type == GOT_TLS_IE_BOTH)
3312 srel->size += 2 * sizeof (Elf32_External_Rel);
3313 else if (GOT_TLS_GD_P (*local_tls_type)
3314 || ! GOT_TLS_GDESC_P (*local_tls_type))
3315 srel->size += sizeof (Elf32_External_Rel);
3316 if (GOT_TLS_GDESC_P (*local_tls_type))
3317 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
3321 *local_got = (bfd_vma) -1;
3325 if (htab->tls_ldm_got.refcount > 0)
3327 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
3329 htab->tls_ldm_got.offset = htab->elf.sgot->size;
3330 htab->elf.sgot->size += 8;
3331 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
3334 htab->tls_ldm_got.offset = -1;
3336 /* Allocate global sym .plt and .got entries, and space for global
3337 sym dynamic relocs. */
3338 elf_link_hash_traverse (&htab->elf, elf_i386_allocate_dynrelocs, info);
3340 /* Allocate .plt and .got entries, and space for local symbols. */
3341 htab_traverse (htab->loc_hash_table,
3342 elf_i386_allocate_local_dynrelocs,
3345 /* For every jump slot reserved in the sgotplt, reloc_count is
3346 incremented. However, when we reserve space for TLS descriptors,
3347 it's not incremented, so in order to compute the space reserved
3348 for them, it suffices to multiply the reloc count by the jump
3351 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3352 so that R_386_IRELATIVE entries come last. */
3353 if (htab->elf.srelplt)
3355 htab->next_tls_desc_index = htab->elf.srelplt->reloc_count;
3356 htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4;
3357 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
3359 else if (htab->elf.irelplt)
3360 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
3363 if (htab->elf.sgotplt)
3365 /* Don't allocate .got.plt section if there are no GOT nor PLT
3366 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
3367 if ((htab->elf.hgot == NULL
3368 || !htab->elf.hgot->ref_regular_nonweak)
3369 && (htab->elf.sgotplt->size
3370 == get_elf_backend_data (output_bfd)->got_header_size)
3371 && (htab->elf.splt == NULL
3372 || htab->elf.splt->size == 0)
3373 && (htab->elf.sgot == NULL
3374 || htab->elf.sgot->size == 0)
3375 && (htab->elf.iplt == NULL
3376 || htab->elf.iplt->size == 0)
3377 && (htab->elf.igotplt == NULL
3378 || htab->elf.igotplt->size == 0))
3379 htab->elf.sgotplt->size = 0;
3383 if (htab->plt_eh_frame != NULL
3384 && htab->elf.splt != NULL
3385 && htab->elf.splt->size != 0
3386 && !bfd_is_abs_section (htab->elf.splt->output_section)
3387 && _bfd_elf_eh_frame_present (info))
3388 htab->plt_eh_frame->size = sizeof (elf_i386_eh_frame_plt);
3390 /* We now have determined the sizes of the various dynamic sections.
3391 Allocate memory for them. */
3393 for (s = dynobj->sections; s != NULL; s = s->next)
3395 bfd_boolean strip_section = TRUE;
3397 if ((s->flags & SEC_LINKER_CREATED) == 0)
3400 if (s == htab->elf.splt
3401 || s == htab->elf.sgot)
3403 /* Strip this section if we don't need it; see the
3405 /* We'd like to strip these sections if they aren't needed, but if
3406 we've exported dynamic symbols from them we must leave them.
3407 It's too late to tell BFD to get rid of the symbols. */
3409 if (htab->elf.hplt != NULL)
3410 strip_section = FALSE;
3412 else if (s == htab->elf.sgotplt
3413 || s == htab->elf.iplt
3414 || s == htab->elf.igotplt
3415 || s == htab->plt_got
3416 || s == htab->plt_eh_frame
3417 || s == htab->elf.sdynbss
3418 || s == htab->elf.sdynrelro)
3420 /* Strip these too. */
3422 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rel"))
3425 && s != htab->elf.srelplt
3426 && s != htab->srelplt2)
3429 /* We use the reloc_count field as a counter if we need
3430 to copy relocs into the output file. */
3435 /* It's not one of our sections, so don't allocate space. */
3441 /* If we don't need this section, strip it from the
3442 output file. This is mostly to handle .rel.bss and
3443 .rel.plt. We must create both sections in
3444 create_dynamic_sections, because they must be created
3445 before the linker maps input sections to output
3446 sections. The linker does that before
3447 adjust_dynamic_symbol is called, and it is that
3448 function which decides whether anything needs to go
3449 into these sections. */
3451 s->flags |= SEC_EXCLUDE;
3455 if ((s->flags & SEC_HAS_CONTENTS) == 0)
3458 /* Allocate memory for the section contents. We use bfd_zalloc
3459 here in case unused entries are not reclaimed before the
3460 section's contents are written out. This should not happen,
3461 but this way if it does, we get a R_386_NONE reloc instead
3463 s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
3464 if (s->contents == NULL)
3468 if (htab->plt_eh_frame != NULL
3469 && htab->plt_eh_frame->contents != NULL)
3471 memcpy (htab->plt_eh_frame->contents, elf_i386_eh_frame_plt,
3472 sizeof (elf_i386_eh_frame_plt));
3473 bfd_put_32 (dynobj, htab->elf.splt->size,
3474 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
3477 if (htab->elf.dynamic_sections_created)
3479 /* Add some entries to the .dynamic section. We fill in the
3480 values later, in elf_i386_finish_dynamic_sections, but we
3481 must add the entries now so that we get the correct size for
3482 the .dynamic section. The DT_DEBUG entry is filled in by the
3483 dynamic linker and used by the debugger. */
3484 #define add_dynamic_entry(TAG, VAL) \
3485 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3487 if (bfd_link_executable (info))
3489 if (!add_dynamic_entry (DT_DEBUG, 0))
3493 if (htab->elf.splt->size != 0)
3495 /* DT_PLTGOT is used by prelink even if there is no PLT
3497 if (!add_dynamic_entry (DT_PLTGOT, 0))
3500 if (htab->elf.srelplt->size != 0)
3502 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3503 || !add_dynamic_entry (DT_PLTREL, DT_REL)
3504 || !add_dynamic_entry (DT_JMPREL, 0))
3511 if (!add_dynamic_entry (DT_REL, 0)
3512 || !add_dynamic_entry (DT_RELSZ, 0)
3513 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
3516 /* If any dynamic relocs apply to a read-only section,
3517 then we need a DT_TEXTREL entry. */
3518 if ((info->flags & DF_TEXTREL) == 0)
3519 elf_link_hash_traverse (&htab->elf,
3520 elf_i386_readonly_dynrelocs, info);
3522 if ((info->flags & DF_TEXTREL) != 0)
3524 if (htab->readonly_dynrelocs_against_ifunc)
3526 info->callbacks->einfo
3527 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3528 bfd_set_error (bfd_error_bad_value);
3532 if (!add_dynamic_entry (DT_TEXTREL, 0))
3536 if (get_elf_i386_backend_data (output_bfd)->is_vxworks
3537 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
3540 #undef add_dynamic_entry
3546 elf_i386_always_size_sections (bfd *output_bfd,
3547 struct bfd_link_info *info)
3549 asection *tls_sec = elf_hash_table (info)->tls_sec;
3553 struct elf_link_hash_entry *tlsbase;
3555 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
3556 "_TLS_MODULE_BASE_",
3557 FALSE, FALSE, FALSE);
3559 if (tlsbase && tlsbase->type == STT_TLS)
3561 struct elf_i386_link_hash_table *htab;
3562 struct bfd_link_hash_entry *bh = NULL;
3563 const struct elf_backend_data *bed
3564 = get_elf_backend_data (output_bfd);
3566 htab = elf_i386_hash_table (info);
3570 if (!(_bfd_generic_link_add_one_symbol
3571 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
3572 tls_sec, 0, NULL, FALSE,
3573 bed->collect, &bh)))
3576 htab->tls_module_base = bh;
3578 tlsbase = (struct elf_link_hash_entry *)bh;
3579 tlsbase->def_regular = 1;
3580 tlsbase->other = STV_HIDDEN;
3581 tlsbase->root.linker_def = 1;
3582 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
3589 /* Set the correct type for an x86 ELF section. We do this by the
3590 section name, which is a hack, but ought to work. */
3593 elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
3594 Elf_Internal_Shdr *hdr,
3599 name = bfd_get_section_name (abfd, sec);
3601 /* This is an ugly, but unfortunately necessary hack that is
3602 needed when producing EFI binaries on x86. It tells
3603 elf.c:elf_fake_sections() not to consider ".reloc" as a section
3604 containing ELF relocation info. We need this hack in order to
3605 be able to generate ELF binaries that can be translated into
3606 EFI applications (which are essentially COFF objects). Those
3607 files contain a COFF ".reloc" section inside an ELFNN object,
3608 which would normally cause BFD to segfault because it would
3609 attempt to interpret this section as containing relocation
3610 entries for section "oc". With this hack enabled, ".reloc"
3611 will be treated as a normal data section, which will avoid the
3612 segfault. However, you won't be able to create an ELFNN binary
3613 with a section named "oc" that needs relocations, but that's
3614 the kind of ugly side-effects you get when detecting section
3615 types based on their names... In practice, this limitation is
3616 unlikely to bite. */
3617 if (strcmp (name, ".reloc") == 0)
3618 hdr->sh_type = SHT_PROGBITS;
3623 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3624 executables. Rather than setting it to the beginning of the TLS
3625 section, we have to set it to the end. This function may be called
3626 multiple times, it is idempotent. */
3629 elf_i386_set_tls_module_base (struct bfd_link_info *info)
3631 struct elf_i386_link_hash_table *htab;
3632 struct bfd_link_hash_entry *base;
3634 if (!bfd_link_executable (info))
3637 htab = elf_i386_hash_table (info);
3641 base = htab->tls_module_base;
3645 base->u.def.value = htab->elf.tls_size;
3648 /* Return the base VMA address which should be subtracted from real addresses
3649 when resolving @dtpoff relocation.
3650 This is PT_TLS segment p_vaddr. */
3653 elf_i386_dtpoff_base (struct bfd_link_info *info)
3655 /* If tls_sec is NULL, we should have signalled an error already. */
3656 if (elf_hash_table (info)->tls_sec == NULL)
3658 return elf_hash_table (info)->tls_sec->vma;
3661 /* Return the relocation value for @tpoff relocation
3662 if STT_TLS virtual address is ADDRESS. */
3665 elf_i386_tpoff (struct bfd_link_info *info, bfd_vma address)
3667 struct elf_link_hash_table *htab = elf_hash_table (info);
3668 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3669 bfd_vma static_tls_size;
3671 /* If tls_sec is NULL, we should have signalled an error already. */
3672 if (htab->tls_sec == NULL)
3675 /* Consider special static TLS alignment requirements. */
3676 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3677 return static_tls_size + htab->tls_sec->vma - address;
3680 /* Relocate an i386 ELF section. */
3683 elf_i386_relocate_section (bfd *output_bfd,
3684 struct bfd_link_info *info,
3686 asection *input_section,
3688 Elf_Internal_Rela *relocs,
3689 Elf_Internal_Sym *local_syms,
3690 asection **local_sections)
3692 struct elf_i386_link_hash_table *htab;
3693 Elf_Internal_Shdr *symtab_hdr;
3694 struct elf_link_hash_entry **sym_hashes;
3695 bfd_vma *local_got_offsets;
3696 bfd_vma *local_tlsdesc_gotents;
3697 Elf_Internal_Rela *rel;
3698 Elf_Internal_Rela *wrel;
3699 Elf_Internal_Rela *relend;
3700 bfd_boolean is_vxworks_tls;
3701 unsigned plt_entry_size;
3703 BFD_ASSERT (is_i386_elf (input_bfd));
3705 /* Skip if check_relocs failed. */
3706 if (input_section->check_relocs_failed)
3709 htab = elf_i386_hash_table (info);
3712 symtab_hdr = &elf_symtab_hdr (input_bfd);
3713 sym_hashes = elf_sym_hashes (input_bfd);
3714 local_got_offsets = elf_local_got_offsets (input_bfd);
3715 local_tlsdesc_gotents = elf_i386_local_tlsdesc_gotent (input_bfd);
3716 /* We have to handle relocations in vxworks .tls_vars sections
3717 specially, because the dynamic loader is 'weird'. */
3718 is_vxworks_tls = (get_elf_i386_backend_data (output_bfd)->is_vxworks
3719 && bfd_link_pic (info)
3720 && !strcmp (input_section->output_section->name,
3723 elf_i386_set_tls_module_base (info);
3725 plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
3727 rel = wrel = relocs;
3728 relend = relocs + input_section->reloc_count;
3729 for (; rel < relend; wrel++, rel++)
3731 unsigned int r_type;
3732 reloc_howto_type *howto;
3733 unsigned long r_symndx;
3734 struct elf_link_hash_entry *h;
3735 struct elf_i386_link_hash_entry *eh;
3736 Elf_Internal_Sym *sym;
3738 bfd_vma off, offplt, plt_offset;
3740 bfd_boolean unresolved_reloc;
3741 bfd_reloc_status_type r;
3745 asection *resolved_plt;
3746 bfd_boolean resolved_to_zero;
3748 r_type = ELF32_R_TYPE (rel->r_info);
3749 if (r_type == R_386_GNU_VTINHERIT
3750 || r_type == R_386_GNU_VTENTRY)
3757 if ((indx = r_type) >= R_386_standard
3758 && ((indx = r_type - R_386_ext_offset) - R_386_standard
3759 >= R_386_ext - R_386_standard)
3760 && ((indx = r_type - R_386_tls_offset) - R_386_ext
3761 >= R_386_ext2 - R_386_ext))
3764 /* xgettext:c-format */
3765 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3766 input_bfd, input_section, r_type);
3767 bfd_set_error (bfd_error_bad_value);
3770 howto = elf_howto_table + indx;
3772 r_symndx = ELF32_R_SYM (rel->r_info);
3776 unresolved_reloc = FALSE;
3777 if (r_symndx < symtab_hdr->sh_info)
3779 sym = local_syms + r_symndx;
3780 sec = local_sections[r_symndx];
3781 relocation = (sec->output_section->vma
3782 + sec->output_offset
3784 st_size = sym->st_size;
3786 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
3787 && ((sec->flags & SEC_MERGE) != 0
3788 || (bfd_link_relocatable (info)
3789 && sec->output_offset != 0)))
3792 bfd_byte *where = contents + rel->r_offset;
3794 switch (howto->size)
3797 addend = bfd_get_8 (input_bfd, where);
3798 if (howto->pc_relative)
3800 addend = (addend ^ 0x80) - 0x80;
3805 addend = bfd_get_16 (input_bfd, where);
3806 if (howto->pc_relative)
3808 addend = (addend ^ 0x8000) - 0x8000;
3813 addend = bfd_get_32 (input_bfd, where);
3814 if (howto->pc_relative)
3816 addend = (addend ^ 0x80000000) - 0x80000000;
3824 if (bfd_link_relocatable (info))
3825 addend += sec->output_offset;
3828 asection *msec = sec;
3829 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
3831 addend -= relocation;
3832 addend += msec->output_section->vma + msec->output_offset;
3835 switch (howto->size)
3838 /* FIXME: overflow checks. */
3839 if (howto->pc_relative)
3841 bfd_put_8 (input_bfd, addend, where);
3844 if (howto->pc_relative)
3846 bfd_put_16 (input_bfd, addend, where);
3849 if (howto->pc_relative)
3851 bfd_put_32 (input_bfd, addend, where);
3855 else if (!bfd_link_relocatable (info)
3856 && ELF32_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3858 /* Relocate against local STT_GNU_IFUNC symbol. */
3859 h = elf_i386_get_local_sym_hash (htab, input_bfd, rel,
3864 /* Set STT_GNU_IFUNC symbol value. */
3865 h->root.u.def.value = sym->st_value;
3866 h->root.u.def.section = sec;
3871 bfd_boolean warned ATTRIBUTE_UNUSED;
3872 bfd_boolean ignored ATTRIBUTE_UNUSED;
3874 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3875 r_symndx, symtab_hdr, sym_hashes,
3877 unresolved_reloc, warned, ignored);
3881 if (sec != NULL && discarded_section (sec))
3883 _bfd_clear_contents (howto, input_bfd, input_section,
3884 contents + rel->r_offset);
3885 wrel->r_offset = rel->r_offset;
3889 /* For ld -r, remove relocations in debug sections against
3890 sections defined in discarded sections. Not done for
3891 eh_frame editing code expects to be present. */
3892 if (bfd_link_relocatable (info)
3893 && (input_section->flags & SEC_DEBUGGING))
3899 if (bfd_link_relocatable (info))
3906 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3907 it here if it is defined in a non-shared object. */
3909 && h->type == STT_GNU_IFUNC
3912 asection *plt, *gotplt, *base_got;
3916 if ((input_section->flags & SEC_ALLOC) == 0)
3918 /* Dynamic relocs are not propagated for SEC_DEBUGGING
3919 sections because such sections are not SEC_ALLOC and
3920 thus ld.so will not process them. */
3921 if ((input_section->flags & SEC_DEBUGGING) != 0)
3926 /* STT_GNU_IFUNC symbol must go through PLT. */
3927 if (htab->elf.splt != NULL)
3929 plt = htab->elf.splt;
3930 gotplt = htab->elf.sgotplt;
3934 plt = htab->elf.iplt;
3935 gotplt = htab->elf.igotplt;
3945 base_got = htab->elf.sgot;
3946 off = h->got.offset;
3948 if (base_got == NULL)
3951 if (off == (bfd_vma) -1)
3953 /* We can't use h->got.offset here to save state, or
3954 even just remember the offset, as finish_dynamic_symbol
3955 would use that as offset into .got. */
3957 if (h->plt.offset == (bfd_vma) -1)
3960 if (htab->elf.splt != NULL)
3962 plt_index = h->plt.offset / plt_entry_size - 1;
3963 off = (plt_index + 3) * 4;
3964 base_got = htab->elf.sgotplt;
3968 plt_index = h->plt.offset / plt_entry_size;
3969 off = plt_index * 4;
3970 base_got = htab->elf.igotplt;
3973 if (h->dynindx == -1
3977 /* This references the local defitionion. We must
3978 initialize this entry in the global offset table.
3979 Since the offset must always be a multiple of 8,
3980 we use the least significant bit to record
3981 whether we have initialized it already.
3983 When doing a dynamic link, we create a .rela.got
3984 relocation entry to initialize the value. This
3985 is done in the finish_dynamic_symbol routine. */
3990 bfd_put_32 (output_bfd, relocation,
3991 base_got->contents + off);
3999 relocation = (base_got->output_section->vma
4000 + base_got->output_offset + off
4001 - gotplt->output_section->vma
4002 - gotplt->output_offset);
4004 if ((*(contents + rel->r_offset - 1) & 0xc7) == 0x5)
4006 if (bfd_link_pic (info))
4007 goto disallow_got32;
4009 /* Add the GOT base if there is no base register. */
4010 relocation += (gotplt->output_section->vma
4011 + gotplt->output_offset);
4013 else if (htab->elf.splt == NULL)
4015 /* Adjust for static executables. */
4016 relocation += gotplt->output_offset;
4022 if (h->plt.offset == (bfd_vma) -1)
4024 /* Handle static pointers of STT_GNU_IFUNC symbols. */
4025 if (r_type == R_386_32
4026 && (input_section->flags & SEC_CODE) == 0)
4027 goto do_ifunc_pointer;
4028 goto bad_ifunc_reloc;
4031 relocation = (plt->output_section->vma
4032 + plt->output_offset + h->plt.offset);
4038 if (h->root.root.string)
4039 name = h->root.root.string;
4041 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
4044 /* xgettext:c-format */
4045 (_("%B: relocation %s against STT_GNU_IFUNC "
4046 "symbol `%s' isn't supported"), input_bfd,
4048 bfd_set_error (bfd_error_bad_value);
4052 /* Generate dynamic relcoation only when there is a
4053 non-GOT reference in a shared object. */
4054 if ((bfd_link_pic (info) && h->non_got_ref)
4055 || h->plt.offset == (bfd_vma) -1)
4057 Elf_Internal_Rela outrel;
4062 /* Need a dynamic relocation to get the real function
4064 offset = _bfd_elf_section_offset (output_bfd,
4068 if (offset == (bfd_vma) -1
4069 || offset == (bfd_vma) -2)
4072 outrel.r_offset = (input_section->output_section->vma
4073 + input_section->output_offset
4076 if (h->dynindx == -1
4078 || bfd_link_executable (info))
4080 /* This symbol is resolved locally. */
4081 outrel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
4082 bfd_put_32 (output_bfd,
4083 (h->root.u.def.value
4084 + h->root.u.def.section->output_section->vma
4085 + h->root.u.def.section->output_offset),
4089 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4091 /* Dynamic relocations are stored in
4092 1. .rel.ifunc section in PIC object.
4093 2. .rel.got section in dynamic executable.
4094 3. .rel.iplt section in static executable. */
4095 if (bfd_link_pic (info))
4096 sreloc = htab->elf.irelifunc;
4097 else if (htab->elf.splt != NULL)
4098 sreloc = htab->elf.srelgot;
4100 sreloc = htab->elf.irelplt;
4101 elf_append_rel (output_bfd, sreloc, &outrel);
4103 /* If this reloc is against an external symbol, we
4104 do not want to fiddle with the addend. Otherwise,
4105 we need to include the symbol value so that it
4106 becomes an addend for the dynamic reloc. For an
4107 internal symbol, we have updated addend. */
4116 relocation -= (gotplt->output_section->vma
4117 + gotplt->output_offset);
4122 eh = (struct elf_i386_link_hash_entry *) h;
4123 resolved_to_zero = (eh != NULL
4124 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
4131 /* Avoid optimizing _DYNAMIC since ld.so may use its
4132 link-time address. */
4133 if (h == htab->elf.hdynamic)
4136 if (bfd_link_pic (info))
4138 /* It is OK to convert mov to lea and convert indirect
4139 branch to direct branch. It is OK to convert adc,
4140 add, and, cmp, or, sbb, sub, test, xor only when PIC
4142 unsigned int opcode, addend;
4143 addend = bfd_get_32 (input_bfd, contents + rel->r_offset);
4146 opcode = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
4147 if (opcode != 0x8b && opcode != 0xff)
4151 /* Resolve "mov GOT[(%reg)], %reg",
4152 "call/jmp *GOT[(%reg)]", "test %reg, foo@GOT[(%reg)]"
4153 and "binop foo@GOT[(%reg)], %reg". */
4155 || (h->plt.offset == (bfd_vma) -1
4156 && h->got.offset == (bfd_vma) -1)
4157 || htab->elf.sgotplt == NULL)
4160 offplt = (htab->elf.sgotplt->output_section->vma
4161 + htab->elf.sgotplt->output_offset);
4163 /* It is relative to .got.plt section. */
4164 if (h->got.offset != (bfd_vma) -1)
4165 /* Use GOT entry. Mask off the least significant bit in
4166 GOT offset which may be set by R_386_GOT32 processing
4168 relocation = (htab->elf.sgot->output_section->vma
4169 + htab->elf.sgot->output_offset
4170 + (h->got.offset & ~1) - offplt);
4172 /* Use GOTPLT entry. */
4173 relocation = (h->plt.offset / plt_entry_size - 1 + 3) * 4;
4175 if (!bfd_link_pic (info))
4177 /* If not PIC, add the .got.plt section address for
4178 baseless addressing. */
4180 modrm = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4181 if ((modrm & 0xc7) == 0x5)
4182 relocation += offplt;
4185 unresolved_reloc = FALSE;
4190 /* Relocation is to the entry for this symbol in the global
4192 if (htab->elf.sgot == NULL)
4199 off = h->got.offset;
4200 dyn = htab->elf.dynamic_sections_created;
4201 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4202 bfd_link_pic (info),
4204 || (bfd_link_pic (info)
4205 && SYMBOL_REFERENCES_LOCAL (info, h))
4206 || (ELF_ST_VISIBILITY (h->other)
4207 && h->root.type == bfd_link_hash_undefweak))
4209 /* This is actually a static link, or it is a
4210 -Bsymbolic link and the symbol is defined
4211 locally, or the symbol was forced to be local
4212 because of a version file. We must initialize
4213 this entry in the global offset table. Since the
4214 offset must always be a multiple of 4, we use the
4215 least significant bit to record whether we have
4216 initialized it already.
4218 When doing a dynamic link, we create a .rel.got
4219 relocation entry to initialize the value. This
4220 is done in the finish_dynamic_symbol routine. */
4225 bfd_put_32 (output_bfd, relocation,
4226 htab->elf.sgot->contents + off);
4231 unresolved_reloc = FALSE;
4235 if (local_got_offsets == NULL)
4238 off = local_got_offsets[r_symndx];
4240 /* The offset must always be a multiple of 4. We use
4241 the least significant bit to record whether we have
4242 already generated the necessary reloc. */
4247 bfd_put_32 (output_bfd, relocation,
4248 htab->elf.sgot->contents + off);
4250 if (bfd_link_pic (info))
4253 Elf_Internal_Rela outrel;
4255 s = htab->elf.srelgot;
4259 outrel.r_offset = (htab->elf.sgot->output_section->vma
4260 + htab->elf.sgot->output_offset
4262 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4263 elf_append_rel (output_bfd, s, &outrel);
4266 local_got_offsets[r_symndx] |= 1;
4270 if (off >= (bfd_vma) -2)
4273 relocation = (htab->elf.sgot->output_section->vma
4274 + htab->elf.sgot->output_offset + off);
4275 if ((*(contents + rel->r_offset - 1) & 0xc7) == 0x5)
4277 if (bfd_link_pic (info))
4279 /* For PIC, disallow R_386_GOT32 without a base
4280 register since we don't know what the GOT base
4286 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
4289 name = h->root.root.string;
4292 /* xgettext:c-format */
4293 (_("%B: direct GOT relocation %s against `%s' without base register can not be used when making a shared object"),
4294 input_bfd, howto->name, name);
4295 bfd_set_error (bfd_error_bad_value);
4301 /* Subtract the .got.plt section address only with a base
4303 relocation -= (htab->elf.sgotplt->output_section->vma
4304 + htab->elf.sgotplt->output_offset);
4310 /* Relocation is relative to the start of the global offset
4313 /* Check to make sure it isn't a protected function or data
4314 symbol for shared library since it may not be local when
4315 used as function address or with copy relocation. We also
4316 need to make sure that a symbol is referenced locally. */
4317 if (!bfd_link_executable (info) && h)
4319 if (!h->def_regular)
4323 switch (ELF_ST_VISIBILITY (h->other))
4326 v = _("hidden symbol");
4329 v = _("internal symbol");
4332 v = _("protected symbol");
4340 /* xgettext:c-format */
4341 (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
4342 input_bfd, v, h->root.root.string);
4343 bfd_set_error (bfd_error_bad_value);
4346 else if (!SYMBOL_REFERENCES_LOCAL (info, h)
4347 && (h->type == STT_FUNC
4348 || h->type == STT_OBJECT)
4349 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
4352 /* xgettext:c-format */
4353 (_("%B: relocation R_386_GOTOFF against protected %s `%s' can not be used when making a shared object"),
4355 h->type == STT_FUNC ? "function" : "data",
4356 h->root.root.string);
4357 bfd_set_error (bfd_error_bad_value);
4362 /* Note that sgot is not involved in this
4363 calculation. We always want the start of .got.plt. If we
4364 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4365 permitted by the ABI, we might have to change this
4367 relocation -= htab->elf.sgotplt->output_section->vma
4368 + htab->elf.sgotplt->output_offset;
4372 /* Use global offset table as symbol value. */
4373 relocation = htab->elf.sgotplt->output_section->vma
4374 + htab->elf.sgotplt->output_offset;
4375 unresolved_reloc = FALSE;
4379 /* Relocation is to the entry for this symbol in the
4380 procedure linkage table. */
4382 /* Resolve a PLT32 reloc against a local symbol directly,
4383 without using the procedure linkage table. */
4387 if ((h->plt.offset == (bfd_vma) -1
4388 && eh->plt_got.offset == (bfd_vma) -1)
4389 || htab->elf.splt == NULL)
4391 /* We didn't make a PLT entry for this symbol. This
4392 happens when statically linking PIC code, or when
4393 using -Bsymbolic. */
4397 if (h->plt.offset != (bfd_vma) -1)
4399 resolved_plt = htab->elf.splt;
4400 plt_offset = h->plt.offset;
4404 resolved_plt = htab->plt_got;
4405 plt_offset = eh->plt_got.offset;
4408 relocation = (resolved_plt->output_section->vma
4409 + resolved_plt->output_offset
4411 unresolved_reloc = FALSE;
4415 /* Set to symbol size. */
4416 relocation = st_size;
4421 if ((input_section->flags & SEC_ALLOC) == 0
4425 /* Copy dynamic function pointer relocations. Don't generate
4426 dynamic relocations against resolved undefined weak symbols
4427 in PIE, except for R_386_PC32. */
4428 if ((bfd_link_pic (info)
4430 || ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4431 && (!resolved_to_zero
4432 || r_type == R_386_PC32))
4433 || h->root.type != bfd_link_hash_undefweak))
4434 && ((r_type != R_386_PC32 && r_type != R_386_SIZE32)
4435 || !SYMBOL_CALLS_LOCAL (info, h)))
4436 || (ELIMINATE_COPY_RELOCS
4437 && !bfd_link_pic (info)
4441 || eh->func_pointer_refcount > 0
4442 || (h->root.type == bfd_link_hash_undefweak
4443 && !resolved_to_zero))
4444 && ((h->def_dynamic && !h->def_regular)
4445 /* Undefined weak symbol is bound locally when
4447 || h->root.type == bfd_link_hash_undefweak)))
4449 Elf_Internal_Rela outrel;
4450 bfd_boolean skip, relocate;
4453 /* When generating a shared object, these relocations
4454 are copied into the output file to be resolved at run
4461 _bfd_elf_section_offset (output_bfd, info, input_section,
4463 if (outrel.r_offset == (bfd_vma) -1)
4465 else if (outrel.r_offset == (bfd_vma) -2)
4466 skip = TRUE, relocate = TRUE;
4467 outrel.r_offset += (input_section->output_section->vma
4468 + input_section->output_offset);
4471 memset (&outrel, 0, sizeof outrel);
4474 && (r_type == R_386_PC32
4475 || !(bfd_link_executable (info)
4476 || SYMBOLIC_BIND (info, h))
4477 || !h->def_regular))
4478 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4481 /* This symbol is local, or marked to become local. */
4483 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4486 sreloc = elf_section_data (input_section)->sreloc;
4488 if (sreloc == NULL || sreloc->contents == NULL)
4490 r = bfd_reloc_notsupported;
4491 goto check_relocation_error;
4494 elf_append_rel (output_bfd, sreloc, &outrel);
4496 /* If this reloc is against an external symbol, we do
4497 not want to fiddle with the addend. Otherwise, we
4498 need to include the symbol value so that it becomes
4499 an addend for the dynamic reloc. */
4506 if (!bfd_link_executable (info))
4508 Elf_Internal_Rela outrel;
4511 outrel.r_offset = rel->r_offset
4512 + input_section->output_section->vma
4513 + input_section->output_offset;
4514 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4515 sreloc = elf_section_data (input_section)->sreloc;
4518 elf_append_rel (output_bfd, sreloc, &outrel);
4523 case R_386_TLS_GOTDESC:
4524 case R_386_TLS_DESC_CALL:
4525 case R_386_TLS_IE_32:
4526 case R_386_TLS_GOTIE:
4527 tls_type = GOT_UNKNOWN;
4528 if (h == NULL && local_got_offsets)
4529 tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
4531 tls_type = elf_i386_hash_entry(h)->tls_type;
4532 if (tls_type == GOT_TLS_IE)
4533 tls_type = GOT_TLS_IE_NEG;
4535 if (! elf_i386_tls_transition (info, input_bfd,
4536 input_section, contents,
4537 symtab_hdr, sym_hashes,
4538 &r_type, tls_type, rel,
4539 relend, h, r_symndx, TRUE))
4542 if (r_type == R_386_TLS_LE_32)
4544 BFD_ASSERT (! unresolved_reloc);
4545 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
4550 /* GD->LE transition. */
4551 type = *(contents + rel->r_offset - 2);
4555 leal foo@tlsgd(,%ebx,1), %eax
4556 call ___tls_get_addr@PLT
4559 subl $foo@tpoff, %eax
4560 (6 byte form of subl). */
4561 roff = rel->r_offset + 5;
4566 leal foo@tlsgd(%ebx), %eax
4567 call ___tls_get_addr@PLT
4570 leal foo@tlsgd(%reg), %eax
4571 call *___tls_get_addr@GOT(%reg)
4572 which may be converted to
4573 addr32 call ___tls_get_addr
4575 movl %gs:0, %eax; subl $foo@tpoff, %eax
4576 (6 byte form of subl). */
4577 roff = rel->r_offset + 6;
4579 memcpy (contents + roff - 8,
4580 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
4581 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
4583 /* Skip R_386_PC32, R_386_PLT32 and R_386_GOT32X. */
4588 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4590 /* GDesc -> LE transition.
4591 It's originally something like:
4592 leal x@tlsdesc(%ebx), %eax
4596 Registers other than %eax may be set up here. */
4601 roff = rel->r_offset;
4602 val = bfd_get_8 (input_bfd, contents + roff - 1);
4604 /* Now modify the instruction as appropriate. */
4605 /* aoliva FIXME: remove the above and xor the byte
4607 bfd_put_8 (output_bfd, val ^ 0x86,
4608 contents + roff - 1);
4609 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
4613 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4615 /* GDesc -> LE transition.
4623 roff = rel->r_offset;
4624 bfd_put_8 (output_bfd, 0x66, contents + roff);
4625 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4628 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
4632 /* IE->LE transition:
4633 Originally it can be one of:
4641 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4644 /* movl foo, %eax. */
4645 bfd_put_8 (output_bfd, 0xb8,
4646 contents + rel->r_offset - 1);
4652 type = bfd_get_8 (input_bfd,
4653 contents + rel->r_offset - 2);
4658 bfd_put_8 (output_bfd, 0xc7,
4659 contents + rel->r_offset - 2);
4660 bfd_put_8 (output_bfd,
4661 0xc0 | ((val >> 3) & 7),
4662 contents + rel->r_offset - 1);
4666 bfd_put_8 (output_bfd, 0x81,
4667 contents + rel->r_offset - 2);
4668 bfd_put_8 (output_bfd,
4669 0xc0 | ((val >> 3) & 7),
4670 contents + rel->r_offset - 1);
4677 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
4678 contents + rel->r_offset);
4683 unsigned int val, type;
4685 /* {IE_32,GOTIE}->LE transition:
4686 Originally it can be one of:
4687 subl foo(%reg1), %reg2
4688 movl foo(%reg1), %reg2
4689 addl foo(%reg1), %reg2
4692 movl $foo, %reg2 (6 byte form)
4693 addl $foo, %reg2. */
4694 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
4695 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4699 bfd_put_8 (output_bfd, 0xc7,
4700 contents + rel->r_offset - 2);
4701 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4702 contents + rel->r_offset - 1);
4704 else if (type == 0x2b)
4707 bfd_put_8 (output_bfd, 0x81,
4708 contents + rel->r_offset - 2);
4709 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
4710 contents + rel->r_offset - 1);
4712 else if (type == 0x03)
4715 bfd_put_8 (output_bfd, 0x81,
4716 contents + rel->r_offset - 2);
4717 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4718 contents + rel->r_offset - 1);
4722 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
4723 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
4724 contents + rel->r_offset);
4726 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
4727 contents + rel->r_offset);
4732 if (htab->elf.sgot == NULL)
4737 off = h->got.offset;
4738 offplt = elf_i386_hash_entry (h)->tlsdesc_got;
4742 if (local_got_offsets == NULL)
4745 off = local_got_offsets[r_symndx];
4746 offplt = local_tlsdesc_gotents[r_symndx];
4753 Elf_Internal_Rela outrel;
4757 if (htab->elf.srelgot == NULL)
4760 indx = h && h->dynindx != -1 ? h->dynindx : 0;
4762 if (GOT_TLS_GDESC_P (tls_type))
4765 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
4766 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
4767 <= htab->elf.sgotplt->size);
4768 outrel.r_offset = (htab->elf.sgotplt->output_section->vma
4769 + htab->elf.sgotplt->output_offset
4771 + htab->sgotplt_jump_table_size);
4772 sreloc = htab->elf.srelplt;
4773 loc = sreloc->contents;
4774 loc += (htab->next_tls_desc_index++
4775 * sizeof (Elf32_External_Rel));
4776 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
4777 <= sreloc->contents + sreloc->size);
4778 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4781 BFD_ASSERT (! unresolved_reloc);
4782 bfd_put_32 (output_bfd,
4783 relocation - elf_i386_dtpoff_base (info),
4784 htab->elf.sgotplt->contents + offplt
4785 + htab->sgotplt_jump_table_size + 4);
4789 bfd_put_32 (output_bfd, 0,
4790 htab->elf.sgotplt->contents + offplt
4791 + htab->sgotplt_jump_table_size + 4);
4795 sreloc = htab->elf.srelgot;
4797 outrel.r_offset = (htab->elf.sgot->output_section->vma
4798 + htab->elf.sgot->output_offset + off);
4800 if (GOT_TLS_GD_P (tls_type))
4801 dr_type = R_386_TLS_DTPMOD32;
4802 else if (GOT_TLS_GDESC_P (tls_type))
4804 else if (tls_type == GOT_TLS_IE_POS)
4805 dr_type = R_386_TLS_TPOFF;
4807 dr_type = R_386_TLS_TPOFF32;
4809 if (dr_type == R_386_TLS_TPOFF && indx == 0)
4810 bfd_put_32 (output_bfd,
4811 relocation - elf_i386_dtpoff_base (info),
4812 htab->elf.sgot->contents + off);
4813 else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
4814 bfd_put_32 (output_bfd,
4815 elf_i386_dtpoff_base (info) - relocation,
4816 htab->elf.sgot->contents + off);
4817 else if (dr_type != R_386_TLS_DESC)
4818 bfd_put_32 (output_bfd, 0,
4819 htab->elf.sgot->contents + off);
4820 outrel.r_info = ELF32_R_INFO (indx, dr_type);
4822 elf_append_rel (output_bfd, sreloc, &outrel);
4824 if (GOT_TLS_GD_P (tls_type))
4828 BFD_ASSERT (! unresolved_reloc);
4829 bfd_put_32 (output_bfd,
4830 relocation - elf_i386_dtpoff_base (info),
4831 htab->elf.sgot->contents + off + 4);
4835 bfd_put_32 (output_bfd, 0,
4836 htab->elf.sgot->contents + off + 4);
4837 outrel.r_info = ELF32_R_INFO (indx,
4838 R_386_TLS_DTPOFF32);
4839 outrel.r_offset += 4;
4840 elf_append_rel (output_bfd, sreloc, &outrel);
4843 else if (tls_type == GOT_TLS_IE_BOTH)
4845 bfd_put_32 (output_bfd,
4847 ? relocation - elf_i386_dtpoff_base (info)
4849 htab->elf.sgot->contents + off + 4);
4850 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4851 outrel.r_offset += 4;
4852 elf_append_rel (output_bfd, sreloc, &outrel);
4859 local_got_offsets[r_symndx] |= 1;
4862 if (off >= (bfd_vma) -2
4863 && ! GOT_TLS_GDESC_P (tls_type))
4865 if (r_type == R_386_TLS_GOTDESC
4866 || r_type == R_386_TLS_DESC_CALL)
4868 relocation = htab->sgotplt_jump_table_size + offplt;
4869 unresolved_reloc = FALSE;
4871 else if (r_type == ELF32_R_TYPE (rel->r_info))
4873 bfd_vma g_o_t = htab->elf.sgotplt->output_section->vma
4874 + htab->elf.sgotplt->output_offset;
4875 relocation = htab->elf.sgot->output_section->vma
4876 + htab->elf.sgot->output_offset + off - g_o_t;
4877 if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
4878 && tls_type == GOT_TLS_IE_BOTH)
4880 if (r_type == R_386_TLS_IE)
4881 relocation += g_o_t;
4882 unresolved_reloc = FALSE;
4884 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
4886 unsigned int val, type;
4889 /* GD->IE transition. */
4890 type = *(contents + rel->r_offset - 2);
4891 val = *(contents + rel->r_offset - 1);
4895 leal foo@tlsgd(,%ebx,1), %eax
4896 call ___tls_get_addr@PLT
4899 subl $foo@gottpoff(%ebx), %eax. */
4901 roff = rel->r_offset - 3;
4906 leal foo@tlsgd(%ebx), %eax
4907 call ___tls_get_addr@PLT
4910 leal foo@tlsgd(%reg), %eax
4911 call *___tls_get_addr@GOT(%reg)
4912 which may be converted to
4913 addr32 call ___tls_get_addr
4916 subl $foo@gottpoff(%reg), %eax. */
4917 roff = rel->r_offset - 2;
4919 memcpy (contents + roff,
4920 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
4921 contents[roff + 7] = 0x80 | (val & 7);
4922 /* If foo is used only with foo@gotntpoff(%reg) and
4923 foo@indntpoff, but not with foo@gottpoff(%reg), change
4924 subl $foo@gottpoff(%reg), %eax
4926 addl $foo@gotntpoff(%reg), %eax. */
4927 if (tls_type == GOT_TLS_IE_POS)
4928 contents[roff + 6] = 0x03;
4929 bfd_put_32 (output_bfd,
4930 htab->elf.sgot->output_section->vma
4931 + htab->elf.sgot->output_offset + off
4932 - htab->elf.sgotplt->output_section->vma
4933 - htab->elf.sgotplt->output_offset,
4934 contents + roff + 8);
4935 /* Skip R_386_PLT32 and R_386_GOT32X. */
4940 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4942 /* GDesc -> IE transition.
4943 It's originally something like:
4944 leal x@tlsdesc(%ebx), %eax
4947 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
4949 movl x@gottpoff(%ebx), %eax # before negl %eax
4951 Registers other than %eax may be set up here. */
4955 /* First, make sure it's a leal adding ebx to a 32-bit
4956 offset into any register, although it's probably
4957 almost always going to be eax. */
4958 roff = rel->r_offset;
4960 /* Now modify the instruction as appropriate. */
4961 /* To turn a leal into a movl in the form we use it, it
4962 suffices to change the first byte from 0x8d to 0x8b.
4963 aoliva FIXME: should we decide to keep the leal, all
4964 we have to do is remove the statement below, and
4965 adjust the relaxation of R_386_TLS_DESC_CALL. */
4966 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4968 if (tls_type == GOT_TLS_IE_BOTH)
4971 bfd_put_32 (output_bfd,
4972 htab->elf.sgot->output_section->vma
4973 + htab->elf.sgot->output_offset + off
4974 - htab->elf.sgotplt->output_section->vma
4975 - htab->elf.sgotplt->output_offset,
4979 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4981 /* GDesc -> IE transition.
4989 depending on how we transformed the TLS_GOTDESC above.
4994 roff = rel->r_offset;
4996 /* Now modify the instruction as appropriate. */
4997 if (tls_type != GOT_TLS_IE_NEG)
5000 bfd_put_8 (output_bfd, 0x66, contents + roff);
5001 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
5006 bfd_put_8 (output_bfd, 0xf7, contents + roff);
5007 bfd_put_8 (output_bfd, 0xd8, contents + roff + 1);
5017 if (! elf_i386_tls_transition (info, input_bfd,
5018 input_section, contents,
5019 symtab_hdr, sym_hashes,
5020 &r_type, GOT_UNKNOWN, rel,
5021 relend, h, r_symndx, TRUE))
5024 if (r_type != R_386_TLS_LDM)
5026 /* LD->LE transition. Change
5027 leal foo@tlsldm(%ebx) %eax
5028 call ___tls_get_addr@PLT
5032 leal 0(%esi,1), %esi
5034 leal foo@tlsldm(%reg) %eax
5035 call *___tls_get_addr@GOT(%reg)
5036 which may be converted to
5037 addr32 call ___tls_get_addr
5040 leal 0(%esi), %esi */
5041 BFD_ASSERT (r_type == R_386_TLS_LE_32);
5042 if (*(contents + rel->r_offset + 4) == 0xff
5043 || *(contents + rel->r_offset + 4) == 0x67)
5044 memcpy (contents + rel->r_offset - 2,
5045 "\x65\xa1\0\0\0\0\x8d\xb6\0\0\0", 12);
5047 memcpy (contents + rel->r_offset - 2,
5048 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
5049 /* Skip R_386_PC32/R_386_PLT32. */
5055 if (htab->elf.sgot == NULL)
5058 off = htab->tls_ldm_got.offset;
5063 Elf_Internal_Rela outrel;
5065 if (htab->elf.srelgot == NULL)
5068 outrel.r_offset = (htab->elf.sgot->output_section->vma
5069 + htab->elf.sgot->output_offset + off);
5071 bfd_put_32 (output_bfd, 0,
5072 htab->elf.sgot->contents + off);
5073 bfd_put_32 (output_bfd, 0,
5074 htab->elf.sgot->contents + off + 4);
5075 outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
5076 elf_append_rel (output_bfd, htab->elf.srelgot, &outrel);
5077 htab->tls_ldm_got.offset |= 1;
5079 relocation = htab->elf.sgot->output_section->vma
5080 + htab->elf.sgot->output_offset + off
5081 - htab->elf.sgotplt->output_section->vma
5082 - htab->elf.sgotplt->output_offset;
5083 unresolved_reloc = FALSE;
5086 case R_386_TLS_LDO_32:
5087 if (!bfd_link_executable (info)
5088 || (input_section->flags & SEC_CODE) == 0)
5089 relocation -= elf_i386_dtpoff_base (info);
5091 /* When converting LDO to LE, we must negate. */
5092 relocation = -elf_i386_tpoff (info, relocation);
5095 case R_386_TLS_LE_32:
5097 if (!bfd_link_executable (info))
5099 Elf_Internal_Rela outrel;
5102 outrel.r_offset = rel->r_offset
5103 + input_section->output_section->vma
5104 + input_section->output_offset;
5105 if (h != NULL && h->dynindx != -1)
5109 if (r_type == R_386_TLS_LE_32)
5110 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
5112 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
5113 sreloc = elf_section_data (input_section)->sreloc;
5116 elf_append_rel (output_bfd, sreloc, &outrel);
5119 else if (r_type == R_386_TLS_LE_32)
5120 relocation = elf_i386_dtpoff_base (info) - relocation;
5122 relocation -= elf_i386_dtpoff_base (info);
5124 else if (r_type == R_386_TLS_LE_32)
5125 relocation = elf_i386_tpoff (info, relocation);
5127 relocation = -elf_i386_tpoff (info, relocation);
5134 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5135 because such sections are not SEC_ALLOC and thus ld.so will
5136 not process them. */
5137 if (unresolved_reloc
5138 && !((input_section->flags & SEC_DEBUGGING) != 0
5140 && _bfd_elf_section_offset (output_bfd, info, input_section,
5141 rel->r_offset) != (bfd_vma) -1)
5144 /* xgettext:c-format */
5145 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5148 (long) rel->r_offset,
5150 h->root.root.string);
5155 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5156 contents, rel->r_offset,
5159 check_relocation_error:
5160 if (r != bfd_reloc_ok)
5165 name = h->root.root.string;
5168 name = bfd_elf_string_from_elf_section (input_bfd,
5169 symtab_hdr->sh_link,
5174 name = bfd_section_name (input_bfd, sec);
5177 if (r == bfd_reloc_overflow)
5178 (*info->callbacks->reloc_overflow)
5179 (info, (h ? &h->root : NULL), name, howto->name,
5180 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
5184 /* xgettext:c-format */
5185 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5186 input_bfd, input_section,
5187 (long) rel->r_offset, name, (int) r);
5198 Elf_Internal_Shdr *rel_hdr;
5199 size_t deleted = rel - wrel;
5201 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
5202 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
5203 if (rel_hdr->sh_size == 0)
5205 /* It is too late to remove an empty reloc section. Leave
5207 ??? What is wrong with an empty section??? */
5208 rel_hdr->sh_size = rel_hdr->sh_entsize;
5211 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
5212 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
5213 input_section->reloc_count -= deleted;
5219 /* Finish up dynamic symbol handling. We set the contents of various
5220 dynamic sections here. */
5223 elf_i386_finish_dynamic_symbol (bfd *output_bfd,
5224 struct bfd_link_info *info,
5225 struct elf_link_hash_entry *h,
5226 Elf_Internal_Sym *sym)
5228 struct elf_i386_link_hash_table *htab;
5229 unsigned plt_entry_size;
5230 const struct elf_i386_backend_data *abed;
5231 struct elf_i386_link_hash_entry *eh;
5232 bfd_boolean local_undefweak;
5234 htab = elf_i386_hash_table (info);
5238 abed = get_elf_i386_backend_data (output_bfd);
5239 plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
5241 eh = (struct elf_i386_link_hash_entry *) h;
5243 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5244 resolved undefined weak symbols in executable so that their
5245 references have value 0 at run-time. */
5246 local_undefweak = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
5250 if (h->plt.offset != (bfd_vma) -1)
5254 Elf_Internal_Rela rel;
5256 asection *plt, *gotplt, *relplt;
5258 /* When building a static executable, use .iplt, .igot.plt and
5259 .rel.iplt sections for STT_GNU_IFUNC symbols. */
5260 if (htab->elf.splt != NULL)
5262 plt = htab->elf.splt;
5263 gotplt = htab->elf.sgotplt;
5264 relplt = htab->elf.srelplt;
5268 plt = htab->elf.iplt;
5269 gotplt = htab->elf.igotplt;
5270 relplt = htab->elf.irelplt;
5273 /* This symbol has an entry in the procedure linkage table. Set
5276 if ((h->dynindx == -1
5278 && !((h->forced_local || bfd_link_executable (info))
5280 && h->type == STT_GNU_IFUNC))
5286 /* Get the index in the procedure linkage table which
5287 corresponds to this symbol. This is the index of this symbol
5288 in all the symbols for which we are making plt entries. The
5289 first entry in the procedure linkage table is reserved.
5291 Get the offset into the .got table of the entry that
5292 corresponds to this function. Each .got entry is 4 bytes.
5293 The first three are reserved.
5295 For static executables, we don't reserve anything. */
5297 if (plt == htab->elf.splt)
5299 got_offset = h->plt.offset / plt_entry_size - 1;
5300 got_offset = (got_offset + 3) * 4;
5304 got_offset = h->plt.offset / plt_entry_size;
5305 got_offset = got_offset * 4;
5308 /* Fill in the entry in the procedure linkage table. */
5309 if (! bfd_link_pic (info))
5311 memcpy (plt->contents + h->plt.offset, abed->plt->plt_entry,
5312 abed->plt->plt_entry_size);
5313 bfd_put_32 (output_bfd,
5314 (gotplt->output_section->vma
5315 + gotplt->output_offset
5317 plt->contents + h->plt.offset
5318 + abed->plt->plt_got_offset);
5320 if (abed->is_vxworks)
5322 int s, k, reloc_index;
5324 /* Create the R_386_32 relocation referencing the GOT
5325 for this PLT entry. */
5327 /* S: Current slot number (zero-based). */
5328 s = ((h->plt.offset - abed->plt->plt_entry_size)
5329 / abed->plt->plt_entry_size);
5330 /* K: Number of relocations for PLTResolve. */
5331 if (bfd_link_pic (info))
5332 k = PLTRESOLVE_RELOCS_SHLIB;
5334 k = PLTRESOLVE_RELOCS;
5335 /* Skip the PLTresolve relocations, and the relocations for
5336 the other PLT slots. */
5337 reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
5338 loc = (htab->srelplt2->contents + reloc_index
5339 * sizeof (Elf32_External_Rel));
5341 rel.r_offset = (htab->elf.splt->output_section->vma
5342 + htab->elf.splt->output_offset
5343 + h->plt.offset + 2),
5344 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
5345 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5347 /* Create the R_386_32 relocation referencing the beginning of
5348 the PLT for this GOT entry. */
5349 rel.r_offset = (htab->elf.sgotplt->output_section->vma
5350 + htab->elf.sgotplt->output_offset
5352 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
5353 bfd_elf32_swap_reloc_out (output_bfd, &rel,
5354 loc + sizeof (Elf32_External_Rel));
5359 memcpy (plt->contents + h->plt.offset, abed->plt->pic_plt_entry,
5360 abed->plt->plt_entry_size);
5361 bfd_put_32 (output_bfd, got_offset,
5362 plt->contents + h->plt.offset
5363 + abed->plt->plt_got_offset);
5366 /* Fill in the entry in the global offset table. Leave the entry
5367 as zero for undefined weak symbol in PIE. No PLT relocation
5368 against undefined weak symbol in PIE. */
5369 if (!local_undefweak)
5371 bfd_put_32 (output_bfd,
5372 (plt->output_section->vma
5373 + plt->output_offset
5375 + abed->plt->plt_lazy_offset),
5376 gotplt->contents + got_offset);
5378 /* Fill in the entry in the .rel.plt section. */
5379 rel.r_offset = (gotplt->output_section->vma
5380 + gotplt->output_offset
5382 if (h->dynindx == -1
5383 || ((bfd_link_executable (info)
5384 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
5386 && h->type == STT_GNU_IFUNC))
5388 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5389 R_386_IRELATIVE instead of R_386_JUMP_SLOT. Store addend
5390 in the .got.plt section. */
5391 bfd_put_32 (output_bfd,
5392 (h->root.u.def.value
5393 + h->root.u.def.section->output_section->vma
5394 + h->root.u.def.section->output_offset),
5395 gotplt->contents + got_offset);
5396 rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
5397 /* R_386_IRELATIVE comes last. */
5398 plt_index = htab->next_irelative_index--;
5402 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
5403 plt_index = htab->next_jump_slot_index++;
5406 loc = relplt->contents + plt_index * sizeof (Elf32_External_Rel);
5407 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5409 /* Don't fill PLT entry for static executables. */
5410 if (plt == htab->elf.splt)
5412 bfd_put_32 (output_bfd,
5413 plt_index * sizeof (Elf32_External_Rel),
5414 plt->contents + h->plt.offset
5415 + abed->plt->plt_reloc_offset);
5416 bfd_put_32 (output_bfd, - (h->plt.offset
5417 + abed->plt->plt_plt_offset + 4),
5418 plt->contents + h->plt.offset
5419 + abed->plt->plt_plt_offset);
5423 else if (eh->plt_got.offset != (bfd_vma) -1)
5425 bfd_vma got_offset, plt_offset;
5426 asection *plt, *got, *gotplt;
5427 const bfd_byte *got_plt_entry;
5429 /* Offset of displacement of the indirect jump. */
5430 bfd_vma plt_got_offset = 2;
5432 /* Set the entry in the GOT procedure linkage table. */
5433 plt = htab->plt_got;
5434 got = htab->elf.sgot;
5435 gotplt = htab->elf.sgotplt;
5436 got_offset = h->got.offset;
5438 if (got_offset == (bfd_vma) -1
5444 /* Fill in the entry in the GOT procedure linkage table. */
5445 if (! bfd_link_pic (info))
5447 got_plt_entry = elf_i386_got_plt_entry;
5448 got_offset += got->output_section->vma + got->output_offset;
5452 got_plt_entry = elf_i386_pic_got_plt_entry;
5453 got_offset += (got->output_section->vma
5454 + got->output_offset
5455 - gotplt->output_section->vma
5456 - gotplt->output_offset);
5459 plt_offset = eh->plt_got.offset;
5460 memcpy (plt->contents + plt_offset, got_plt_entry,
5461 sizeof (elf_i386_got_plt_entry));
5462 bfd_put_32 (output_bfd, got_offset,
5463 plt->contents + plt_offset + plt_got_offset);
5466 if (!local_undefweak
5468 && (h->plt.offset != (bfd_vma) -1
5469 || eh->plt_got.offset != (bfd_vma) -1))
5471 /* Mark the symbol as undefined, rather than as defined in
5472 the .plt section. Leave the value if there were any
5473 relocations where pointer equality matters (this is a clue
5474 for the dynamic linker, to make function pointer
5475 comparisons work between an application and shared
5476 library), otherwise set it to zero. If a function is only
5477 called from a binary, there is no need to slow down
5478 shared libraries because of that. */
5479 sym->st_shndx = SHN_UNDEF;
5480 if (!h->pointer_equality_needed)
5484 /* Don't generate dynamic GOT relocation against undefined weak
5485 symbol in executable. */
5486 if (h->got.offset != (bfd_vma) -1
5487 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h)->tls_type)
5488 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0
5489 && !local_undefweak)
5491 Elf_Internal_Rela rel;
5492 asection *relgot = htab->elf.srelgot;
5494 /* This symbol has an entry in the global offset table. Set it
5497 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
5500 rel.r_offset = (htab->elf.sgot->output_section->vma
5501 + htab->elf.sgot->output_offset
5502 + (h->got.offset & ~(bfd_vma) 1));
5504 /* If this is a static link, or it is a -Bsymbolic link and the
5505 symbol is defined locally or was forced to be local because
5506 of a version file, we just want to emit a RELATIVE reloc.
5507 The entry in the global offset table will already have been
5508 initialized in the relocate_section function. */
5510 && h->type == STT_GNU_IFUNC)
5512 if (h->plt.offset == (bfd_vma) -1)
5514 /* STT_GNU_IFUNC is referenced without PLT. */
5515 if (htab->elf.splt == NULL)
5517 /* use .rel[a].iplt section to store .got relocations
5518 in static executable. */
5519 relgot = htab->elf.irelplt;
5521 if (SYMBOL_REFERENCES_LOCAL (info, h))
5523 bfd_put_32 (output_bfd,
5524 (h->root.u.def.value
5525 + h->root.u.def.section->output_section->vma
5526 + h->root.u.def.section->output_offset),
5527 htab->elf.sgot->contents + h->got.offset);
5528 rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
5533 else if (bfd_link_pic (info))
5535 /* Generate R_386_GLOB_DAT. */
5542 if (!h->pointer_equality_needed)
5545 /* For non-shared object, we can't use .got.plt, which
5546 contains the real function addres if we need pointer
5547 equality. We load the GOT entry with the PLT entry. */
5548 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
5549 bfd_put_32 (output_bfd,
5550 (plt->output_section->vma
5551 + plt->output_offset + h->plt.offset),
5552 htab->elf.sgot->contents + h->got.offset);
5556 else if (bfd_link_pic (info)
5557 && SYMBOL_REFERENCES_LOCAL (info, h))
5559 BFD_ASSERT((h->got.offset & 1) != 0);
5560 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
5564 BFD_ASSERT((h->got.offset & 1) == 0);
5566 bfd_put_32 (output_bfd, (bfd_vma) 0,
5567 htab->elf.sgot->contents + h->got.offset);
5568 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
5571 elf_append_rel (output_bfd, relgot, &rel);
5576 Elf_Internal_Rela rel;
5579 /* This symbol needs a copy reloc. Set it up. */
5581 if (h->dynindx == -1
5582 || (h->root.type != bfd_link_hash_defined
5583 && h->root.type != bfd_link_hash_defweak)
5584 || htab->elf.srelbss == NULL
5585 || htab->elf.sreldynrelro == NULL)
5588 rel.r_offset = (h->root.u.def.value
5589 + h->root.u.def.section->output_section->vma
5590 + h->root.u.def.section->output_offset);
5591 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
5592 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
5593 s = htab->elf.sreldynrelro;
5595 s = htab->elf.srelbss;
5596 elf_append_rel (output_bfd, s, &rel);
5602 /* Finish up local dynamic symbol handling. We set the contents of
5603 various dynamic sections here. */
5606 elf_i386_finish_local_dynamic_symbol (void **slot, void *inf)
5608 struct elf_link_hash_entry *h
5609 = (struct elf_link_hash_entry *) *slot;
5610 struct bfd_link_info *info
5611 = (struct bfd_link_info *) inf;
5613 return elf_i386_finish_dynamic_symbol (info->output_bfd, info,
5617 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5618 here since undefined weak symbol may not be dynamic and may not be
5619 called for elf_i386_finish_dynamic_symbol. */
5622 elf_i386_pie_finish_undefweak_symbol (struct bfd_hash_entry *bh,
5625 struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
5626 struct bfd_link_info *info = (struct bfd_link_info *) inf;
5628 if (h->root.type != bfd_link_hash_undefweak
5629 || h->dynindx != -1)
5632 return elf_i386_finish_dynamic_symbol (info->output_bfd,
5636 /* Used to decide how to sort relocs in an optimal manner for the
5637 dynamic linker, before writing them out. */
5639 static enum elf_reloc_type_class
5640 elf_i386_reloc_type_class (const struct bfd_link_info *info,
5641 const asection *rel_sec ATTRIBUTE_UNUSED,
5642 const Elf_Internal_Rela *rela)
5644 bfd *abfd = info->output_bfd;
5645 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5646 struct elf_link_hash_table *htab = elf_hash_table (info);
5648 if (htab->dynsym != NULL
5649 && htab->dynsym->contents != NULL)
5651 /* Check relocation against STT_GNU_IFUNC symbol if there are
5653 unsigned long r_symndx = ELF32_R_SYM (rela->r_info);
5654 if (r_symndx != STN_UNDEF)
5656 Elf_Internal_Sym sym;
5657 if (!bed->s->swap_symbol_in (abfd,
5658 (htab->dynsym->contents
5659 + r_symndx * sizeof (Elf32_External_Sym)),
5663 if (ELF32_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
5664 return reloc_class_ifunc;
5668 switch (ELF32_R_TYPE (rela->r_info))
5670 case R_386_IRELATIVE:
5671 return reloc_class_ifunc;
5672 case R_386_RELATIVE:
5673 return reloc_class_relative;
5674 case R_386_JUMP_SLOT:
5675 return reloc_class_plt;
5677 return reloc_class_copy;
5679 return reloc_class_normal;
5683 /* Finish up the dynamic sections. */
5686 elf_i386_finish_dynamic_sections (bfd *output_bfd,
5687 struct bfd_link_info *info)
5689 struct elf_i386_link_hash_table *htab;
5692 const struct elf_i386_backend_data *abed;
5694 htab = elf_i386_hash_table (info);
5698 dynobj = htab->elf.dynobj;
5699 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
5700 abed = get_elf_i386_backend_data (output_bfd);
5702 if (htab->elf.dynamic_sections_created)
5704 Elf32_External_Dyn *dyncon, *dynconend;
5706 if (sdyn == NULL || htab->elf.sgot == NULL)
5709 dyncon = (Elf32_External_Dyn *) sdyn->contents;
5710 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5711 for (; dyncon < dynconend; dyncon++)
5713 Elf_Internal_Dyn dyn;
5716 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5721 if (abed->is_vxworks
5722 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
5727 s = htab->elf.sgotplt;
5728 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5732 s = htab->elf.srelplt;
5733 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5737 s = htab->elf.srelplt;
5738 dyn.d_un.d_val = s->size;
5742 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5745 /* Fill in the first entry in the procedure linkage table. */
5746 if (htab->elf.splt && htab->elf.splt->size > 0)
5748 if (bfd_link_pic (info))
5750 memcpy (htab->elf.splt->contents, abed->plt->pic_plt0_entry,
5751 abed->plt->plt0_entry_size);
5752 memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
5753 abed->plt0_pad_byte,
5754 abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
5758 memcpy (htab->elf.splt->contents, abed->plt->plt0_entry,
5759 abed->plt->plt0_entry_size);
5760 memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
5761 abed->plt0_pad_byte,
5762 abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
5763 bfd_put_32 (output_bfd,
5764 (htab->elf.sgotplt->output_section->vma
5765 + htab->elf.sgotplt->output_offset
5767 htab->elf.splt->contents
5768 + abed->plt->plt0_got1_offset);
5769 bfd_put_32 (output_bfd,
5770 (htab->elf.sgotplt->output_section->vma
5771 + htab->elf.sgotplt->output_offset
5773 htab->elf.splt->contents
5774 + abed->plt->plt0_got2_offset);
5776 if (abed->is_vxworks)
5778 Elf_Internal_Rela rel;
5780 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
5781 On IA32 we use REL relocations so the addend goes in
5782 the PLT directly. */
5783 rel.r_offset = (htab->elf.splt->output_section->vma
5784 + htab->elf.splt->output_offset
5785 + abed->plt->plt0_got1_offset);
5786 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
5787 bfd_elf32_swap_reloc_out (output_bfd, &rel,
5788 htab->srelplt2->contents);
5789 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
5790 rel.r_offset = (htab->elf.splt->output_section->vma
5791 + htab->elf.splt->output_offset
5792 + abed->plt->plt0_got2_offset);
5793 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
5794 bfd_elf32_swap_reloc_out (output_bfd, &rel,
5795 htab->srelplt2->contents +
5796 sizeof (Elf32_External_Rel));
5800 /* UnixWare sets the entsize of .plt to 4, although that doesn't
5801 really seem like the right value. */
5802 elf_section_data (htab->elf.splt->output_section)
5803 ->this_hdr.sh_entsize = 4;
5805 /* Correct the .rel.plt.unloaded relocations. */
5806 if (abed->is_vxworks && !bfd_link_pic (info))
5808 int num_plts = (htab->elf.splt->size
5809 / abed->plt->plt_entry_size) - 1;
5812 p = htab->srelplt2->contents;
5813 if (bfd_link_pic (info))
5814 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
5816 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
5818 for (; num_plts; num_plts--)
5820 Elf_Internal_Rela rel;
5821 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
5822 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
5823 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
5824 p += sizeof (Elf32_External_Rel);
5826 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
5827 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
5828 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
5829 p += sizeof (Elf32_External_Rel);
5835 if (htab->elf.sgotplt)
5837 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
5840 (_("discarded output section: `%A'"), htab->elf.sgotplt);
5844 /* Fill in the first three entries in the global offset table. */
5845 if (htab->elf.sgotplt->size > 0)
5847 bfd_put_32 (output_bfd,
5849 : sdyn->output_section->vma + sdyn->output_offset),
5850 htab->elf.sgotplt->contents);
5851 bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 4);
5852 bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 8);
5855 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize = 4;
5858 /* Adjust .eh_frame for .plt section. */
5859 if (htab->plt_eh_frame != NULL
5860 && htab->plt_eh_frame->contents != NULL)
5862 if (htab->elf.splt != NULL
5863 && htab->elf.splt->size != 0
5864 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
5865 && htab->elf.splt->output_section != NULL
5866 && htab->plt_eh_frame->output_section != NULL)
5868 bfd_vma plt_start = htab->elf.splt->output_section->vma;
5869 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
5870 + htab->plt_eh_frame->output_offset
5871 + PLT_FDE_START_OFFSET;
5872 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
5873 htab->plt_eh_frame->contents
5874 + PLT_FDE_START_OFFSET);
5876 if (htab->plt_eh_frame->sec_info_type
5877 == SEC_INFO_TYPE_EH_FRAME)
5879 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
5881 htab->plt_eh_frame->contents))
5886 if (htab->elf.sgot && htab->elf.sgot->size > 0)
5887 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 4;
5889 /* Fill PLT entries for undefined weak symbols in PIE. */
5890 if (bfd_link_pie (info))
5891 bfd_hash_traverse (&info->hash->table,
5892 elf_i386_pie_finish_undefweak_symbol,
5898 /* Fill PLT/GOT entries and allocate dynamic relocations for local
5899 STT_GNU_IFUNC symbols, which aren't in the ELF linker hash table.
5900 It has to be done before elf_link_sort_relocs is called so that
5901 dynamic relocations are properly sorted. */
5904 elf_i386_output_arch_local_syms
5905 (bfd *output_bfd ATTRIBUTE_UNUSED,
5906 struct bfd_link_info *info,
5907 void *flaginfo ATTRIBUTE_UNUSED,
5908 int (*func) (void *, const char *,
5911 struct elf_link_hash_entry *) ATTRIBUTE_UNUSED)
5913 struct elf_i386_link_hash_table *htab = elf_i386_hash_table (info);
5917 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5918 htab_traverse (htab->loc_hash_table,
5919 elf_i386_finish_local_dynamic_symbol,
5925 /* Return an array of PLT entry symbol values. */
5928 elf_i386_get_plt_sym_val (bfd *abfd, asymbol **dynsyms, asection *plt,
5931 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
5934 bfd_vma *plt_sym_val;
5936 bfd_byte *plt_contents;
5937 const struct elf_i386_backend_data *bed
5938 = get_elf_i386_backend_data (abfd);
5939 Elf_Internal_Shdr *hdr;
5941 /* Get the .plt section contents. */
5942 plt_contents = (bfd_byte *) bfd_malloc (plt->size);
5943 if (plt_contents == NULL)
5945 if (!bfd_get_section_contents (abfd, (asection *) plt,
5946 plt_contents, 0, plt->size))
5949 free (plt_contents);
5953 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
5954 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
5957 hdr = &elf_section_data (relplt)->this_hdr;
5958 count = relplt->size / hdr->sh_entsize;
5960 plt_sym_val = (bfd_vma *) bfd_malloc (sizeof (bfd_vma) * count);
5961 if (plt_sym_val == NULL)
5964 for (i = 0; i < count; i++)
5965 plt_sym_val[i] = -1;
5967 plt_offset = bed->plt->plt_entry_size;
5968 p = relplt->relocation;
5969 for (i = 0; i < count; i++, p++)
5973 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
5974 if (p->howto == NULL)
5977 if (p->howto->type != R_386_JUMP_SLOT
5978 && p->howto->type != R_386_IRELATIVE)
5981 reloc_index = H_GET_32 (abfd, (plt_contents + plt_offset
5982 + bed->plt->plt_reloc_offset));
5983 reloc_index /= sizeof (Elf32_External_Rel);
5984 if (reloc_index < count)
5985 plt_sym_val[reloc_index] = plt->vma + plt_offset;
5987 plt_offset += bed->plt->plt_entry_size;
5989 /* PR binutils/18437: Skip extra relocations in the .rel.plt
5991 if (plt_offset >= plt->size)
5995 free (plt_contents);
6000 /* Similar to _bfd_elf_get_synthetic_symtab. */
6003 elf_i386_get_synthetic_symtab (bfd *abfd,
6010 asection *plt = bfd_get_section_by_name (abfd, ".plt");
6011 return _bfd_elf_ifunc_get_synthetic_symtab (abfd, symcount, syms,
6012 dynsymcount, dynsyms, ret,
6014 elf_i386_get_plt_sym_val);
6017 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6020 elf_i386_hash_symbol (struct elf_link_hash_entry *h)
6022 if (h->plt.offset != (bfd_vma) -1
6024 && !h->pointer_equality_needed)
6027 return _bfd_elf_hash_symbol (h);
6030 #define TARGET_LITTLE_SYM i386_elf32_vec
6031 #define TARGET_LITTLE_NAME "elf32-i386"
6032 #define ELF_ARCH bfd_arch_i386
6033 #define ELF_TARGET_ID I386_ELF_DATA
6034 #define ELF_MACHINE_CODE EM_386
6035 #define ELF_MAXPAGESIZE 0x1000
6037 #define elf_backend_can_gc_sections 1
6038 #define elf_backend_can_refcount 1
6039 #define elf_backend_want_got_plt 1
6040 #define elf_backend_plt_readonly 1
6041 #define elf_backend_want_plt_sym 0
6042 #define elf_backend_got_header_size 12
6043 #define elf_backend_plt_alignment 4
6044 #define elf_backend_dtrel_excludes_plt 1
6045 #define elf_backend_extern_protected_data 1
6046 #define elf_backend_caches_rawsize 1
6047 #define elf_backend_want_dynrelro 1
6049 /* Support RELA for objdump of prelink objects. */
6050 #define elf_info_to_howto elf_i386_info_to_howto_rel
6051 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
6053 #define bfd_elf32_mkobject elf_i386_mkobject
6055 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
6056 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
6057 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
6058 #define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
6059 #define bfd_elf32_get_synthetic_symtab elf_i386_get_synthetic_symtab
6061 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
6062 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
6063 #define elf_backend_check_relocs elf_i386_check_relocs
6064 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
6065 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
6066 #define elf_backend_fake_sections elf_i386_fake_sections
6067 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
6068 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
6069 #define elf_backend_output_arch_local_syms elf_i386_output_arch_local_syms
6070 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
6071 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
6072 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
6073 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
6074 #define elf_backend_relocate_section elf_i386_relocate_section
6075 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
6076 #define elf_backend_always_size_sections elf_i386_always_size_sections
6077 #define elf_backend_omit_section_dynsym \
6078 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6079 #define elf_backend_hash_symbol elf_i386_hash_symbol
6080 #define elf_backend_fixup_symbol elf_i386_fixup_symbol
6082 #include "elf32-target.h"
6084 /* FreeBSD support. */
6086 #undef TARGET_LITTLE_SYM
6087 #define TARGET_LITTLE_SYM i386_elf32_fbsd_vec
6088 #undef TARGET_LITTLE_NAME
6089 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
6091 #define ELF_OSABI ELFOSABI_FREEBSD
6093 /* The kernel recognizes executables as valid only if they carry a
6094 "FreeBSD" label in the ELF header. So we put this label on all
6095 executables and (for simplicity) also all other object files. */
6098 elf_i386_fbsd_post_process_headers (bfd *abfd, struct bfd_link_info *info)
6100 _bfd_elf_post_process_headers (abfd, info);
6102 #ifdef OLD_FREEBSD_ABI_LABEL
6104 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
6105 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
6106 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
6111 #undef elf_backend_post_process_headers
6112 #define elf_backend_post_process_headers elf_i386_fbsd_post_process_headers
6114 #define elf32_bed elf32_i386_fbsd_bed
6116 #undef elf_backend_add_symbol_hook
6118 #include "elf32-target.h"
6122 #undef TARGET_LITTLE_SYM
6123 #define TARGET_LITTLE_SYM i386_elf32_sol2_vec
6124 #undef TARGET_LITTLE_NAME
6125 #define TARGET_LITTLE_NAME "elf32-i386-sol2"
6127 #undef elf_backend_post_process_headers
6129 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6130 objects won't be recognized. */
6134 #define elf32_bed elf32_i386_sol2_bed
6136 /* The 32-bit static TLS arena size is rounded to the nearest 8-byte
6138 #undef elf_backend_static_tls_alignment
6139 #define elf_backend_static_tls_alignment 8
6141 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6143 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6145 #undef elf_backend_want_plt_sym
6146 #define elf_backend_want_plt_sym 1
6148 #undef elf_backend_strtab_flags
6149 #define elf_backend_strtab_flags SHF_STRINGS
6151 /* Called to set the sh_flags, sh_link and sh_info fields of OSECTION which
6152 has a type >= SHT_LOOS. Returns TRUE if these fields were initialised
6153 FALSE otherwise. ISECTION is the best guess matching section from the
6154 input bfd IBFD, but it might be NULL. */
6157 elf32_i386_copy_solaris_special_section_fields (const bfd *ibfd ATTRIBUTE_UNUSED,
6158 bfd *obfd ATTRIBUTE_UNUSED,
6159 const Elf_Internal_Shdr *isection ATTRIBUTE_UNUSED,
6160 Elf_Internal_Shdr *osection ATTRIBUTE_UNUSED)
6162 /* PR 19938: FIXME: Need to add code for setting the sh_info
6163 and sh_link fields of Solaris specific section types. */
6166 /* Based upon Oracle Solaris 11.3 Linkers and Libraries Guide, Ch. 13,
6167 Object File Format, Table 13-9 ELF sh_link and sh_info Interpretation:
6169 http://docs.oracle.com/cd/E53394_01/html/E54813/chapter6-94076.html#scrolltoc
6171 The following values should be set:
6174 -----------------------------------------------------------------------------
6175 SHT_SUNW_ancillary The section header index of 0
6176 [0x6fffffee] the associated string table.
6178 SHT_SUNW_capinfo The section header index of For a dynamic object, the
6179 [0x6ffffff0] the associated symbol table. section header index of
6181 SHT_SUNW_capchain table,
6184 SHT_SUNW_symsort The section header index of 0
6185 [0x6ffffff1] the associated symbol table.
6187 SHT_SUNW_tlssort The section header index of 0
6188 [0x6ffffff2] the associated symbol table.
6190 SHT_SUNW_LDYNSYM The section header index of One greater than the
6191 [0x6ffffff3] the associated string table. symbol table index of the
6192 This index is the same string last local symbol,
6193 table used by the SHT_DYNSYM STB_LOCAL. Since
6194 section. SHT_SUNW_LDYNSYM only
6195 contains local symbols,
6196 sh_info is equivalent to
6197 the number of symbols in
6200 SHT_SUNW_cap If symbol capabilities exist, If any capabilities refer
6201 [0x6ffffff5] the section header index of to named strings, the
6202 the associated section header index of
6203 SHT_SUNW_capinfo table, the associated string
6204 otherwise 0. table, otherwise 0.
6206 SHT_SUNW_move The section header index of 0
6207 [0x6ffffffa] the associated symbol table.
6212 SHT_SUNW_syminfo The section header index of The section header index
6213 [0x6ffffffc] the associated symbol table. of the associated
6216 SHT_SUNW_verdef The section header index of The number of version
6217 [0x6ffffffd] the associated string table. definitions within the
6220 SHT_SUNW_verneed The section header index of The number of version
6221 [0x6ffffffe] the associated string table. dependencies within the
6224 SHT_SUNW_versym The section header index of 0
6225 [0x6fffffff] the associated symbol table. */
6228 #undef elf_backend_copy_special_section_fields
6229 #define elf_backend_copy_special_section_fields elf32_i386_copy_solaris_special_section_fields
6231 #include "elf32-target.h"
6233 /* Intel MCU support. */
6236 elf32_iamcu_elf_object_p (bfd *abfd)
6238 /* Set the right machine number for an IAMCU elf32 file. */
6239 bfd_default_set_arch_mach (abfd, bfd_arch_iamcu, bfd_mach_i386_iamcu);
6243 #undef TARGET_LITTLE_SYM
6244 #define TARGET_LITTLE_SYM iamcu_elf32_vec
6245 #undef TARGET_LITTLE_NAME
6246 #define TARGET_LITTLE_NAME "elf32-iamcu"
6248 #define ELF_ARCH bfd_arch_iamcu
6250 #undef ELF_MACHINE_CODE
6251 #define ELF_MACHINE_CODE EM_IAMCU
6256 #define elf32_bed elf32_iamcu_bed
6258 #undef elf_backend_object_p
6259 #define elf_backend_object_p elf32_iamcu_elf_object_p
6261 #undef elf_backend_static_tls_alignment
6263 #undef elf_backend_want_plt_sym
6264 #define elf_backend_want_plt_sym 0
6266 #undef elf_backend_strtab_flags
6267 #undef elf_backend_copy_special_section_fields
6269 #include "elf32-target.h"
6271 /* Restore defaults. */
6273 #define ELF_ARCH bfd_arch_i386
6274 #undef ELF_MACHINE_CODE
6275 #define ELF_MACHINE_CODE EM_386
6277 /* Native Client support. */
6279 #undef TARGET_LITTLE_SYM
6280 #define TARGET_LITTLE_SYM i386_elf32_nacl_vec
6281 #undef TARGET_LITTLE_NAME
6282 #define TARGET_LITTLE_NAME "elf32-i386-nacl"
6284 #define elf32_bed elf32_i386_nacl_bed
6286 #undef ELF_MAXPAGESIZE
6287 #define ELF_MAXPAGESIZE 0x10000
6289 /* Restore defaults. */
6291 #undef elf_backend_want_plt_sym
6292 #define elf_backend_want_plt_sym 0
6293 #undef elf_backend_post_process_headers
6294 #undef elf_backend_static_tls_alignment
6296 /* NaCl uses substantially different PLT entries for the same effects. */
6298 #undef elf_backend_plt_alignment
6299 #define elf_backend_plt_alignment 5
6300 #define NACL_PLT_ENTRY_SIZE 64
6301 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6303 static const bfd_byte elf_i386_nacl_plt0_entry[] =
6305 0xff, 0x35, /* pushl contents of address */
6306 0, 0, 0, 0, /* replaced with address of .got + 4. */
6307 0x8b, 0x0d, /* movl contents of address, %ecx */
6308 0, 0, 0, 0, /* replaced with address of .got + 8. */
6309 0x83, 0xe1, NACLMASK, /* andl $NACLMASK, %ecx */
6310 0xff, 0xe1 /* jmp *%ecx */
6313 static const bfd_byte elf_i386_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
6315 0x8b, 0x0d, /* movl contents of address, %ecx */
6316 0, 0, 0, 0, /* replaced with GOT slot address. */
6317 0x83, 0xe1, NACLMASK, /* andl $NACLMASK, %ecx */
6318 0xff, 0xe1, /* jmp *%ecx */
6320 /* Pad to the next 32-byte boundary with nop instructions. */
6322 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6323 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6325 /* Lazy GOT entries point here (32-byte aligned). */
6326 0x68, /* pushl immediate */
6327 0, 0, 0, 0, /* replaced with reloc offset. */
6328 0xe9, /* jmp relative */
6329 0, 0, 0, 0, /* replaced with offset to .plt. */
6331 /* Pad to the next 32-byte boundary with nop instructions. */
6332 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6333 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6337 static const bfd_byte
6338 elf_i386_nacl_pic_plt0_entry[sizeof (elf_i386_nacl_plt0_entry)] =
6340 0xff, 0x73, 0x04, /* pushl 4(%ebx) */
6341 0x8b, 0x4b, 0x08, /* mov 0x8(%ebx), %ecx */
6342 0x83, 0xe1, 0xe0, /* and $NACLMASK, %ecx */
6343 0xff, 0xe1, /* jmp *%ecx */
6345 /* This is expected to be the same size as elf_i386_nacl_plt0_entry,
6346 so pad to that size with nop instructions. */
6347 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
6350 static const bfd_byte elf_i386_nacl_pic_plt_entry[NACL_PLT_ENTRY_SIZE] =
6352 0x8b, 0x8b, /* movl offset(%ebx), %ecx */
6353 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
6354 0x83, 0xe1, 0xe0, /* andl $NACLMASK, %ecx */
6355 0xff, 0xe1, /* jmp *%ecx */
6357 /* Pad to the next 32-byte boundary with nop instructions. */
6359 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6360 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6362 /* Lazy GOT entries point here (32-byte aligned). */
6363 0x68, /* pushl immediate */
6364 0, 0, 0, 0, /* replaced with offset into relocation table. */
6365 0xe9, /* jmp relative */
6366 0, 0, 0, 0, /* replaced with offset to start of .plt. */
6368 /* Pad to the next 32-byte boundary with nop instructions. */
6369 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6370 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6374 static const bfd_byte elf_i386_nacl_eh_frame_plt[] =
6376 #if (PLT_CIE_LENGTH != 20 \
6377 || PLT_FDE_LENGTH != 36 \
6378 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6379 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6380 # error "Need elf_i386_backend_data parameters for eh_frame_plt offsets!"
6382 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
6383 0, 0, 0, 0, /* CIE ID */
6384 1, /* CIE version */
6385 'z', 'R', 0, /* Augmentation string */
6386 1, /* Code alignment factor */
6387 0x7c, /* Data alignment factor: -4 */
6388 8, /* Return address column */
6389 1, /* Augmentation size */
6390 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
6391 DW_CFA_def_cfa, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
6392 DW_CFA_offset + 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
6393 DW_CFA_nop, DW_CFA_nop,
6395 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
6396 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
6397 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
6398 0, 0, 0, 0, /* .plt size goes here */
6399 0, /* Augmentation size */
6400 DW_CFA_def_cfa_offset, 8, /* DW_CFA_def_cfa_offset: 8 */
6401 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6402 DW_CFA_def_cfa_offset, 12, /* DW_CFA_def_cfa_offset: 12 */
6403 DW_CFA_advance_loc + 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6404 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
6405 13, /* Block length */
6406 DW_OP_breg4, 4, /* DW_OP_breg4 (esp): 4 */
6407 DW_OP_breg8, 0, /* DW_OP_breg8 (eip): 0 */
6408 DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
6409 DW_OP_lit2, DW_OP_shl, DW_OP_plus,
6410 DW_CFA_nop, DW_CFA_nop
6413 static const struct elf_i386_plt_layout elf_i386_nacl_plt =
6415 elf_i386_nacl_plt0_entry, /* plt0_entry */
6416 sizeof (elf_i386_nacl_plt0_entry), /* plt0_entry_size */
6417 2, /* plt0_got1_offset */
6418 8, /* plt0_got2_offset */
6419 elf_i386_nacl_plt_entry, /* plt_entry */
6420 NACL_PLT_ENTRY_SIZE, /* plt_entry_size */
6421 2, /* plt_got_offset */
6422 33, /* plt_reloc_offset */
6423 38, /* plt_plt_offset */
6424 32, /* plt_lazy_offset */
6425 elf_i386_nacl_pic_plt0_entry, /* pic_plt0_entry */
6426 elf_i386_nacl_pic_plt_entry, /* pic_plt_entry */
6427 elf_i386_nacl_eh_frame_plt, /* eh_frame_plt */
6428 sizeof (elf_i386_nacl_eh_frame_plt),/* eh_frame_plt_size */
6431 static const struct elf_i386_backend_data elf_i386_nacl_arch_bed =
6433 &elf_i386_nacl_plt, /* plt */
6434 0x90, /* plt0_pad_byte: nop insn */
6439 elf32_i386_nacl_elf_object_p (bfd *abfd)
6441 /* Set the right machine number for a NaCl i386 ELF32 file. */
6442 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_i386_i386_nacl);
6446 #undef elf_backend_arch_data
6447 #define elf_backend_arch_data &elf_i386_nacl_arch_bed
6449 #undef elf_backend_object_p
6450 #define elf_backend_object_p elf32_i386_nacl_elf_object_p
6451 #undef elf_backend_modify_segment_map
6452 #define elf_backend_modify_segment_map nacl_modify_segment_map
6453 #undef elf_backend_modify_program_headers
6454 #define elf_backend_modify_program_headers nacl_modify_program_headers
6455 #undef elf_backend_final_write_processing
6456 #define elf_backend_final_write_processing nacl_final_write_processing
6458 #include "elf32-target.h"
6460 /* Restore defaults. */
6461 #undef elf_backend_object_p
6462 #undef elf_backend_modify_segment_map
6463 #undef elf_backend_modify_program_headers
6464 #undef elf_backend_final_write_processing
6466 /* VxWorks support. */
6468 #undef TARGET_LITTLE_SYM
6469 #define TARGET_LITTLE_SYM i386_elf32_vxworks_vec
6470 #undef TARGET_LITTLE_NAME
6471 #define TARGET_LITTLE_NAME "elf32-i386-vxworks"
6473 #undef elf_backend_plt_alignment
6474 #define elf_backend_plt_alignment 4
6476 static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed =
6478 &elf_i386_plt, /* plt */
6479 0x90, /* plt0_pad_byte */
6483 #undef elf_backend_arch_data
6484 #define elf_backend_arch_data &elf_i386_vxworks_arch_bed
6486 #undef elf_backend_relocs_compatible
6487 #undef elf_backend_add_symbol_hook
6488 #define elf_backend_add_symbol_hook \
6489 elf_vxworks_add_symbol_hook
6490 #undef elf_backend_link_output_symbol_hook
6491 #define elf_backend_link_output_symbol_hook \
6492 elf_vxworks_link_output_symbol_hook
6493 #undef elf_backend_emit_relocs
6494 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
6495 #undef elf_backend_final_write_processing
6496 #define elf_backend_final_write_processing \
6497 elf_vxworks_final_write_processing
6498 #undef elf_backend_static_tls_alignment
6500 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
6502 #undef elf_backend_want_plt_sym
6503 #define elf_backend_want_plt_sym 1
6506 #define elf32_bed elf32_i386_vxworks_bed
6508 #include "elf32-target.h"