1 /* Intel 80386/80486-specific support for 32-bit ELF
2 Copyright (C) 1993-2016 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 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
390 /* PR 17512: file: 0f67f69d. */
391 if (elf_howto_table [indx].type != r_type)
393 return &elf_howto_table[indx];
397 elf_i386_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
399 Elf_Internal_Rela *dst)
401 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
402 cache_ptr->howto = elf_i386_rtype_to_howto (abfd, r_type);
405 /* Return whether a symbol name implies a local label. The UnixWare
406 2.1 cc generates temporary symbols that start with .X, so we
407 recognize them here. FIXME: do other SVR4 compilers also use .X?.
408 If so, we should move the .X recognition into
409 _bfd_elf_is_local_label_name. */
412 elf_i386_is_local_label_name (bfd *abfd, const char *name)
414 if (name[0] == '.' && name[1] == 'X')
417 return _bfd_elf_is_local_label_name (abfd, name);
420 /* Support for core dump NOTE sections. */
423 elf_i386_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
428 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
430 int pr_version = bfd_get_32 (abfd, note->descdata);
436 elf_tdata (abfd)->core->signal = bfd_get_32 (abfd, note->descdata + 20);
439 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
443 size = bfd_get_32 (abfd, note->descdata + 8);
447 switch (note->descsz)
452 case 144: /* Linux/i386 */
454 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
457 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
467 /* Make a ".reg/999" section. */
468 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
469 size, note->descpos + offset);
473 elf_i386_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
475 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
477 int pr_version = bfd_get_32 (abfd, note->descdata);
482 elf_tdata (abfd)->core->program
483 = _bfd_elfcore_strndup (abfd, note->descdata + 8, 17);
484 elf_tdata (abfd)->core->command
485 = _bfd_elfcore_strndup (abfd, note->descdata + 25, 81);
489 switch (note->descsz)
494 case 124: /* Linux/i386 elf_prpsinfo. */
495 elf_tdata (abfd)->core->pid
496 = bfd_get_32 (abfd, note->descdata + 12);
497 elf_tdata (abfd)->core->program
498 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
499 elf_tdata (abfd)->core->command
500 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
504 /* Note that for some reason, a spurious space is tacked
505 onto the end of the args in some (at least one anyway)
506 implementations, so strip it off if it exists. */
508 char *command = elf_tdata (abfd)->core->command;
509 int n = strlen (command);
511 if (0 < n && command[n - 1] == ' ')
512 command[n - 1] = '\0';
518 /* Functions for the i386 ELF linker.
520 In order to gain some understanding of code in this file without
521 knowing all the intricate details of the linker, note the
524 Functions named elf_i386_* are called by external routines, other
525 functions are only called locally. elf_i386_* functions appear
526 in this file more or less in the order in which they are called
527 from external routines. eg. elf_i386_check_relocs is called
528 early in the link process, elf_i386_finish_dynamic_sections is
529 one of the last functions. */
532 /* The name of the dynamic interpreter. This is put in the .interp
535 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
537 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
538 copying dynamic variables from a shared lib into an app's dynbss
539 section, and instead use a dynamic relocation to point into the
541 #define ELIMINATE_COPY_RELOCS 1
543 /* The size in bytes of an entry in the procedure linkage table. */
545 #define PLT_ENTRY_SIZE 16
547 /* The first entry in an absolute procedure linkage table looks like
548 this. See the SVR4 ABI i386 supplement to see how this works.
549 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
551 static const bfd_byte elf_i386_plt0_entry[12] =
553 0xff, 0x35, /* pushl contents of address */
554 0, 0, 0, 0, /* replaced with address of .got + 4. */
555 0xff, 0x25, /* jmp indirect */
556 0, 0, 0, 0 /* replaced with address of .got + 8. */
559 /* Subsequent entries in an absolute procedure linkage table look like
562 static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
564 0xff, 0x25, /* jmp indirect */
565 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
566 0x68, /* pushl immediate */
567 0, 0, 0, 0, /* replaced with offset into relocation table. */
568 0xe9, /* jmp relative */
569 0, 0, 0, 0 /* replaced with offset to start of .plt. */
572 /* The first entry in a PIC procedure linkage table look like this.
573 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
575 static const bfd_byte elf_i386_pic_plt0_entry[12] =
577 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
578 0xff, 0xa3, 8, 0, 0, 0 /* jmp *8(%ebx) */
581 /* Subsequent entries in a PIC procedure linkage table look like this. */
583 static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
585 0xff, 0xa3, /* jmp *offset(%ebx) */
586 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
587 0x68, /* pushl immediate */
588 0, 0, 0, 0, /* replaced with offset into relocation table. */
589 0xe9, /* jmp relative */
590 0, 0, 0, 0 /* replaced with offset to start of .plt. */
593 /* Entries in the GOT procedure linkage table look like this. */
595 static const bfd_byte elf_i386_got_plt_entry[8] =
597 0xff, 0x25, /* jmp indirect */
598 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
599 0x66, 0x90 /* xchg %ax,%ax */
602 /* Entries in the PIC GOT procedure linkage table look like this. */
604 static const bfd_byte elf_i386_pic_got_plt_entry[8] =
606 0xff, 0xa3, /* jmp *offset(%ebx) */
607 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
608 0x66, 0x90 /* xchg %ax,%ax */
611 /* .eh_frame covering the .plt section. */
613 static const bfd_byte elf_i386_eh_frame_plt[] =
615 #define PLT_CIE_LENGTH 20
616 #define PLT_FDE_LENGTH 36
617 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
618 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
619 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
620 0, 0, 0, 0, /* CIE ID */
622 'z', 'R', 0, /* Augmentation string */
623 1, /* Code alignment factor */
624 0x7c, /* Data alignment factor */
625 8, /* Return address column */
626 1, /* Augmentation size */
627 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
628 DW_CFA_def_cfa, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
629 DW_CFA_offset + 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
630 DW_CFA_nop, DW_CFA_nop,
632 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
633 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
634 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
635 0, 0, 0, 0, /* .plt size goes here */
636 0, /* Augmentation size */
637 DW_CFA_def_cfa_offset, 8, /* DW_CFA_def_cfa_offset: 8 */
638 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
639 DW_CFA_def_cfa_offset, 12, /* DW_CFA_def_cfa_offset: 12 */
640 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
641 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
642 11, /* Block length */
643 DW_OP_breg4, 4, /* DW_OP_breg4 (esp): 4 */
644 DW_OP_breg8, 0, /* DW_OP_breg8 (eip): 0 */
645 DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
646 DW_OP_lit2, DW_OP_shl, DW_OP_plus,
647 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
650 struct elf_i386_plt_layout
652 /* The first entry in an absolute procedure linkage table looks like this. */
653 const bfd_byte *plt0_entry;
654 unsigned int plt0_entry_size;
656 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
657 unsigned int plt0_got1_offset;
658 unsigned int plt0_got2_offset;
660 /* Later entries in an absolute procedure linkage table look like this. */
661 const bfd_byte *plt_entry;
662 unsigned int plt_entry_size;
664 /* Offsets into plt_entry that are to be replaced with... */
665 unsigned int plt_got_offset; /* ... address of this symbol in .got. */
666 unsigned int plt_reloc_offset; /* ... offset into relocation table. */
667 unsigned int plt_plt_offset; /* ... offset to start of .plt. */
669 /* Offset into plt_entry where the initial value of the GOT entry points. */
670 unsigned int plt_lazy_offset;
672 /* The first entry in a PIC procedure linkage table looks like this. */
673 const bfd_byte *pic_plt0_entry;
675 /* Subsequent entries in a PIC procedure linkage table look like this. */
676 const bfd_byte *pic_plt_entry;
678 /* .eh_frame covering the .plt section. */
679 const bfd_byte *eh_frame_plt;
680 unsigned int eh_frame_plt_size;
683 #define GET_PLT_ENTRY_SIZE(abfd) \
684 get_elf_i386_backend_data (abfd)->plt->plt_entry_size
686 /* These are the standard parameters. */
687 static const struct elf_i386_plt_layout elf_i386_plt =
689 elf_i386_plt0_entry, /* plt0_entry */
690 sizeof (elf_i386_plt0_entry), /* plt0_entry_size */
691 2, /* plt0_got1_offset */
692 8, /* plt0_got2_offset */
693 elf_i386_plt_entry, /* plt_entry */
694 PLT_ENTRY_SIZE, /* plt_entry_size */
695 2, /* plt_got_offset */
696 7, /* plt_reloc_offset */
697 12, /* plt_plt_offset */
698 6, /* plt_lazy_offset */
699 elf_i386_pic_plt0_entry, /* pic_plt0_entry */
700 elf_i386_pic_plt_entry, /* pic_plt_entry */
701 elf_i386_eh_frame_plt, /* eh_frame_plt */
702 sizeof (elf_i386_eh_frame_plt), /* eh_frame_plt_size */
706 /* On VxWorks, the .rel.plt.unloaded section has absolute relocations
707 for the PLTResolve stub and then for each PLT entry. */
708 #define PLTRESOLVE_RELOCS_SHLIB 0
709 #define PLTRESOLVE_RELOCS 2
710 #define PLT_NON_JUMP_SLOT_RELOCS 2
712 /* Architecture-specific backend data for i386. */
714 struct elf_i386_backend_data
716 /* Parameters describing PLT generation. */
717 const struct elf_i386_plt_layout *plt;
719 /* Value used to fill the unused bytes of the first PLT entry. */
720 bfd_byte plt0_pad_byte;
722 /* True if the target system is VxWorks. */
726 #define get_elf_i386_backend_data(abfd) \
727 ((const struct elf_i386_backend_data *) \
728 get_elf_backend_data (abfd)->arch_data)
730 /* These are the standard parameters. */
731 static const struct elf_i386_backend_data elf_i386_arch_bed =
733 &elf_i386_plt, /* plt */
734 0, /* plt0_pad_byte */
738 #define elf_backend_arch_data &elf_i386_arch_bed
740 /* Is a undefined weak symbol which is resolved to 0. Reference to an
741 undefined weak symbol is resolved to 0 when building executable if
743 1. Has non-GOT/non-PLT relocations in text section. Or
744 2. Has no GOT/PLT relocation.
746 #define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, GOT_RELOC, EH) \
747 ((EH)->elf.root.type == bfd_link_hash_undefweak \
748 && bfd_link_executable (INFO) \
749 && (elf_i386_hash_table (INFO)->interp == NULL \
751 || (EH)->has_non_got_reloc \
752 || !(INFO)->dynamic_undefined_weak))
754 /* i386 ELF linker hash entry. */
756 struct elf_i386_link_hash_entry
758 struct elf_link_hash_entry elf;
760 /* Track dynamic relocs copied for this symbol. */
761 struct elf_dyn_relocs *dyn_relocs;
763 #define GOT_UNKNOWN 0
767 #define GOT_TLS_IE_POS 5
768 #define GOT_TLS_IE_NEG 6
769 #define GOT_TLS_IE_BOTH 7
770 #define GOT_TLS_GDESC 8
771 #define GOT_TLS_GD_BOTH_P(type) \
772 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
773 #define GOT_TLS_GD_P(type) \
774 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
775 #define GOT_TLS_GDESC_P(type) \
776 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
777 #define GOT_TLS_GD_ANY_P(type) \
778 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
779 unsigned char tls_type;
781 /* Symbol is referenced by R_386_GOTOFF relocation. */
782 unsigned int gotoff_ref : 1;
784 /* Symbol has GOT or PLT relocations. */
785 unsigned int has_got_reloc : 1;
787 /* Symbol has non-GOT/non-PLT relocations in text sections. */
788 unsigned int has_non_got_reloc : 1;
790 /* Reference count of C/C++ function pointer relocations in read-write
791 section which can be resolved at run-time. */
792 bfd_signed_vma func_pointer_refcount;
794 /* Information about the GOT PLT entry. Filled when there are both
795 GOT and PLT relocations against the same function. */
796 union gotplt_union plt_got;
798 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
799 starting at the end of the jump table. */
803 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
805 struct elf_i386_obj_tdata
807 struct elf_obj_tdata root;
809 /* tls_type for each local got entry. */
810 char *local_got_tls_type;
812 /* GOTPLT entries for TLS descriptors. */
813 bfd_vma *local_tlsdesc_gotent;
816 #define elf_i386_tdata(abfd) \
817 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
819 #define elf_i386_local_got_tls_type(abfd) \
820 (elf_i386_tdata (abfd)->local_got_tls_type)
822 #define elf_i386_local_tlsdesc_gotent(abfd) \
823 (elf_i386_tdata (abfd)->local_tlsdesc_gotent)
825 #define is_i386_elf(bfd) \
826 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
827 && elf_tdata (bfd) != NULL \
828 && elf_object_id (bfd) == I386_ELF_DATA)
831 elf_i386_mkobject (bfd *abfd)
833 return bfd_elf_allocate_object (abfd, sizeof (struct elf_i386_obj_tdata),
837 /* i386 ELF linker hash table. */
839 struct elf_i386_link_hash_table
841 struct elf_link_hash_table elf;
843 /* Short-cuts to get to dynamic linker sections. */
847 asection *plt_eh_frame;
852 bfd_signed_vma refcount;
856 /* The amount of space used by the reserved portion of the sgotplt
857 section, plus whatever space is used by the jump slots. */
858 bfd_vma sgotplt_jump_table_size;
860 /* Small local sym cache. */
861 struct sym_cache sym_cache;
863 /* _TLS_MODULE_BASE_ symbol. */
864 struct bfd_link_hash_entry *tls_module_base;
866 /* Used by local STT_GNU_IFUNC symbols. */
867 htab_t loc_hash_table;
868 void * loc_hash_memory;
870 /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */
873 /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */
874 bfd_vma next_tls_desc_index;
876 /* The index of the next unused R_386_JUMP_SLOT slot in .rel.plt. */
877 bfd_vma next_jump_slot_index;
879 /* The index of the next unused R_386_IRELATIVE slot in .rel.plt. */
880 bfd_vma next_irelative_index;
882 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
883 to read-only sections. */
884 bfd_boolean readonly_dynrelocs_against_ifunc;
887 /* Get the i386 ELF linker hash table from a link_info structure. */
889 #define elf_i386_hash_table(p) \
890 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
891 == I386_ELF_DATA ? ((struct elf_i386_link_hash_table *) ((p)->hash)) : NULL)
893 #define elf_i386_compute_jump_table_size(htab) \
894 ((htab)->elf.srelplt->reloc_count * 4)
896 /* Create an entry in an i386 ELF linker hash table. */
898 static struct bfd_hash_entry *
899 elf_i386_link_hash_newfunc (struct bfd_hash_entry *entry,
900 struct bfd_hash_table *table,
903 /* Allocate the structure if it has not already been allocated by a
907 entry = (struct bfd_hash_entry *)
908 bfd_hash_allocate (table, sizeof (struct elf_i386_link_hash_entry));
913 /* Call the allocation method of the superclass. */
914 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
917 struct elf_i386_link_hash_entry *eh;
919 eh = (struct elf_i386_link_hash_entry *) entry;
920 eh->dyn_relocs = NULL;
921 eh->tls_type = GOT_UNKNOWN;
923 eh->has_got_reloc = 0;
924 eh->has_non_got_reloc = 0;
925 eh->func_pointer_refcount = 0;
926 eh->plt_got.offset = (bfd_vma) -1;
927 eh->tlsdesc_got = (bfd_vma) -1;
933 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
934 for local symbol so that we can handle local STT_GNU_IFUNC symbols
935 as global symbol. We reuse indx and dynstr_index for local symbol
936 hash since they aren't used by global symbols in this backend. */
939 elf_i386_local_htab_hash (const void *ptr)
941 struct elf_link_hash_entry *h
942 = (struct elf_link_hash_entry *) ptr;
943 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
946 /* Compare local hash entries. */
949 elf_i386_local_htab_eq (const void *ptr1, const void *ptr2)
951 struct elf_link_hash_entry *h1
952 = (struct elf_link_hash_entry *) ptr1;
953 struct elf_link_hash_entry *h2
954 = (struct elf_link_hash_entry *) ptr2;
956 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
959 /* Find and/or create a hash entry for local symbol. */
961 static struct elf_link_hash_entry *
962 elf_i386_get_local_sym_hash (struct elf_i386_link_hash_table *htab,
963 bfd *abfd, const Elf_Internal_Rela *rel,
966 struct elf_i386_link_hash_entry e, *ret;
967 asection *sec = abfd->sections;
968 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
969 ELF32_R_SYM (rel->r_info));
972 e.elf.indx = sec->id;
973 e.elf.dynstr_index = ELF32_R_SYM (rel->r_info);
974 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
975 create ? INSERT : NO_INSERT);
982 ret = (struct elf_i386_link_hash_entry *) *slot;
986 ret = (struct elf_i386_link_hash_entry *)
987 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
988 sizeof (struct elf_i386_link_hash_entry));
991 memset (ret, 0, sizeof (*ret));
992 ret->elf.indx = sec->id;
993 ret->elf.dynstr_index = ELF32_R_SYM (rel->r_info);
994 ret->elf.dynindx = -1;
995 ret->func_pointer_refcount = 0;
996 ret->plt_got.offset = (bfd_vma) -1;
1002 /* Destroy an i386 ELF linker hash table. */
1005 elf_i386_link_hash_table_free (bfd *obfd)
1007 struct elf_i386_link_hash_table *htab
1008 = (struct elf_i386_link_hash_table *) obfd->link.hash;
1010 if (htab->loc_hash_table)
1011 htab_delete (htab->loc_hash_table);
1012 if (htab->loc_hash_memory)
1013 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
1014 _bfd_elf_link_hash_table_free (obfd);
1017 /* Create an i386 ELF linker hash table. */
1019 static struct bfd_link_hash_table *
1020 elf_i386_link_hash_table_create (bfd *abfd)
1022 struct elf_i386_link_hash_table *ret;
1023 bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
1025 ret = (struct elf_i386_link_hash_table *) bfd_zmalloc (amt);
1029 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
1030 elf_i386_link_hash_newfunc,
1031 sizeof (struct elf_i386_link_hash_entry),
1038 ret->loc_hash_table = htab_try_create (1024,
1039 elf_i386_local_htab_hash,
1040 elf_i386_local_htab_eq,
1042 ret->loc_hash_memory = objalloc_create ();
1043 if (!ret->loc_hash_table || !ret->loc_hash_memory)
1045 elf_i386_link_hash_table_free (abfd);
1048 ret->elf.root.hash_table_free = elf_i386_link_hash_table_free;
1050 return &ret->elf.root;
1053 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
1054 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
1058 elf_i386_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
1060 struct elf_i386_link_hash_table *htab;
1062 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1065 htab = elf_i386_hash_table (info);
1069 /* Set the contents of the .interp section to the interpreter. */
1070 if (bfd_link_executable (info) && !info->nointerp)
1072 asection *s = bfd_get_linker_section (dynobj, ".interp");
1075 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1076 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1080 htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
1084 if (bfd_link_executable (info))
1086 /* Always allow copy relocs for building executables. */
1087 asection *s = bfd_get_linker_section (dynobj, ".rel.bss");
1090 const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
1091 s = bfd_make_section_anyway_with_flags (dynobj,
1093 (bed->dynamic_sec_flags
1096 || ! bfd_set_section_alignment (dynobj, s,
1097 bed->s->log_file_align))
1103 if (get_elf_i386_backend_data (dynobj)->is_vxworks
1104 && !elf_vxworks_create_dynamic_sections (dynobj, info,
1108 if (!info->no_ld_generated_unwind_info
1109 && htab->plt_eh_frame == NULL
1110 && htab->elf.splt != NULL)
1112 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
1113 | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1114 | SEC_LINKER_CREATED);
1116 = bfd_make_section_anyway_with_flags (dynobj, ".eh_frame", flags);
1117 if (htab->plt_eh_frame == NULL
1118 || !bfd_set_section_alignment (dynobj, htab->plt_eh_frame, 2))
1125 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1128 elf_i386_copy_indirect_symbol (struct bfd_link_info *info,
1129 struct elf_link_hash_entry *dir,
1130 struct elf_link_hash_entry *ind)
1132 struct elf_i386_link_hash_entry *edir, *eind;
1134 edir = (struct elf_i386_link_hash_entry *) dir;
1135 eind = (struct elf_i386_link_hash_entry *) ind;
1137 if (eind->dyn_relocs != NULL)
1139 if (edir->dyn_relocs != NULL)
1141 struct elf_dyn_relocs **pp;
1142 struct elf_dyn_relocs *p;
1144 /* Add reloc counts against the indirect sym to the direct sym
1145 list. Merge any entries against the same section. */
1146 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1148 struct elf_dyn_relocs *q;
1150 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1151 if (q->sec == p->sec)
1153 q->pc_count += p->pc_count;
1154 q->count += p->count;
1161 *pp = edir->dyn_relocs;
1164 edir->dyn_relocs = eind->dyn_relocs;
1165 eind->dyn_relocs = NULL;
1168 if (ind->root.type == bfd_link_hash_indirect
1169 && dir->got.refcount <= 0)
1171 edir->tls_type = eind->tls_type;
1172 eind->tls_type = GOT_UNKNOWN;
1175 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1176 generate a R_386_COPY reloc. */
1177 edir->gotoff_ref |= eind->gotoff_ref;
1179 edir->has_got_reloc |= eind->has_got_reloc;
1180 edir->has_non_got_reloc |= eind->has_non_got_reloc;
1182 if (ELIMINATE_COPY_RELOCS
1183 && ind->root.type != bfd_link_hash_indirect
1184 && dir->dynamic_adjusted)
1186 /* If called to transfer flags for a weakdef during processing
1187 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1188 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1189 dir->ref_dynamic |= ind->ref_dynamic;
1190 dir->ref_regular |= ind->ref_regular;
1191 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1192 dir->needs_plt |= ind->needs_plt;
1193 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1197 if (eind->func_pointer_refcount > 0)
1199 edir->func_pointer_refcount += eind->func_pointer_refcount;
1200 eind->func_pointer_refcount = 0;
1203 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1207 /* Return TRUE if the TLS access code sequence support transition
1211 elf_i386_check_tls_transition (asection *sec,
1213 Elf_Internal_Shdr *symtab_hdr,
1214 struct elf_link_hash_entry **sym_hashes,
1215 unsigned int r_type,
1216 const Elf_Internal_Rela *rel,
1217 const Elf_Internal_Rela *relend)
1219 unsigned int val, type;
1220 unsigned long r_symndx;
1221 struct elf_link_hash_entry *h;
1224 offset = rel->r_offset;
1229 if (offset < 2 || (rel + 1) >= relend)
1232 type = bfd_get_8 (abfd, contents + offset - 2);
1233 if (r_type == R_386_TLS_GD)
1235 /* Check transition from GD access model. Only
1236 leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr
1237 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop
1238 can transit to different access model. */
1239 if ((offset + 10) > sec->size ||
1240 (type != 0x8d && type != 0x04))
1243 val = bfd_get_8 (abfd, contents + offset - 1);
1246 /* leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr */
1250 if (bfd_get_8 (abfd, contents + offset - 3) != 0x8d)
1253 if ((val & 0xc7) != 0x05 || val == (4 << 3))
1258 /* leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop */
1259 if ((val & 0xf8) != 0x80 || (val & 7) == 4)
1262 if (bfd_get_8 (abfd, contents + offset + 9) != 0x90)
1268 /* Check transition from LD access model. Only
1269 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr
1270 can transit to different access model. */
1271 if (type != 0x8d || (offset + 9) > sec->size)
1274 val = bfd_get_8 (abfd, contents + offset - 1);
1275 if ((val & 0xf8) != 0x80 || (val & 7) == 4)
1279 if (bfd_get_8 (abfd, contents + offset + 4) != 0xe8)
1282 r_symndx = ELF32_R_SYM (rel[1].r_info);
1283 if (r_symndx < symtab_hdr->sh_info)
1286 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1287 /* Use strncmp to check ___tls_get_addr since ___tls_get_addr
1288 may be versioned. */
1290 && h->root.root.string != NULL
1291 && (ELF32_R_TYPE (rel[1].r_info) == R_386_PC32
1292 || ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32)
1293 && (strncmp (h->root.root.string, "___tls_get_addr",
1297 /* Check transition from IE access model:
1298 movl foo@indntpoff(%rip), %eax
1299 movl foo@indntpoff(%rip), %reg
1300 addl foo@indntpoff(%rip), %reg
1303 if (offset < 1 || (offset + 4) > sec->size)
1306 /* Check "movl foo@tpoff(%rip), %eax" first. */
1307 val = bfd_get_8 (abfd, contents + offset - 1);
1314 /* Check movl|addl foo@tpoff(%rip), %reg. */
1315 type = bfd_get_8 (abfd, contents + offset - 2);
1316 return ((type == 0x8b || type == 0x03)
1317 && (val & 0xc7) == 0x05);
1319 case R_386_TLS_GOTIE:
1320 case R_386_TLS_IE_32:
1321 /* Check transition from {IE_32,GOTIE} access model:
1322 subl foo@{tpoff,gontoff}(%reg1), %reg2
1323 movl foo@{tpoff,gontoff}(%reg1), %reg2
1324 addl foo@{tpoff,gontoff}(%reg1), %reg2
1327 if (offset < 2 || (offset + 4) > sec->size)
1330 val = bfd_get_8 (abfd, contents + offset - 1);
1331 if ((val & 0xc0) != 0x80 || (val & 7) == 4)
1334 type = bfd_get_8 (abfd, contents + offset - 2);
1335 return type == 0x8b || type == 0x2b || type == 0x03;
1337 case R_386_TLS_GOTDESC:
1338 /* Check transition from GDesc access model:
1339 leal x@tlsdesc(%ebx), %eax
1341 Make sure it's a leal adding ebx to a 32-bit offset
1342 into any register, although it's probably almost always
1345 if (offset < 2 || (offset + 4) > sec->size)
1348 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1351 val = bfd_get_8 (abfd, contents + offset - 1);
1352 return (val & 0xc7) == 0x83;
1354 case R_386_TLS_DESC_CALL:
1355 /* Check transition from GDesc access model:
1356 call *x@tlsdesc(%rax)
1358 if (offset + 2 <= sec->size)
1360 /* Make sure that it's a call *x@tlsdesc(%rax). */
1361 static const unsigned char call[] = { 0xff, 0x10 };
1362 return memcmp (contents + offset, call, 2) == 0;
1372 /* Return TRUE if the TLS access transition is OK or no transition
1373 will be performed. Update R_TYPE if there is a transition. */
1376 elf_i386_tls_transition (struct bfd_link_info *info, bfd *abfd,
1377 asection *sec, bfd_byte *contents,
1378 Elf_Internal_Shdr *symtab_hdr,
1379 struct elf_link_hash_entry **sym_hashes,
1380 unsigned int *r_type, int tls_type,
1381 const Elf_Internal_Rela *rel,
1382 const Elf_Internal_Rela *relend,
1383 struct elf_link_hash_entry *h,
1384 unsigned long r_symndx,
1385 bfd_boolean from_relocate_section)
1387 unsigned int from_type = *r_type;
1388 unsigned int to_type = from_type;
1389 bfd_boolean check = TRUE;
1391 /* Skip TLS transition for functions. */
1393 && (h->type == STT_FUNC
1394 || h->type == STT_GNU_IFUNC))
1400 case R_386_TLS_GOTDESC:
1401 case R_386_TLS_DESC_CALL:
1402 case R_386_TLS_IE_32:
1404 case R_386_TLS_GOTIE:
1405 if (bfd_link_executable (info))
1408 to_type = R_386_TLS_LE_32;
1409 else if (from_type != R_386_TLS_IE
1410 && from_type != R_386_TLS_GOTIE)
1411 to_type = R_386_TLS_IE_32;
1414 /* When we are called from elf_i386_relocate_section, there may
1415 be additional transitions based on TLS_TYPE. */
1416 if (from_relocate_section)
1418 unsigned int new_to_type = to_type;
1420 if (bfd_link_executable (info)
1423 && (tls_type & GOT_TLS_IE))
1424 new_to_type = R_386_TLS_LE_32;
1426 if (to_type == R_386_TLS_GD
1427 || to_type == R_386_TLS_GOTDESC
1428 || to_type == R_386_TLS_DESC_CALL)
1430 if (tls_type == GOT_TLS_IE_POS)
1431 new_to_type = R_386_TLS_GOTIE;
1432 else if (tls_type & GOT_TLS_IE)
1433 new_to_type = R_386_TLS_IE_32;
1436 /* We checked the transition before when we were called from
1437 elf_i386_check_relocs. We only want to check the new
1438 transition which hasn't been checked before. */
1439 check = new_to_type != to_type && from_type == to_type;
1440 to_type = new_to_type;
1446 if (bfd_link_executable (info))
1447 to_type = R_386_TLS_LE_32;
1454 /* Return TRUE if there is no transition. */
1455 if (from_type == to_type)
1458 /* Check if the transition can be performed. */
1460 && ! elf_i386_check_tls_transition (sec, contents,
1461 symtab_hdr, sym_hashes,
1462 from_type, rel, relend))
1464 reloc_howto_type *from, *to;
1467 from = elf_i386_rtype_to_howto (abfd, from_type);
1468 to = elf_i386_rtype_to_howto (abfd, to_type);
1471 name = h->root.root.string;
1474 struct elf_i386_link_hash_table *htab;
1476 htab = elf_i386_hash_table (info);
1481 Elf_Internal_Sym *isym;
1483 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1485 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1489 (*_bfd_error_handler)
1490 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1491 "in section `%A' failed"),
1492 abfd, sec, from->name, to->name, name,
1493 (unsigned long) rel->r_offset);
1494 bfd_set_error (bfd_error_bad_value);
1502 /* With the local symbol, foo, we convert
1503 mov foo@GOT[(%reg1)], %reg2
1505 lea foo[@GOTOFF(%reg1)], %reg2
1507 call/jmp *foo@GOT[(%reg)]
1509 nop call foo/jmp foo nop
1510 When PIC is false, convert
1511 test %reg1, foo@GOT[(%reg2)]
1515 binop foo@GOT[(%reg1)], %reg2
1518 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1523 elf_i386_convert_load_reloc (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
1525 Elf_Internal_Rela *irel,
1526 struct elf_link_hash_entry *h,
1527 bfd_boolean *converted,
1528 struct bfd_link_info *link_info)
1530 struct elf_i386_link_hash_table *htab;
1531 unsigned int opcode;
1533 bfd_boolean baseless;
1534 Elf_Internal_Sym *isym;
1535 unsigned int addend;
1539 bfd_boolean to_reloc_32;
1540 unsigned int r_type;
1541 unsigned int r_symndx;
1542 bfd_vma roff = irel->r_offset;
1547 /* Addend for R_386_GOT32 and R_386_GOT32X relocations must be 0. */
1548 addend = bfd_get_32 (abfd, contents + roff);
1552 htab = elf_i386_hash_table (link_info);
1553 is_pic = bfd_link_pic (link_info);
1555 r_type = ELF32_R_TYPE (irel->r_info);
1556 r_symndx = ELF32_R_SYM (irel->r_info);
1558 modrm = bfd_get_8 (abfd, contents + roff - 1);
1559 baseless = (modrm & 0xc7) == 0x5;
1561 if (r_type == R_386_GOT32X && baseless && is_pic)
1563 /* For PIC, disallow R_386_GOT32X without a base register
1564 since we don't know what the GOT base is. Allow
1565 R_386_GOT32 for existing object files. */
1570 isym = bfd_sym_from_r_symndx (&htab->sym_cache, abfd,
1572 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1575 name = h->root.root.string;
1577 (*_bfd_error_handler)
1578 (_("%B: direct GOT relocation R_386_GOT32X against `%s' without base register can not be used when making a shared object"),
1583 opcode = bfd_get_8 (abfd, contents + roff - 2);
1585 /* Convert mov to lea since it has been done for a while. */
1588 /* Only convert R_386_GOT32X relocation for call, jmp or
1589 one of adc, add, and, cmp, or, sbb, sub, test, xor
1591 if (r_type != R_386_GOT32X)
1595 /* Convert to R_386_32 if PIC is false or there is no base
1597 to_reloc_32 = !is_pic || baseless;
1599 /* Try to convert R_386_GOT32 and R_386_GOT32X. Get the symbol
1600 referred to by the reloc. */
1603 if (opcode == 0x0ff)
1604 /* Convert "call/jmp *foo@GOT[(%reg)]". */
1605 goto convert_branch;
1607 /* Convert "mov foo@GOT[(%reg1)], %reg2",
1608 "test %reg1, foo@GOT(%reg2)" and
1609 "binop foo@GOT[(%reg1)], %reg2". */
1613 /* Undefined weak symbol is only bound locally in executable
1614 and its reference is resolved as 0. */
1615 if (UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info, TRUE,
1616 elf_i386_hash_entry (h)))
1620 /* No direct branch to 0 for PIC. */
1624 goto convert_branch;
1628 /* We can convert load of address 0 to R_386_32. */
1636 /* We have "call/jmp *foo@GOT[(%reg)]". */
1637 if ((h->root.type == bfd_link_hash_defined
1638 || h->root.type == bfd_link_hash_defweak)
1639 && SYMBOL_REFERENCES_LOCAL (link_info, h))
1641 /* The function is locally defined. */
1643 /* Convert R_386_GOT32X to R_386_PC32. */
1644 if (modrm == 0x15 || (modrm & 0xf8) == 0x90)
1646 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
1649 nop = link_info->call_nop_byte;
1650 if (link_info->call_nop_as_suffix)
1652 nop_offset = roff + 3;
1653 irel->r_offset -= 1;
1656 nop_offset = roff - 2;
1660 /* Convert to "jmp foo nop". */
1663 nop_offset = roff + 3;
1664 irel->r_offset -= 1;
1667 bfd_put_8 (abfd, nop, contents + nop_offset);
1668 bfd_put_8 (abfd, modrm, contents + irel->r_offset - 1);
1669 /* When converting to PC-relative relocation, we
1670 need to adjust addend by -4. */
1671 bfd_put_32 (abfd, -4, contents + irel->r_offset);
1672 irel->r_info = ELF32_R_INFO (r_symndx, R_386_PC32);
1679 /* We have "mov foo@GOT[(%re1g)], %reg2",
1680 "test %reg1, foo@GOT(%reg2)" and
1681 "binop foo@GOT[(%reg1)], %reg2".
1683 Avoid optimizing _DYNAMIC since ld.so may use its
1684 link-time address. */
1685 if (h == htab->elf.hdynamic)
1688 /* def_regular is set by an assignment in a linker script in
1689 bfd_elf_record_link_assignment. */
1691 || h->root.type == bfd_link_hash_defined
1692 || h->root.type == bfd_link_hash_defweak)
1693 && SYMBOL_REFERENCES_LOCAL (link_info, h))
1700 /* Convert "mov foo@GOT[(%reg1)], %reg2" to
1701 "mov $foo, %reg2" with R_386_32. */
1703 modrm = 0xc0 | (modrm & 0x38) >> 3;
1704 bfd_put_8 (abfd, modrm, contents + roff - 1);
1709 /* Convert "mov foo@GOT(%reg1), %reg2" to
1710 "lea foo@GOTOFF(%reg1), %reg2". */
1711 r_type = R_386_GOTOFF;
1717 /* Only R_386_32 is supported. */
1723 /* Convert "test %reg1, foo@GOT(%reg2)" to
1724 "test $foo, %reg1". */
1725 modrm = 0xc0 | (modrm & 0x38) >> 3;
1730 /* Convert "binop foo@GOT(%reg1), %reg2" to
1731 "binop $foo, %reg2". */
1733 | (modrm & 0x38) >> 3
1737 bfd_put_8 (abfd, modrm, contents + roff - 1);
1741 bfd_put_8 (abfd, opcode, contents + roff - 2);
1742 irel->r_info = ELF32_R_INFO (r_symndx, r_type);
1751 /* Rename some of the generic section flags to better document how they
1753 #define need_convert_load sec_flg0
1754 #define check_relocs_failed sec_flg1
1756 /* Look through the relocs for a section during the first phase, and
1757 calculate needed space in the global offset table, procedure linkage
1758 table, and dynamic reloc sections. */
1761 elf_i386_check_relocs (bfd *abfd,
1762 struct bfd_link_info *info,
1764 const Elf_Internal_Rela *relocs)
1766 struct elf_i386_link_hash_table *htab;
1767 Elf_Internal_Shdr *symtab_hdr;
1768 struct elf_link_hash_entry **sym_hashes;
1769 const Elf_Internal_Rela *rel;
1770 const Elf_Internal_Rela *rel_end;
1773 bfd_boolean use_plt_got;
1775 if (bfd_link_relocatable (info))
1778 BFD_ASSERT (is_i386_elf (abfd));
1780 htab = elf_i386_hash_table (info);
1783 sec->check_relocs_failed = 1;
1787 /* Get the section contents. */
1788 if (elf_section_data (sec)->this_hdr.contents != NULL)
1789 contents = elf_section_data (sec)->this_hdr.contents;
1790 else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1792 sec->check_relocs_failed = 1;
1796 use_plt_got = (!get_elf_i386_backend_data (abfd)->is_vxworks
1797 && (get_elf_i386_backend_data (abfd)
1798 == &elf_i386_arch_bed));
1800 symtab_hdr = &elf_symtab_hdr (abfd);
1801 sym_hashes = elf_sym_hashes (abfd);
1805 rel_end = relocs + sec->reloc_count;
1806 for (rel = relocs; rel < rel_end; rel++)
1808 unsigned int r_type;
1809 unsigned long r_symndx;
1810 struct elf_link_hash_entry *h;
1811 struct elf_i386_link_hash_entry *eh;
1812 Elf_Internal_Sym *isym;
1814 bfd_boolean size_reloc;
1816 r_symndx = ELF32_R_SYM (rel->r_info);
1817 r_type = ELF32_R_TYPE (rel->r_info);
1819 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1821 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1827 if (r_symndx < symtab_hdr->sh_info)
1829 /* A local symbol. */
1830 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1835 /* Check relocation against local STT_GNU_IFUNC symbol. */
1836 if (ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1838 h = elf_i386_get_local_sym_hash (htab, abfd, rel, TRUE);
1842 /* Fake a STT_GNU_IFUNC symbol. */
1843 h->type = STT_GNU_IFUNC;
1846 h->forced_local = 1;
1847 h->root.type = bfd_link_hash_defined;
1855 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1856 while (h->root.type == bfd_link_hash_indirect
1857 || h->root.type == bfd_link_hash_warning)
1858 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1861 eh = (struct elf_i386_link_hash_entry *) h;
1876 if (htab->elf.dynobj == NULL)
1877 htab->elf.dynobj = abfd;
1878 /* Create the ifunc sections for static executables. */
1879 if (h->type == STT_GNU_IFUNC
1880 && !_bfd_elf_create_ifunc_sections (htab->elf.dynobj,
1886 /* It is referenced by a non-shared object. */
1888 h->root.non_ir_ref = 1;
1890 if (h->type == STT_GNU_IFUNC)
1891 elf_tdata (info->output_bfd)->has_gnu_symbols
1892 |= elf_gnu_symbol_ifunc;
1895 if (! elf_i386_tls_transition (info, abfd, sec, contents,
1896 symtab_hdr, sym_hashes,
1897 &r_type, GOT_UNKNOWN,
1898 rel, rel_end, h, r_symndx, FALSE))
1904 htab->tls_ldm_got.refcount += 1;
1908 /* This symbol requires a procedure linkage table entry. We
1909 actually build the entry in adjust_dynamic_symbol,
1910 because this might be a case of linking PIC code which is
1911 never referenced by a dynamic object, in which case we
1912 don't need to generate a procedure linkage table entry
1915 /* If this is a local symbol, we resolve it directly without
1916 creating a procedure linkage table entry. */
1920 eh->has_got_reloc = 1;
1922 h->plt.refcount += 1;
1929 case R_386_TLS_IE_32:
1931 case R_386_TLS_GOTIE:
1932 if (!bfd_link_executable (info))
1933 info->flags |= DF_STATIC_TLS;
1939 case R_386_TLS_GOTDESC:
1940 case R_386_TLS_DESC_CALL:
1941 /* This symbol requires a global offset table entry. */
1943 int tls_type, old_tls_type;
1950 tls_type = GOT_NORMAL;
1952 case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
1953 case R_386_TLS_GOTDESC:
1954 case R_386_TLS_DESC_CALL:
1955 tls_type = GOT_TLS_GDESC; break;
1956 case R_386_TLS_IE_32:
1957 if (ELF32_R_TYPE (rel->r_info) == r_type)
1958 tls_type = GOT_TLS_IE_NEG;
1960 /* If this is a GD->IE transition, we may use either of
1961 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
1962 tls_type = GOT_TLS_IE;
1965 case R_386_TLS_GOTIE:
1966 tls_type = GOT_TLS_IE_POS; break;
1971 h->got.refcount += 1;
1972 old_tls_type = elf_i386_hash_entry(h)->tls_type;
1976 bfd_signed_vma *local_got_refcounts;
1978 /* This is a global offset table entry for a local symbol. */
1979 local_got_refcounts = elf_local_got_refcounts (abfd);
1980 if (local_got_refcounts == NULL)
1984 size = symtab_hdr->sh_info;
1985 size *= (sizeof (bfd_signed_vma)
1986 + sizeof (bfd_vma) + sizeof(char));
1987 local_got_refcounts = (bfd_signed_vma *)
1988 bfd_zalloc (abfd, size);
1989 if (local_got_refcounts == NULL)
1991 elf_local_got_refcounts (abfd) = local_got_refcounts;
1992 elf_i386_local_tlsdesc_gotent (abfd)
1993 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
1994 elf_i386_local_got_tls_type (abfd)
1995 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
1997 local_got_refcounts[r_symndx] += 1;
1998 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
2001 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
2002 tls_type |= old_tls_type;
2003 /* If a TLS symbol is accessed using IE at least once,
2004 there is no point to use dynamic model for it. */
2005 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
2006 && (! GOT_TLS_GD_ANY_P (old_tls_type)
2007 || (tls_type & GOT_TLS_IE) == 0))
2009 if ((old_tls_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (tls_type))
2010 tls_type = old_tls_type;
2011 else if (GOT_TLS_GD_ANY_P (old_tls_type)
2012 && GOT_TLS_GD_ANY_P (tls_type))
2013 tls_type |= old_tls_type;
2017 name = h->root.root.string;
2019 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
2021 (*_bfd_error_handler)
2022 (_("%B: `%s' accessed both as normal and "
2023 "thread local symbol"),
2025 bfd_set_error (bfd_error_bad_value);
2030 if (old_tls_type != tls_type)
2033 elf_i386_hash_entry (h)->tls_type = tls_type;
2035 elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
2043 if (htab->elf.sgot == NULL)
2045 if (htab->elf.dynobj == NULL)
2046 htab->elf.dynobj = abfd;
2047 if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
2050 if (r_type != R_386_TLS_IE)
2053 eh->has_got_reloc = 1;
2058 case R_386_TLS_LE_32:
2061 eh->has_got_reloc = 1;
2062 if (bfd_link_executable (info))
2064 info->flags |= DF_STATIC_TLS;
2069 if (eh != NULL && (sec->flags & SEC_CODE) != 0)
2070 eh->has_non_got_reloc = 1;
2072 /* STT_GNU_IFUNC symbol must go through PLT even if it is
2073 locally defined and undefined symbol may turn out to be
2074 a STT_GNU_IFUNC symbol later. */
2076 && (bfd_link_executable (info)
2077 || ((h->type == STT_GNU_IFUNC
2078 || h->root.type == bfd_link_hash_undefweak
2079 || h->root.type == bfd_link_hash_undefined)
2080 && SYMBOLIC_BIND (info, h))))
2082 /* If this reloc is in a read-only section, we might
2083 need a copy reloc. We can't check reliably at this
2084 stage whether the section is read-only, as input
2085 sections have not yet been mapped to output sections.
2086 Tentatively set the flag for now, and correct in
2087 adjust_dynamic_symbol. */
2090 /* We may need a .plt entry if the function this reloc
2091 refers to is in a shared lib. */
2092 h->plt.refcount += 1;
2093 if (r_type == R_386_PC32)
2095 /* Since something like ".long foo - ." may be used
2096 as pointer, make sure that PLT is used if foo is
2097 a function defined in a shared library. */
2098 if ((sec->flags & SEC_CODE) == 0)
2099 h->pointer_equality_needed = 1;
2103 h->pointer_equality_needed = 1;
2104 /* R_386_32 can be resolved at run-time. */
2105 if (r_type == R_386_32
2106 && (sec->flags & SEC_READONLY) == 0)
2107 eh->func_pointer_refcount += 1;
2113 /* If we are creating a shared library, and this is a reloc
2114 against a global symbol, or a non PC relative reloc
2115 against a local symbol, then we need to copy the reloc
2116 into the shared library. However, if we are linking with
2117 -Bsymbolic, we do not need to copy a reloc against a
2118 global symbol which is defined in an object we are
2119 including in the link (i.e., DEF_REGULAR is set). At
2120 this point we have not seen all the input files, so it is
2121 possible that DEF_REGULAR is not set now but will be set
2122 later (it is never cleared). In case of a weak definition,
2123 DEF_REGULAR may be cleared later by a strong definition in
2124 a shared library. We account for that possibility below by
2125 storing information in the relocs_copied field of the hash
2126 table entry. A similar situation occurs when creating
2127 shared libraries and symbol visibility changes render the
2130 If on the other hand, we are creating an executable, we
2131 may need to keep relocations for symbols satisfied by a
2132 dynamic library if we manage to avoid copy relocs for the
2134 if ((bfd_link_pic (info)
2135 && (sec->flags & SEC_ALLOC) != 0
2136 && (r_type != R_386_PC32
2138 && (! (bfd_link_pie (info)
2139 || SYMBOLIC_BIND (info, h))
2140 || h->root.type == bfd_link_hash_defweak
2141 || !h->def_regular))))
2142 || (ELIMINATE_COPY_RELOCS
2143 && !bfd_link_pic (info)
2144 && (sec->flags & SEC_ALLOC) != 0
2146 && (h->root.type == bfd_link_hash_defweak
2147 || !h->def_regular)))
2149 struct elf_dyn_relocs *p;
2150 struct elf_dyn_relocs **head;
2152 /* We must copy these reloc types into the output file.
2153 Create a reloc section in dynobj and make room for
2157 if (htab->elf.dynobj == NULL)
2158 htab->elf.dynobj = abfd;
2160 sreloc = _bfd_elf_make_dynamic_reloc_section
2161 (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ FALSE);
2167 /* If this is a global symbol, we count the number of
2168 relocations we need for this symbol. */
2171 head = &eh->dyn_relocs;
2175 /* Track dynamic relocs needed for local syms too.
2176 We really need local syms available to do this
2181 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2186 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
2190 vpp = &elf_section_data (s)->local_dynrel;
2191 head = (struct elf_dyn_relocs **)vpp;
2195 if (p == NULL || p->sec != sec)
2197 bfd_size_type amt = sizeof *p;
2198 p = (struct elf_dyn_relocs *) bfd_alloc (htab->elf.dynobj,
2210 /* Count size relocation as PC-relative relocation. */
2211 if (r_type == R_386_PC32 || size_reloc)
2216 /* This relocation describes the C++ object vtable hierarchy.
2217 Reconstruct it for later use during GC. */
2218 case R_386_GNU_VTINHERIT:
2219 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2223 /* This relocation describes which C++ vtable entries are actually
2224 used. Record for later use during GC. */
2225 case R_386_GNU_VTENTRY:
2226 BFD_ASSERT (h != NULL);
2228 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
2238 && h->plt.refcount > 0
2239 && (((info->flags & DF_BIND_NOW) && !h->pointer_equality_needed)
2240 || h->got.refcount > 0)
2241 && htab->plt_got == NULL)
2243 /* Create the GOT procedure linkage table. */
2244 unsigned int plt_got_align;
2245 const struct elf_backend_data *bed;
2247 bed = get_elf_backend_data (info->output_bfd);
2248 BFD_ASSERT (sizeof (elf_i386_got_plt_entry) == 8
2249 && (sizeof (elf_i386_got_plt_entry)
2250 == sizeof (elf_i386_pic_got_plt_entry)));
2253 if (htab->elf.dynobj == NULL)
2254 htab->elf.dynobj = abfd;
2256 = bfd_make_section_anyway_with_flags (htab->elf.dynobj,
2258 (bed->dynamic_sec_flags
2263 if (htab->plt_got == NULL
2264 || !bfd_set_section_alignment (htab->elf.dynobj,
2270 if ((r_type == R_386_GOT32 || r_type == R_386_GOT32X)
2271 && (h == NULL || h->type != STT_GNU_IFUNC))
2272 sec->need_convert_load = 1;
2275 if (elf_section_data (sec)->this_hdr.contents != contents)
2277 if (!info->keep_memory)
2281 /* Cache the section contents for elf_link_input_bfd. */
2282 elf_section_data (sec)->this_hdr.contents = contents;
2289 if (elf_section_data (sec)->this_hdr.contents != contents)
2291 sec->check_relocs_failed = 1;
2295 /* Return the section that should be marked against GC for a given
2299 elf_i386_gc_mark_hook (asection *sec,
2300 struct bfd_link_info *info,
2301 Elf_Internal_Rela *rel,
2302 struct elf_link_hash_entry *h,
2303 Elf_Internal_Sym *sym)
2306 switch (ELF32_R_TYPE (rel->r_info))
2308 case R_386_GNU_VTINHERIT:
2309 case R_386_GNU_VTENTRY:
2313 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2316 /* Remove undefined weak symbol from the dynamic symbol table if it
2317 is resolved to 0. */
2320 elf_i386_fixup_symbol (struct bfd_link_info *info,
2321 struct elf_link_hash_entry *h)
2323 if (h->dynindx != -1
2324 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
2325 elf_i386_hash_entry (h)->has_got_reloc,
2326 elf_i386_hash_entry (h)))
2329 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
2335 /* Adjust a symbol defined by a dynamic object and referenced by a
2336 regular object. The current definition is in some section of the
2337 dynamic object, but we're not including those sections. We have to
2338 change the definition to something the rest of the link can
2342 elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info,
2343 struct elf_link_hash_entry *h)
2345 struct elf_i386_link_hash_table *htab;
2347 struct elf_i386_link_hash_entry *eh;
2348 struct elf_dyn_relocs *p;
2350 /* STT_GNU_IFUNC symbol must go through PLT. */
2351 if (h->type == STT_GNU_IFUNC)
2353 /* All local STT_GNU_IFUNC references must be treate as local
2354 calls via local PLT. */
2356 && SYMBOL_CALLS_LOCAL (info, h))
2358 bfd_size_type pc_count = 0, count = 0;
2359 struct elf_dyn_relocs **pp;
2361 eh = (struct elf_i386_link_hash_entry *) h;
2362 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2364 pc_count += p->pc_count;
2365 p->count -= p->pc_count;
2374 if (pc_count || count)
2378 if (h->plt.refcount <= 0)
2379 h->plt.refcount = 1;
2381 h->plt.refcount += 1;
2385 if (h->plt.refcount <= 0)
2387 h->plt.offset = (bfd_vma) -1;
2393 /* If this is a function, put it in the procedure linkage table. We
2394 will fill in the contents of the procedure linkage table later,
2395 when we know the address of the .got section. */
2396 if (h->type == STT_FUNC
2399 if (h->plt.refcount <= 0
2400 || SYMBOL_CALLS_LOCAL (info, h)
2401 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2402 && h->root.type == bfd_link_hash_undefweak))
2404 /* This case can occur if we saw a PLT32 reloc in an input
2405 file, but the symbol was never referred to by a dynamic
2406 object, or if all references were garbage collected. In
2407 such a case, we don't actually need to build a procedure
2408 linkage table, and we can just do a PC32 reloc instead. */
2409 h->plt.offset = (bfd_vma) -1;
2416 /* It's possible that we incorrectly decided a .plt reloc was
2417 needed for an R_386_PC32 reloc to a non-function sym in
2418 check_relocs. We can't decide accurately between function and
2419 non-function syms in check-relocs; Objects loaded later in
2420 the link may change h->type. So fix it now. */
2421 h->plt.offset = (bfd_vma) -1;
2423 /* If this is a weak symbol, and there is a real definition, the
2424 processor independent code will have arranged for us to see the
2425 real definition first, and we can just use the same value. */
2426 if (h->u.weakdef != NULL)
2428 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2429 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2430 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2431 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2432 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
2433 h->non_got_ref = h->u.weakdef->non_got_ref;
2437 /* This is a reference to a symbol defined by a dynamic object which
2438 is not a function. */
2440 /* If we are creating a shared library, we must presume that the
2441 only references to the symbol are via the global offset table.
2442 For such cases we need not do anything here; the relocations will
2443 be handled correctly by relocate_section. */
2444 if (!bfd_link_executable (info))
2447 /* If there are no references to this symbol that do not use the
2448 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
2450 eh = (struct elf_i386_link_hash_entry *) h;
2451 if (!h->non_got_ref && !eh->gotoff_ref)
2454 /* If -z nocopyreloc was given, we won't generate them either. */
2455 if (info->nocopyreloc)
2461 htab = elf_i386_hash_table (info);
2465 /* If there aren't any dynamic relocs in read-only sections nor
2466 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
2467 avoid the copy reloc. This doesn't work on VxWorks, where we can
2468 not have dynamic relocations (other than copy and jump slot
2469 relocations) in an executable. */
2470 if (ELIMINATE_COPY_RELOCS
2472 && !get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
2474 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2476 s = p->sec->output_section;
2477 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2488 /* We must allocate the symbol in our .dynbss section, which will
2489 become part of the .bss section of the executable. There will be
2490 an entry for this symbol in the .dynsym section. The dynamic
2491 object will contain position independent code, so all references
2492 from the dynamic object to this symbol will go through the global
2493 offset table. The dynamic linker will use the .dynsym entry to
2494 determine the address it must put in the global offset table, so
2495 both the dynamic object and the regular object will refer to the
2496 same memory location for the variable. */
2498 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
2499 copy the initial value out of the dynamic object and into the
2500 runtime process image. */
2501 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2503 htab->srelbss->size += sizeof (Elf32_External_Rel);
2509 return _bfd_elf_adjust_dynamic_copy (info, h, s);
2512 /* Allocate space in .plt, .got and associated reloc sections for
2516 elf_i386_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
2518 struct bfd_link_info *info;
2519 struct elf_i386_link_hash_table *htab;
2520 struct elf_i386_link_hash_entry *eh;
2521 struct elf_dyn_relocs *p;
2522 unsigned plt_entry_size;
2523 bfd_boolean resolved_to_zero;
2525 if (h->root.type == bfd_link_hash_indirect)
2528 eh = (struct elf_i386_link_hash_entry *) h;
2530 info = (struct bfd_link_info *) inf;
2531 htab = elf_i386_hash_table (info);
2535 plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
2537 resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
2541 /* Clear the reference count of function pointer relocations if
2542 symbol isn't a normal function. */
2543 if (h->type != STT_FUNC)
2544 eh->func_pointer_refcount = 0;
2546 /* We can't use the GOT PLT if pointer equality is needed since
2547 finish_dynamic_symbol won't clear symbol value and the dynamic
2548 linker won't update the GOT slot. We will get into an infinite
2549 loop at run-time. */
2550 if (htab->plt_got != NULL
2551 && h->type != STT_GNU_IFUNC
2552 && !h->pointer_equality_needed
2553 && h->plt.refcount > 0
2554 && h->got.refcount > 0)
2556 /* Don't use the regular PLT if there are both GOT and GOTPLT
2558 h->plt.offset = (bfd_vma) -1;
2560 /* Use the GOT PLT. */
2561 eh->plt_got.refcount = 1;
2564 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2565 here if it is defined and referenced in a non-shared object. */
2566 if (h->type == STT_GNU_IFUNC
2568 return _bfd_elf_allocate_ifunc_dyn_relocs (info, h, &eh->dyn_relocs,
2569 &htab->readonly_dynrelocs_against_ifunc,
2572 /* Don't create the PLT entry if there are only function pointer
2573 relocations which can be resolved at run-time. */
2574 else if (htab->elf.dynamic_sections_created
2575 && (h->plt.refcount > eh->func_pointer_refcount
2576 || eh->plt_got.refcount > 0))
2578 bfd_boolean use_plt_got;
2580 /* Clear the reference count of function pointer relocations
2582 eh->func_pointer_refcount = 0;
2584 if ((info->flags & DF_BIND_NOW) && !h->pointer_equality_needed)
2586 /* Don't use the regular PLT for DF_BIND_NOW. */
2587 h->plt.offset = (bfd_vma) -1;
2589 /* Use the GOT PLT. */
2590 h->got.refcount = 1;
2591 eh->plt_got.refcount = 1;
2594 use_plt_got = eh->plt_got.refcount > 0;
2596 /* Make sure this symbol is output as a dynamic symbol.
2597 Undefined weak syms won't yet be marked as dynamic. */
2598 if (h->dynindx == -1
2600 && !resolved_to_zero)
2602 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2606 if (bfd_link_pic (info)
2607 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2609 asection *s = htab->elf.splt;
2610 asection *got_s = htab->plt_got;
2612 /* If this is the first .plt entry, make room for the special
2613 first entry. The .plt section is used by prelink to undo
2614 prelinking for dynamic relocations. */
2616 s->size = plt_entry_size;
2619 eh->plt_got.offset = got_s->size;
2621 h->plt.offset = s->size;
2623 /* If this symbol is not defined in a regular file, and we are
2624 not generating a shared library, then set the symbol to this
2625 location in the .plt. This is required to make function
2626 pointers compare as equal between the normal executable and
2627 the shared library. */
2628 if (! bfd_link_pic (info)
2633 /* We need to make a call to the entry of the GOT PLT
2634 instead of regular PLT entry. */
2635 h->root.u.def.section = got_s;
2636 h->root.u.def.value = eh->plt_got.offset;
2640 h->root.u.def.section = s;
2641 h->root.u.def.value = h->plt.offset;
2645 /* Make room for this entry. */
2647 got_s->size += sizeof (elf_i386_got_plt_entry);
2650 s->size += plt_entry_size;
2652 /* We also need to make an entry in the .got.plt section,
2653 which will be placed in the .got section by the linker
2655 htab->elf.sgotplt->size += 4;
2657 /* There should be no PLT relocation against resolved
2658 undefined weak symbol in executable. */
2659 if (!resolved_to_zero)
2661 /* We also need to make an entry in the .rel.plt
2663 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2664 htab->elf.srelplt->reloc_count++;
2668 if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks
2669 && !bfd_link_pic (info))
2671 /* VxWorks has a second set of relocations for each PLT entry
2672 in executables. They go in a separate relocation section,
2673 which is processed by the kernel loader. */
2675 /* There are two relocations for the initial PLT entry: an
2676 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2677 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
2679 if (h->plt.offset == plt_entry_size)
2680 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2682 /* There are two extra relocations for each subsequent PLT entry:
2683 an R_386_32 relocation for the GOT entry, and an R_386_32
2684 relocation for the PLT entry. */
2686 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2691 eh->plt_got.offset = (bfd_vma) -1;
2692 h->plt.offset = (bfd_vma) -1;
2698 eh->plt_got.offset = (bfd_vma) -1;
2699 h->plt.offset = (bfd_vma) -1;
2703 eh->tlsdesc_got = (bfd_vma) -1;
2705 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
2706 make it a R_386_TLS_LE_32 requiring no TLS entry. */
2707 if (h->got.refcount > 0
2708 && bfd_link_executable (info)
2710 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
2711 h->got.offset = (bfd_vma) -1;
2712 else if (h->got.refcount > 0)
2716 int tls_type = elf_i386_hash_entry(h)->tls_type;
2718 /* Make sure this symbol is output as a dynamic symbol.
2719 Undefined weak syms won't yet be marked as dynamic. */
2720 if (h->dynindx == -1
2722 && !resolved_to_zero)
2724 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2729 if (GOT_TLS_GDESC_P (tls_type))
2731 eh->tlsdesc_got = htab->elf.sgotplt->size
2732 - elf_i386_compute_jump_table_size (htab);
2733 htab->elf.sgotplt->size += 8;
2734 h->got.offset = (bfd_vma) -2;
2736 if (! GOT_TLS_GDESC_P (tls_type)
2737 || GOT_TLS_GD_P (tls_type))
2739 h->got.offset = s->size;
2741 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
2742 if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
2745 dyn = htab->elf.dynamic_sections_created;
2746 /* R_386_TLS_IE_32 needs one dynamic relocation,
2747 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2748 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2749 need two), R_386_TLS_GD needs one if local symbol and two if
2750 global. No dynamic relocation against resolved undefined weak
2751 symbol in executable. */
2752 if (tls_type == GOT_TLS_IE_BOTH)
2753 htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
2754 else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
2755 || (tls_type & GOT_TLS_IE))
2756 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2757 else if (GOT_TLS_GD_P (tls_type))
2758 htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
2759 else if (! GOT_TLS_GDESC_P (tls_type)
2760 && ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2761 && !resolved_to_zero)
2762 || h->root.type != bfd_link_hash_undefweak)
2763 && (bfd_link_pic (info)
2764 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
2765 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2766 if (GOT_TLS_GDESC_P (tls_type))
2767 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2770 h->got.offset = (bfd_vma) -1;
2772 if (eh->dyn_relocs == NULL)
2775 /* In the shared -Bsymbolic case, discard space allocated for
2776 dynamic pc-relative relocs against symbols which turn out to be
2777 defined in regular objects. For the normal shared case, discard
2778 space for pc-relative relocs that have become local due to symbol
2779 visibility changes. */
2781 if (bfd_link_pic (info))
2783 /* The only reloc that uses pc_count is R_386_PC32, which will
2784 appear on a call or on something like ".long foo - .". We
2785 want calls to protected symbols to resolve directly to the
2786 function rather than going via the plt. If people want
2787 function pointer comparisons to work as expected then they
2788 should avoid writing assembly like ".long foo - .". */
2789 if (SYMBOL_CALLS_LOCAL (info, h))
2791 struct elf_dyn_relocs **pp;
2793 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2795 p->count -= p->pc_count;
2804 if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
2806 struct elf_dyn_relocs **pp;
2807 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2809 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2816 /* Also discard relocs on undefined weak syms with non-default
2817 visibility or in PIE. */
2818 if (eh->dyn_relocs != NULL
2819 && h->root.type == bfd_link_hash_undefweak)
2821 /* Undefined weak symbol is never bound locally in shared
2823 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2824 || resolved_to_zero)
2828 /* Keep dynamic non-GOT/non-PLT relocation so that we
2829 can branch to 0 without PLT. */
2830 struct elf_dyn_relocs **pp;
2832 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2833 if (p->pc_count == 0)
2837 /* Remove non-R_386_PC32 relocation. */
2838 p->count = p->pc_count;
2842 if (eh->dyn_relocs != NULL)
2844 /* Make sure undefined weak symbols are output
2845 as dynamic symbols in PIEs for dynamic non-GOT
2846 non-PLT reloations. */
2847 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2852 eh->dyn_relocs = NULL;
2854 else if (h->dynindx == -1
2855 && !h->forced_local)
2857 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2862 else if (ELIMINATE_COPY_RELOCS)
2864 /* For the non-shared case, discard space for relocs against
2865 symbols which turn out to need copy relocs or are not
2866 dynamic. Keep dynamic relocations for run-time function
2867 pointer initialization. */
2869 if ((!h->non_got_ref
2870 || eh->func_pointer_refcount > 0
2871 || (h->root.type == bfd_link_hash_undefweak
2872 && !resolved_to_zero))
2875 || (htab->elf.dynamic_sections_created
2876 && (h->root.type == bfd_link_hash_undefweak
2877 || h->root.type == bfd_link_hash_undefined))))
2879 /* Make sure this symbol is output as a dynamic symbol.
2880 Undefined weak syms won't yet be marked as dynamic. */
2881 if (h->dynindx == -1
2883 && !resolved_to_zero)
2885 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2889 /* If that succeeded, we know we'll be keeping all the
2891 if (h->dynindx != -1)
2895 eh->dyn_relocs = NULL;
2896 eh->func_pointer_refcount = 0;
2901 /* Finally, allocate space. */
2902 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2906 sreloc = elf_section_data (p->sec)->sreloc;
2908 BFD_ASSERT (sreloc != NULL);
2909 sreloc->size += p->count * sizeof (Elf32_External_Rel);
2915 /* Allocate space in .plt, .got and associated reloc sections for
2916 local dynamic relocs. */
2919 elf_i386_allocate_local_dynrelocs (void **slot, void *inf)
2921 struct elf_link_hash_entry *h
2922 = (struct elf_link_hash_entry *) *slot;
2924 if (h->type != STT_GNU_IFUNC
2928 || h->root.type != bfd_link_hash_defined)
2931 return elf_i386_allocate_dynrelocs (h, inf);
2934 /* Find any dynamic relocs that apply to read-only sections. */
2937 elf_i386_readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
2939 struct elf_i386_link_hash_entry *eh;
2940 struct elf_dyn_relocs *p;
2942 /* Skip local IFUNC symbols. */
2943 if (h->forced_local && h->type == STT_GNU_IFUNC)
2946 eh = (struct elf_i386_link_hash_entry *) h;
2947 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2949 asection *s = p->sec->output_section;
2951 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2953 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2955 info->flags |= DF_TEXTREL;
2957 if ((info->warn_shared_textrel && bfd_link_pic (info))
2958 || info->error_textrel)
2959 info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
2960 p->sec->owner, h->root.root.string,
2963 /* Not an error, just cut short the traversal. */
2970 /* Convert load via the GOT slot to load immediate. */
2973 elf_i386_convert_load (bfd *abfd, asection *sec,
2974 struct bfd_link_info *link_info)
2976 struct elf_i386_link_hash_table *htab;
2977 Elf_Internal_Shdr *symtab_hdr;
2978 Elf_Internal_Rela *internal_relocs;
2979 Elf_Internal_Rela *irel, *irelend;
2981 bfd_boolean changed;
2982 bfd_signed_vma *local_got_refcounts;
2984 /* Don't even try to convert non-ELF outputs. */
2985 if (!is_elf_hash_table (link_info->hash))
2988 /* Nothing to do if there is no need or no output. */
2989 if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
2990 || sec->need_convert_load == 0
2991 || bfd_is_abs_section (sec->output_section))
2994 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2996 /* Load the relocations for this section. */
2997 internal_relocs = (_bfd_elf_link_read_relocs
2998 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
2999 link_info->keep_memory));
3000 if (internal_relocs == NULL)
3004 htab = elf_i386_hash_table (link_info);
3005 local_got_refcounts = elf_local_got_refcounts (abfd);
3007 /* Get the section contents. */
3008 if (elf_section_data (sec)->this_hdr.contents != NULL)
3009 contents = elf_section_data (sec)->this_hdr.contents;
3012 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
3016 irelend = internal_relocs + sec->reloc_count;
3017 for (irel = internal_relocs; irel < irelend; irel++)
3019 unsigned int r_type = ELF32_R_TYPE (irel->r_info);
3020 unsigned int r_symndx;
3021 struct elf_link_hash_entry *h;
3022 bfd_boolean converted;
3024 if (r_type != R_386_GOT32 && r_type != R_386_GOT32X)
3027 r_symndx = ELF32_R_SYM (irel->r_info);
3028 if (r_symndx < symtab_hdr->sh_info)
3029 h = elf_i386_get_local_sym_hash (htab, sec->owner,
3030 (const Elf_Internal_Rela *) irel,
3034 h = elf_sym_hashes (abfd)[r_symndx - symtab_hdr->sh_info];
3035 while (h->root.type == bfd_link_hash_indirect
3036 || h->root.type == bfd_link_hash_warning)
3037 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3040 /* STT_GNU_IFUNC must keep GOT32 relocations. */
3041 if (h != NULL && h->type == STT_GNU_IFUNC)
3045 if (!elf_i386_convert_load_reloc (abfd, symtab_hdr, contents,
3046 irel, h, &converted, link_info))
3051 changed = converted;
3054 if (h->got.refcount > 0)
3055 h->got.refcount -= 1;
3059 if (local_got_refcounts != NULL
3060 && local_got_refcounts[r_symndx] > 0)
3061 local_got_refcounts[r_symndx] -= 1;
3066 if (contents != NULL
3067 && elf_section_data (sec)->this_hdr.contents != contents)
3069 if (!changed && !link_info->keep_memory)
3073 /* Cache the section contents for elf_link_input_bfd. */
3074 elf_section_data (sec)->this_hdr.contents = contents;
3078 if (elf_section_data (sec)->relocs != internal_relocs)
3081 free (internal_relocs);
3083 elf_section_data (sec)->relocs = internal_relocs;
3089 if (contents != NULL
3090 && elf_section_data (sec)->this_hdr.contents != contents)
3092 if (internal_relocs != NULL
3093 && elf_section_data (sec)->relocs != internal_relocs)
3094 free (internal_relocs);
3098 /* Set the sizes of the dynamic sections. */
3101 elf_i386_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
3103 struct elf_i386_link_hash_table *htab;
3109 htab = elf_i386_hash_table (info);
3112 dynobj = htab->elf.dynobj;
3116 /* Set up .got offsets for local syms, and space for local dynamic
3118 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3120 bfd_signed_vma *local_got;
3121 bfd_signed_vma *end_local_got;
3122 char *local_tls_type;
3123 bfd_vma *local_tlsdesc_gotent;
3124 bfd_size_type locsymcount;
3125 Elf_Internal_Shdr *symtab_hdr;
3128 if (! is_i386_elf (ibfd))
3131 for (s = ibfd->sections; s != NULL; s = s->next)
3133 struct elf_dyn_relocs *p;
3135 if (!elf_i386_convert_load (ibfd, s, info))
3138 for (p = ((struct elf_dyn_relocs *)
3139 elf_section_data (s)->local_dynrel);
3143 if (!bfd_is_abs_section (p->sec)
3144 && bfd_is_abs_section (p->sec->output_section))
3146 /* Input section has been discarded, either because
3147 it is a copy of a linkonce section or due to
3148 linker script /DISCARD/, so we'll be discarding
3151 else if (get_elf_i386_backend_data (output_bfd)->is_vxworks
3152 && strcmp (p->sec->output_section->name,
3155 /* Relocations in vxworks .tls_vars sections are
3156 handled specially by the loader. */
3158 else if (p->count != 0)
3160 srel = elf_section_data (p->sec)->sreloc;
3161 srel->size += p->count * sizeof (Elf32_External_Rel);
3162 if ((p->sec->output_section->flags & SEC_READONLY) != 0
3163 && (info->flags & DF_TEXTREL) == 0)
3165 info->flags |= DF_TEXTREL;
3166 if ((info->warn_shared_textrel && bfd_link_pic (info))
3167 || info->error_textrel)
3168 info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3169 p->sec->owner, p->sec);
3175 local_got = elf_local_got_refcounts (ibfd);
3179 symtab_hdr = &elf_symtab_hdr (ibfd);
3180 locsymcount = symtab_hdr->sh_info;
3181 end_local_got = local_got + locsymcount;
3182 local_tls_type = elf_i386_local_got_tls_type (ibfd);
3183 local_tlsdesc_gotent = elf_i386_local_tlsdesc_gotent (ibfd);
3185 srel = htab->elf.srelgot;
3186 for (; local_got < end_local_got;
3187 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
3189 *local_tlsdesc_gotent = (bfd_vma) -1;
3192 if (GOT_TLS_GDESC_P (*local_tls_type))
3194 *local_tlsdesc_gotent = htab->elf.sgotplt->size
3195 - elf_i386_compute_jump_table_size (htab);
3196 htab->elf.sgotplt->size += 8;
3197 *local_got = (bfd_vma) -2;
3199 if (! GOT_TLS_GDESC_P (*local_tls_type)
3200 || GOT_TLS_GD_P (*local_tls_type))
3202 *local_got = s->size;
3204 if (GOT_TLS_GD_P (*local_tls_type)
3205 || *local_tls_type == GOT_TLS_IE_BOTH)
3208 if (bfd_link_pic (info)
3209 || GOT_TLS_GD_ANY_P (*local_tls_type)
3210 || (*local_tls_type & GOT_TLS_IE))
3212 if (*local_tls_type == GOT_TLS_IE_BOTH)
3213 srel->size += 2 * sizeof (Elf32_External_Rel);
3214 else if (GOT_TLS_GD_P (*local_tls_type)
3215 || ! GOT_TLS_GDESC_P (*local_tls_type))
3216 srel->size += sizeof (Elf32_External_Rel);
3217 if (GOT_TLS_GDESC_P (*local_tls_type))
3218 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
3222 *local_got = (bfd_vma) -1;
3226 if (htab->tls_ldm_got.refcount > 0)
3228 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
3230 htab->tls_ldm_got.offset = htab->elf.sgot->size;
3231 htab->elf.sgot->size += 8;
3232 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
3235 htab->tls_ldm_got.offset = -1;
3237 /* Allocate global sym .plt and .got entries, and space for global
3238 sym dynamic relocs. */
3239 elf_link_hash_traverse (&htab->elf, elf_i386_allocate_dynrelocs, info);
3241 /* Allocate .plt and .got entries, and space for local symbols. */
3242 htab_traverse (htab->loc_hash_table,
3243 elf_i386_allocate_local_dynrelocs,
3246 /* For every jump slot reserved in the sgotplt, reloc_count is
3247 incremented. However, when we reserve space for TLS descriptors,
3248 it's not incremented, so in order to compute the space reserved
3249 for them, it suffices to multiply the reloc count by the jump
3252 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3253 so that R_386_IRELATIVE entries come last. */
3254 if (htab->elf.srelplt)
3256 htab->next_tls_desc_index = htab->elf.srelplt->reloc_count;
3257 htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4;
3258 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
3260 else if (htab->elf.irelplt)
3261 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
3264 if (htab->elf.sgotplt)
3266 /* Don't allocate .got.plt section if there are no GOT nor PLT
3267 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
3268 if ((htab->elf.hgot == NULL
3269 || !htab->elf.hgot->ref_regular_nonweak)
3270 && (htab->elf.sgotplt->size
3271 == get_elf_backend_data (output_bfd)->got_header_size)
3272 && (htab->elf.splt == NULL
3273 || htab->elf.splt->size == 0)
3274 && (htab->elf.sgot == NULL
3275 || htab->elf.sgot->size == 0)
3276 && (htab->elf.iplt == NULL
3277 || htab->elf.iplt->size == 0)
3278 && (htab->elf.igotplt == NULL
3279 || htab->elf.igotplt->size == 0))
3280 htab->elf.sgotplt->size = 0;
3284 if (htab->plt_eh_frame != NULL
3285 && htab->elf.splt != NULL
3286 && htab->elf.splt->size != 0
3287 && !bfd_is_abs_section (htab->elf.splt->output_section)
3288 && _bfd_elf_eh_frame_present (info))
3289 htab->plt_eh_frame->size = sizeof (elf_i386_eh_frame_plt);
3291 /* We now have determined the sizes of the various dynamic sections.
3292 Allocate memory for them. */
3294 for (s = dynobj->sections; s != NULL; s = s->next)
3296 bfd_boolean strip_section = TRUE;
3298 if ((s->flags & SEC_LINKER_CREATED) == 0)
3301 if (s == htab->elf.splt
3302 || s == htab->elf.sgot)
3304 /* Strip this section if we don't need it; see the
3306 /* We'd like to strip these sections if they aren't needed, but if
3307 we've exported dynamic symbols from them we must leave them.
3308 It's too late to tell BFD to get rid of the symbols. */
3310 if (htab->elf.hplt != NULL)
3311 strip_section = FALSE;
3313 else if (s == htab->elf.sgotplt
3314 || s == htab->elf.iplt
3315 || s == htab->elf.igotplt
3316 || s == htab->plt_got
3317 || s == htab->plt_eh_frame
3318 || s == htab->sdynbss)
3320 /* Strip these too. */
3322 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rel"))
3325 && s != htab->elf.srelplt
3326 && s != htab->srelplt2)
3329 /* We use the reloc_count field as a counter if we need
3330 to copy relocs into the output file. */
3335 /* It's not one of our sections, so don't allocate space. */
3341 /* If we don't need this section, strip it from the
3342 output file. This is mostly to handle .rel.bss and
3343 .rel.plt. We must create both sections in
3344 create_dynamic_sections, because they must be created
3345 before the linker maps input sections to output
3346 sections. The linker does that before
3347 adjust_dynamic_symbol is called, and it is that
3348 function which decides whether anything needs to go
3349 into these sections. */
3351 s->flags |= SEC_EXCLUDE;
3355 if ((s->flags & SEC_HAS_CONTENTS) == 0)
3358 /* Allocate memory for the section contents. We use bfd_zalloc
3359 here in case unused entries are not reclaimed before the
3360 section's contents are written out. This should not happen,
3361 but this way if it does, we get a R_386_NONE reloc instead
3363 s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
3364 if (s->contents == NULL)
3368 if (htab->plt_eh_frame != NULL
3369 && htab->plt_eh_frame->contents != NULL)
3371 memcpy (htab->plt_eh_frame->contents, elf_i386_eh_frame_plt,
3372 sizeof (elf_i386_eh_frame_plt));
3373 bfd_put_32 (dynobj, htab->elf.splt->size,
3374 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
3377 if (htab->elf.dynamic_sections_created)
3379 /* Add some entries to the .dynamic section. We fill in the
3380 values later, in elf_i386_finish_dynamic_sections, but we
3381 must add the entries now so that we get the correct size for
3382 the .dynamic section. The DT_DEBUG entry is filled in by the
3383 dynamic linker and used by the debugger. */
3384 #define add_dynamic_entry(TAG, VAL) \
3385 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3387 if (bfd_link_executable (info))
3389 if (!add_dynamic_entry (DT_DEBUG, 0))
3393 if (htab->elf.splt->size != 0)
3395 /* DT_PLTGOT is used by prelink even if there is no PLT
3397 if (!add_dynamic_entry (DT_PLTGOT, 0))
3400 if (htab->elf.srelplt->size != 0)
3402 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3403 || !add_dynamic_entry (DT_PLTREL, DT_REL)
3404 || !add_dynamic_entry (DT_JMPREL, 0))
3411 if (!add_dynamic_entry (DT_REL, 0)
3412 || !add_dynamic_entry (DT_RELSZ, 0)
3413 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
3416 /* If any dynamic relocs apply to a read-only section,
3417 then we need a DT_TEXTREL entry. */
3418 if ((info->flags & DF_TEXTREL) == 0)
3419 elf_link_hash_traverse (&htab->elf,
3420 elf_i386_readonly_dynrelocs, info);
3422 if ((info->flags & DF_TEXTREL) != 0)
3424 if (htab->readonly_dynrelocs_against_ifunc)
3426 info->callbacks->einfo
3427 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3428 bfd_set_error (bfd_error_bad_value);
3432 if (!add_dynamic_entry (DT_TEXTREL, 0))
3436 if (get_elf_i386_backend_data (output_bfd)->is_vxworks
3437 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
3440 #undef add_dynamic_entry
3446 elf_i386_always_size_sections (bfd *output_bfd,
3447 struct bfd_link_info *info)
3449 asection *tls_sec = elf_hash_table (info)->tls_sec;
3453 struct elf_link_hash_entry *tlsbase;
3455 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
3456 "_TLS_MODULE_BASE_",
3457 FALSE, FALSE, FALSE);
3459 if (tlsbase && tlsbase->type == STT_TLS)
3461 struct elf_i386_link_hash_table *htab;
3462 struct bfd_link_hash_entry *bh = NULL;
3463 const struct elf_backend_data *bed
3464 = get_elf_backend_data (output_bfd);
3466 htab = elf_i386_hash_table (info);
3470 if (!(_bfd_generic_link_add_one_symbol
3471 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
3472 tls_sec, 0, NULL, FALSE,
3473 bed->collect, &bh)))
3476 htab->tls_module_base = bh;
3478 tlsbase = (struct elf_link_hash_entry *)bh;
3479 tlsbase->def_regular = 1;
3480 tlsbase->other = STV_HIDDEN;
3481 tlsbase->root.linker_def = 1;
3482 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
3489 /* Set the correct type for an x86 ELF section. We do this by the
3490 section name, which is a hack, but ought to work. */
3493 elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
3494 Elf_Internal_Shdr *hdr,
3499 name = bfd_get_section_name (abfd, sec);
3501 /* This is an ugly, but unfortunately necessary hack that is
3502 needed when producing EFI binaries on x86. It tells
3503 elf.c:elf_fake_sections() not to consider ".reloc" as a section
3504 containing ELF relocation info. We need this hack in order to
3505 be able to generate ELF binaries that can be translated into
3506 EFI applications (which are essentially COFF objects). Those
3507 files contain a COFF ".reloc" section inside an ELFNN object,
3508 which would normally cause BFD to segfault because it would
3509 attempt to interpret this section as containing relocation
3510 entries for section "oc". With this hack enabled, ".reloc"
3511 will be treated as a normal data section, which will avoid the
3512 segfault. However, you won't be able to create an ELFNN binary
3513 with a section named "oc" that needs relocations, but that's
3514 the kind of ugly side-effects you get when detecting section
3515 types based on their names... In practice, this limitation is
3516 unlikely to bite. */
3517 if (strcmp (name, ".reloc") == 0)
3518 hdr->sh_type = SHT_PROGBITS;
3523 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3524 executables. Rather than setting it to the beginning of the TLS
3525 section, we have to set it to the end. This function may be called
3526 multiple times, it is idempotent. */
3529 elf_i386_set_tls_module_base (struct bfd_link_info *info)
3531 struct elf_i386_link_hash_table *htab;
3532 struct bfd_link_hash_entry *base;
3534 if (!bfd_link_executable (info))
3537 htab = elf_i386_hash_table (info);
3541 base = htab->tls_module_base;
3545 base->u.def.value = htab->elf.tls_size;
3548 /* Return the base VMA address which should be subtracted from real addresses
3549 when resolving @dtpoff relocation.
3550 This is PT_TLS segment p_vaddr. */
3553 elf_i386_dtpoff_base (struct bfd_link_info *info)
3555 /* If tls_sec is NULL, we should have signalled an error already. */
3556 if (elf_hash_table (info)->tls_sec == NULL)
3558 return elf_hash_table (info)->tls_sec->vma;
3561 /* Return the relocation value for @tpoff relocation
3562 if STT_TLS virtual address is ADDRESS. */
3565 elf_i386_tpoff (struct bfd_link_info *info, bfd_vma address)
3567 struct elf_link_hash_table *htab = elf_hash_table (info);
3568 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3569 bfd_vma static_tls_size;
3571 /* If tls_sec is NULL, we should have signalled an error already. */
3572 if (htab->tls_sec == NULL)
3575 /* Consider special static TLS alignment requirements. */
3576 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3577 return static_tls_size + htab->tls_sec->vma - address;
3580 /* Relocate an i386 ELF section. */
3583 elf_i386_relocate_section (bfd *output_bfd,
3584 struct bfd_link_info *info,
3586 asection *input_section,
3588 Elf_Internal_Rela *relocs,
3589 Elf_Internal_Sym *local_syms,
3590 asection **local_sections)
3592 struct elf_i386_link_hash_table *htab;
3593 Elf_Internal_Shdr *symtab_hdr;
3594 struct elf_link_hash_entry **sym_hashes;
3595 bfd_vma *local_got_offsets;
3596 bfd_vma *local_tlsdesc_gotents;
3597 Elf_Internal_Rela *rel;
3598 Elf_Internal_Rela *wrel;
3599 Elf_Internal_Rela *relend;
3600 bfd_boolean is_vxworks_tls;
3601 unsigned plt_entry_size;
3603 BFD_ASSERT (is_i386_elf (input_bfd));
3605 /* Skip if check_relocs failed. */
3606 if (input_section->check_relocs_failed)
3609 htab = elf_i386_hash_table (info);
3612 symtab_hdr = &elf_symtab_hdr (input_bfd);
3613 sym_hashes = elf_sym_hashes (input_bfd);
3614 local_got_offsets = elf_local_got_offsets (input_bfd);
3615 local_tlsdesc_gotents = elf_i386_local_tlsdesc_gotent (input_bfd);
3616 /* We have to handle relocations in vxworks .tls_vars sections
3617 specially, because the dynamic loader is 'weird'. */
3618 is_vxworks_tls = (get_elf_i386_backend_data (output_bfd)->is_vxworks
3619 && bfd_link_pic (info)
3620 && !strcmp (input_section->output_section->name,
3623 elf_i386_set_tls_module_base (info);
3625 plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
3627 rel = wrel = relocs;
3628 relend = relocs + input_section->reloc_count;
3629 for (; rel < relend; wrel++, rel++)
3631 unsigned int r_type;
3632 reloc_howto_type *howto;
3633 unsigned long r_symndx;
3634 struct elf_link_hash_entry *h;
3635 struct elf_i386_link_hash_entry *eh;
3636 Elf_Internal_Sym *sym;
3638 bfd_vma off, offplt, plt_offset;
3640 bfd_boolean unresolved_reloc;
3641 bfd_reloc_status_type r;
3645 asection *resolved_plt;
3646 bfd_boolean resolved_to_zero;
3648 r_type = ELF32_R_TYPE (rel->r_info);
3649 if (r_type == R_386_GNU_VTINHERIT
3650 || r_type == R_386_GNU_VTENTRY)
3657 if ((indx = r_type) >= R_386_standard
3658 && ((indx = r_type - R_386_ext_offset) - R_386_standard
3659 >= R_386_ext - R_386_standard)
3660 && ((indx = r_type - R_386_tls_offset) - R_386_ext
3661 >= R_386_ext2 - R_386_ext))
3663 (*_bfd_error_handler)
3664 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3665 input_bfd, input_section, r_type);
3666 bfd_set_error (bfd_error_bad_value);
3669 howto = elf_howto_table + indx;
3671 r_symndx = ELF32_R_SYM (rel->r_info);
3675 unresolved_reloc = FALSE;
3676 if (r_symndx < symtab_hdr->sh_info)
3678 sym = local_syms + r_symndx;
3679 sec = local_sections[r_symndx];
3680 relocation = (sec->output_section->vma
3681 + sec->output_offset
3683 st_size = sym->st_size;
3685 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
3686 && ((sec->flags & SEC_MERGE) != 0
3687 || (bfd_link_relocatable (info)
3688 && sec->output_offset != 0)))
3691 bfd_byte *where = contents + rel->r_offset;
3693 switch (howto->size)
3696 addend = bfd_get_8 (input_bfd, where);
3697 if (howto->pc_relative)
3699 addend = (addend ^ 0x80) - 0x80;
3704 addend = bfd_get_16 (input_bfd, where);
3705 if (howto->pc_relative)
3707 addend = (addend ^ 0x8000) - 0x8000;
3712 addend = bfd_get_32 (input_bfd, where);
3713 if (howto->pc_relative)
3715 addend = (addend ^ 0x80000000) - 0x80000000;
3723 if (bfd_link_relocatable (info))
3724 addend += sec->output_offset;
3727 asection *msec = sec;
3728 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
3730 addend -= relocation;
3731 addend += msec->output_section->vma + msec->output_offset;
3734 switch (howto->size)
3737 /* FIXME: overflow checks. */
3738 if (howto->pc_relative)
3740 bfd_put_8 (input_bfd, addend, where);
3743 if (howto->pc_relative)
3745 bfd_put_16 (input_bfd, addend, where);
3748 if (howto->pc_relative)
3750 bfd_put_32 (input_bfd, addend, where);
3754 else if (!bfd_link_relocatable (info)
3755 && ELF32_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3757 /* Relocate against local STT_GNU_IFUNC symbol. */
3758 h = elf_i386_get_local_sym_hash (htab, input_bfd, rel,
3763 /* Set STT_GNU_IFUNC symbol value. */
3764 h->root.u.def.value = sym->st_value;
3765 h->root.u.def.section = sec;
3770 bfd_boolean warned ATTRIBUTE_UNUSED;
3771 bfd_boolean ignored ATTRIBUTE_UNUSED;
3773 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3774 r_symndx, symtab_hdr, sym_hashes,
3776 unresolved_reloc, warned, ignored);
3780 if (sec != NULL && discarded_section (sec))
3782 _bfd_clear_contents (howto, input_bfd, input_section,
3783 contents + rel->r_offset);
3784 wrel->r_offset = rel->r_offset;
3788 /* For ld -r, remove relocations in debug sections against
3789 sections defined in discarded sections. Not done for
3790 eh_frame editing code expects to be present. */
3791 if (bfd_link_relocatable (info)
3792 && (input_section->flags & SEC_DEBUGGING))
3798 if (bfd_link_relocatable (info))
3805 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3806 it here if it is defined in a non-shared object. */
3808 && h->type == STT_GNU_IFUNC
3811 asection *plt, *gotplt, *base_got;
3815 if ((input_section->flags & SEC_ALLOC) == 0)
3817 /* Dynamic relocs are not propagated for SEC_DEBUGGING
3818 sections because such sections are not SEC_ALLOC and
3819 thus ld.so will not process them. */
3820 if ((input_section->flags & SEC_DEBUGGING) != 0)
3824 else if (h->plt.offset == (bfd_vma) -1)
3827 /* STT_GNU_IFUNC symbol must go through PLT. */
3828 if (htab->elf.splt != NULL)
3830 plt = htab->elf.splt;
3831 gotplt = htab->elf.sgotplt;
3835 plt = htab->elf.iplt;
3836 gotplt = htab->elf.igotplt;
3839 relocation = (plt->output_section->vma
3840 + plt->output_offset + h->plt.offset);
3845 if (h->root.root.string)
3846 name = h->root.root.string;
3848 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3850 (*_bfd_error_handler)
3851 (_("%B: relocation %s against STT_GNU_IFUNC "
3852 "symbol `%s' isn't handled by %s"), input_bfd,
3853 elf_howto_table[r_type].name,
3854 name, __FUNCTION__);
3855 bfd_set_error (bfd_error_bad_value);
3859 /* Generate dynamic relcoation only when there is a
3860 non-GOT reference in a shared object. */
3861 if (bfd_link_pic (info) && h->non_got_ref)
3863 Elf_Internal_Rela outrel;
3867 /* Need a dynamic relocation to get the real function
3869 offset = _bfd_elf_section_offset (output_bfd,
3873 if (offset == (bfd_vma) -1
3874 || offset == (bfd_vma) -2)
3877 outrel.r_offset = (input_section->output_section->vma
3878 + input_section->output_offset
3881 if (h->dynindx == -1
3883 || bfd_link_executable (info))
3885 /* This symbol is resolved locally. */
3886 outrel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
3887 bfd_put_32 (output_bfd,
3888 (h->root.u.def.value
3889 + h->root.u.def.section->output_section->vma
3890 + h->root.u.def.section->output_offset),
3894 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3896 sreloc = htab->elf.irelifunc;
3897 elf_append_rel (output_bfd, sreloc, &outrel);
3899 /* If this reloc is against an external symbol, we
3900 do not want to fiddle with the addend. Otherwise,
3901 we need to include the symbol value so that it
3902 becomes an addend for the dynamic reloc. For an
3903 internal symbol, we have updated addend. */
3913 base_got = htab->elf.sgot;
3914 off = h->got.offset;
3916 if (base_got == NULL)
3919 if (off == (bfd_vma) -1)
3921 /* We can't use h->got.offset here to save state, or
3922 even just remember the offset, as finish_dynamic_symbol
3923 would use that as offset into .got. */
3925 if (htab->elf.splt != NULL)
3927 plt_index = h->plt.offset / plt_entry_size - 1;
3928 off = (plt_index + 3) * 4;
3929 base_got = htab->elf.sgotplt;
3933 plt_index = h->plt.offset / plt_entry_size;
3934 off = plt_index * 4;
3935 base_got = htab->elf.igotplt;
3938 if (h->dynindx == -1
3942 /* This references the local defitionion. We must
3943 initialize this entry in the global offset table.
3944 Since the offset must always be a multiple of 8,
3945 we use the least significant bit to record
3946 whether we have initialized it already.
3948 When doing a dynamic link, we create a .rela.got
3949 relocation entry to initialize the value. This
3950 is done in the finish_dynamic_symbol routine. */
3955 bfd_put_32 (output_bfd, relocation,
3956 base_got->contents + off);
3963 /* Adjust for static executables. */
3964 if (htab->elf.splt == NULL)
3965 relocation += gotplt->output_offset;
3969 relocation = (base_got->output_section->vma
3970 + base_got->output_offset + off
3971 - gotplt->output_section->vma
3972 - gotplt->output_offset);
3973 /* Adjust for static executables. */
3974 if (htab->elf.splt == NULL)
3975 relocation += gotplt->output_offset;
3981 relocation -= (gotplt->output_section->vma
3982 + gotplt->output_offset);
3987 eh = (struct elf_i386_link_hash_entry *) h;
3988 resolved_to_zero = (eh != NULL
3989 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
3996 /* Avoid optimizing _DYNAMIC since ld.so may use its
3997 link-time address. */
3998 if (h == htab->elf.hdynamic)
4001 if (bfd_link_pic (info))
4003 /* It is OK to convert mov to lea and convert indirect
4004 branch to direct branch. It is OK to convert adc,
4005 add, and, cmp, or, sbb, sub, test, xor only when PIC
4007 unsigned int opcode, addend;
4008 addend = bfd_get_32 (input_bfd, contents + rel->r_offset);
4011 opcode = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
4012 if (opcode != 0x8b && opcode != 0xff)
4016 /* Resolve "mov GOT[(%reg)], %reg",
4017 "call/jmp *GOT[(%reg)]", "test %reg, foo@GOT[(%reg)]"
4018 and "binop foo@GOT[(%reg)], %reg". */
4020 || (h->plt.offset == (bfd_vma) -1
4021 && h->got.offset == (bfd_vma) -1)
4022 || htab->elf.sgotplt == NULL)
4025 offplt = (htab->elf.sgotplt->output_section->vma
4026 + htab->elf.sgotplt->output_offset);
4028 /* It is relative to .got.plt section. */
4029 if (h->got.offset != (bfd_vma) -1)
4030 /* Use GOT entry. Mask off the least significant bit in
4031 GOT offset which may be set by R_386_GOT32 processing
4033 relocation = (htab->elf.sgot->output_section->vma
4034 + htab->elf.sgot->output_offset
4035 + (h->got.offset & ~1) - offplt);
4037 /* Use GOTPLT entry. */
4038 relocation = (h->plt.offset / plt_entry_size - 1 + 3) * 4;
4040 if (!bfd_link_pic (info))
4042 /* If not PIC, add the .got.plt section address for
4043 baseless addressing. */
4045 modrm = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4046 if ((modrm & 0xc7) == 0x5)
4047 relocation += offplt;
4050 unresolved_reloc = FALSE;
4055 /* Relocation is to the entry for this symbol in the global
4057 if (htab->elf.sgot == NULL)
4064 off = h->got.offset;
4065 dyn = htab->elf.dynamic_sections_created;
4066 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4067 bfd_link_pic (info),
4069 || (bfd_link_pic (info)
4070 && SYMBOL_REFERENCES_LOCAL (info, h))
4071 || (ELF_ST_VISIBILITY (h->other)
4072 && h->root.type == bfd_link_hash_undefweak))
4074 /* This is actually a static link, or it is a
4075 -Bsymbolic link and the symbol is defined
4076 locally, or the symbol was forced to be local
4077 because of a version file. We must initialize
4078 this entry in the global offset table. Since the
4079 offset must always be a multiple of 4, we use the
4080 least significant bit to record whether we have
4081 initialized it already.
4083 When doing a dynamic link, we create a .rel.got
4084 relocation entry to initialize the value. This
4085 is done in the finish_dynamic_symbol routine. */
4090 bfd_put_32 (output_bfd, relocation,
4091 htab->elf.sgot->contents + off);
4096 unresolved_reloc = FALSE;
4100 if (local_got_offsets == NULL)
4103 off = local_got_offsets[r_symndx];
4105 /* The offset must always be a multiple of 4. We use
4106 the least significant bit to record whether we have
4107 already generated the necessary reloc. */
4112 bfd_put_32 (output_bfd, relocation,
4113 htab->elf.sgot->contents + off);
4115 if (bfd_link_pic (info))
4118 Elf_Internal_Rela outrel;
4120 s = htab->elf.srelgot;
4124 outrel.r_offset = (htab->elf.sgot->output_section->vma
4125 + htab->elf.sgot->output_offset
4127 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4128 elf_append_rel (output_bfd, s, &outrel);
4131 local_got_offsets[r_symndx] |= 1;
4135 if (off >= (bfd_vma) -2)
4138 relocation = htab->elf.sgot->output_section->vma
4139 + htab->elf.sgot->output_offset + off
4140 - htab->elf.sgotplt->output_section->vma
4141 - htab->elf.sgotplt->output_offset;
4145 /* Relocation is relative to the start of the global offset
4148 /* Check to make sure it isn't a protected function or data
4149 symbol for shared library since it may not be local when
4150 used as function address or with copy relocation. We also
4151 need to make sure that a symbol is referenced locally. */
4152 if (!bfd_link_executable (info) && h)
4154 if (!h->def_regular)
4158 switch (ELF_ST_VISIBILITY (h->other))
4161 v = _("hidden symbol");
4164 v = _("internal symbol");
4167 v = _("protected symbol");
4174 (*_bfd_error_handler)
4175 (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
4176 input_bfd, v, h->root.root.string);
4177 bfd_set_error (bfd_error_bad_value);
4180 else if (!SYMBOL_REFERENCES_LOCAL (info, h)
4181 && (h->type == STT_FUNC
4182 || h->type == STT_OBJECT)
4183 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
4185 (*_bfd_error_handler)
4186 (_("%B: relocation R_386_GOTOFF against protected %s `%s' can not be used when making a shared object"),
4188 h->type == STT_FUNC ? "function" : "data",
4189 h->root.root.string);
4190 bfd_set_error (bfd_error_bad_value);
4195 /* Note that sgot is not involved in this
4196 calculation. We always want the start of .got.plt. If we
4197 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4198 permitted by the ABI, we might have to change this
4200 relocation -= htab->elf.sgotplt->output_section->vma
4201 + htab->elf.sgotplt->output_offset;
4205 /* Use global offset table as symbol value. */
4206 relocation = htab->elf.sgotplt->output_section->vma
4207 + htab->elf.sgotplt->output_offset;
4208 unresolved_reloc = FALSE;
4212 /* Relocation is to the entry for this symbol in the
4213 procedure linkage table. */
4215 /* Resolve a PLT32 reloc against a local symbol directly,
4216 without using the procedure linkage table. */
4220 if ((h->plt.offset == (bfd_vma) -1
4221 && eh->plt_got.offset == (bfd_vma) -1)
4222 || htab->elf.splt == NULL)
4224 /* We didn't make a PLT entry for this symbol. This
4225 happens when statically linking PIC code, or when
4226 using -Bsymbolic. */
4230 if (h->plt.offset != (bfd_vma) -1)
4232 resolved_plt = htab->elf.splt;
4233 plt_offset = h->plt.offset;
4237 resolved_plt = htab->plt_got;
4238 plt_offset = eh->plt_got.offset;
4241 relocation = (resolved_plt->output_section->vma
4242 + resolved_plt->output_offset
4244 unresolved_reloc = FALSE;
4248 /* Set to symbol size. */
4249 relocation = st_size;
4254 if ((input_section->flags & SEC_ALLOC) == 0
4258 /* Copy dynamic function pointer relocations. Don't generate
4259 dynamic relocations against resolved undefined weak symbols
4260 in PIE, except for R_386_PC32. */
4261 if ((bfd_link_pic (info)
4263 || ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4264 && (!resolved_to_zero
4265 || r_type == R_386_PC32))
4266 || h->root.type != bfd_link_hash_undefweak))
4267 && ((r_type != R_386_PC32 && r_type != R_386_SIZE32)
4268 || !SYMBOL_CALLS_LOCAL (info, h)))
4269 || (ELIMINATE_COPY_RELOCS
4270 && !bfd_link_pic (info)
4274 || eh->func_pointer_refcount > 0
4275 || (h->root.type == bfd_link_hash_undefweak
4276 && !resolved_to_zero))
4277 && ((h->def_dynamic && !h->def_regular)
4278 /* Undefined weak symbol is bound locally when
4280 || h->root.type == bfd_link_hash_undefweak)))
4282 Elf_Internal_Rela outrel;
4283 bfd_boolean skip, relocate;
4286 /* When generating a shared object, these relocations
4287 are copied into the output file to be resolved at run
4294 _bfd_elf_section_offset (output_bfd, info, input_section,
4296 if (outrel.r_offset == (bfd_vma) -1)
4298 else if (outrel.r_offset == (bfd_vma) -2)
4299 skip = TRUE, relocate = TRUE;
4300 outrel.r_offset += (input_section->output_section->vma
4301 + input_section->output_offset);
4304 memset (&outrel, 0, sizeof outrel);
4307 && (r_type == R_386_PC32
4308 || !(bfd_link_executable (info)
4309 || SYMBOLIC_BIND (info, h))
4310 || !h->def_regular))
4311 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4314 /* This symbol is local, or marked to become local. */
4316 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4319 sreloc = elf_section_data (input_section)->sreloc;
4321 if (sreloc == NULL || sreloc->contents == NULL)
4323 r = bfd_reloc_notsupported;
4324 goto check_relocation_error;
4327 elf_append_rel (output_bfd, sreloc, &outrel);
4329 /* If this reloc is against an external symbol, we do
4330 not want to fiddle with the addend. Otherwise, we
4331 need to include the symbol value so that it becomes
4332 an addend for the dynamic reloc. */
4339 if (!bfd_link_executable (info))
4341 Elf_Internal_Rela outrel;
4344 outrel.r_offset = rel->r_offset
4345 + input_section->output_section->vma
4346 + input_section->output_offset;
4347 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4348 sreloc = elf_section_data (input_section)->sreloc;
4351 elf_append_rel (output_bfd, sreloc, &outrel);
4356 case R_386_TLS_GOTDESC:
4357 case R_386_TLS_DESC_CALL:
4358 case R_386_TLS_IE_32:
4359 case R_386_TLS_GOTIE:
4360 tls_type = GOT_UNKNOWN;
4361 if (h == NULL && local_got_offsets)
4362 tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
4364 tls_type = elf_i386_hash_entry(h)->tls_type;
4365 if (tls_type == GOT_TLS_IE)
4366 tls_type = GOT_TLS_IE_NEG;
4368 if (! elf_i386_tls_transition (info, input_bfd,
4369 input_section, contents,
4370 symtab_hdr, sym_hashes,
4371 &r_type, tls_type, rel,
4372 relend, h, r_symndx, TRUE))
4375 if (r_type == R_386_TLS_LE_32)
4377 BFD_ASSERT (! unresolved_reloc);
4378 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
4383 /* GD->LE transition. */
4384 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
4387 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
4389 movl %gs:0, %eax; subl $foo@tpoff, %eax
4390 (6 byte form of subl). */
4391 memcpy (contents + rel->r_offset - 3,
4392 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
4393 roff = rel->r_offset + 5;
4397 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
4399 movl %gs:0, %eax; subl $foo@tpoff, %eax
4400 (6 byte form of subl). */
4401 memcpy (contents + rel->r_offset - 2,
4402 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
4403 roff = rel->r_offset + 6;
4405 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
4407 /* Skip R_386_PC32/R_386_PLT32. */
4412 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4414 /* GDesc -> LE transition.
4415 It's originally something like:
4416 leal x@tlsdesc(%ebx), %eax
4420 Registers other than %eax may be set up here. */
4425 roff = rel->r_offset;
4426 val = bfd_get_8 (input_bfd, contents + roff - 1);
4428 /* Now modify the instruction as appropriate. */
4429 /* aoliva FIXME: remove the above and xor the byte
4431 bfd_put_8 (output_bfd, val ^ 0x86,
4432 contents + roff - 1);
4433 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
4437 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4439 /* GDesc -> LE transition.
4447 roff = rel->r_offset;
4448 bfd_put_8 (output_bfd, 0x66, contents + roff);
4449 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4452 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
4456 /* IE->LE transition:
4457 Originally it can be one of:
4465 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4468 /* movl foo, %eax. */
4469 bfd_put_8 (output_bfd, 0xb8,
4470 contents + rel->r_offset - 1);
4476 type = bfd_get_8 (input_bfd,
4477 contents + rel->r_offset - 2);
4482 bfd_put_8 (output_bfd, 0xc7,
4483 contents + rel->r_offset - 2);
4484 bfd_put_8 (output_bfd,
4485 0xc0 | ((val >> 3) & 7),
4486 contents + rel->r_offset - 1);
4490 bfd_put_8 (output_bfd, 0x81,
4491 contents + rel->r_offset - 2);
4492 bfd_put_8 (output_bfd,
4493 0xc0 | ((val >> 3) & 7),
4494 contents + rel->r_offset - 1);
4501 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
4502 contents + rel->r_offset);
4507 unsigned int val, type;
4509 /* {IE_32,GOTIE}->LE transition:
4510 Originally it can be one of:
4511 subl foo(%reg1), %reg2
4512 movl foo(%reg1), %reg2
4513 addl foo(%reg1), %reg2
4516 movl $foo, %reg2 (6 byte form)
4517 addl $foo, %reg2. */
4518 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
4519 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4523 bfd_put_8 (output_bfd, 0xc7,
4524 contents + rel->r_offset - 2);
4525 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4526 contents + rel->r_offset - 1);
4528 else if (type == 0x2b)
4531 bfd_put_8 (output_bfd, 0x81,
4532 contents + rel->r_offset - 2);
4533 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
4534 contents + rel->r_offset - 1);
4536 else if (type == 0x03)
4539 bfd_put_8 (output_bfd, 0x81,
4540 contents + rel->r_offset - 2);
4541 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4542 contents + rel->r_offset - 1);
4546 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
4547 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
4548 contents + rel->r_offset);
4550 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
4551 contents + rel->r_offset);
4556 if (htab->elf.sgot == NULL)
4561 off = h->got.offset;
4562 offplt = elf_i386_hash_entry (h)->tlsdesc_got;
4566 if (local_got_offsets == NULL)
4569 off = local_got_offsets[r_symndx];
4570 offplt = local_tlsdesc_gotents[r_symndx];
4577 Elf_Internal_Rela outrel;
4581 if (htab->elf.srelgot == NULL)
4584 indx = h && h->dynindx != -1 ? h->dynindx : 0;
4586 if (GOT_TLS_GDESC_P (tls_type))
4589 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
4590 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
4591 <= htab->elf.sgotplt->size);
4592 outrel.r_offset = (htab->elf.sgotplt->output_section->vma
4593 + htab->elf.sgotplt->output_offset
4595 + htab->sgotplt_jump_table_size);
4596 sreloc = htab->elf.srelplt;
4597 loc = sreloc->contents;
4598 loc += (htab->next_tls_desc_index++
4599 * sizeof (Elf32_External_Rel));
4600 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
4601 <= sreloc->contents + sreloc->size);
4602 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4605 BFD_ASSERT (! unresolved_reloc);
4606 bfd_put_32 (output_bfd,
4607 relocation - elf_i386_dtpoff_base (info),
4608 htab->elf.sgotplt->contents + offplt
4609 + htab->sgotplt_jump_table_size + 4);
4613 bfd_put_32 (output_bfd, 0,
4614 htab->elf.sgotplt->contents + offplt
4615 + htab->sgotplt_jump_table_size + 4);
4619 sreloc = htab->elf.srelgot;
4621 outrel.r_offset = (htab->elf.sgot->output_section->vma
4622 + htab->elf.sgot->output_offset + off);
4624 if (GOT_TLS_GD_P (tls_type))
4625 dr_type = R_386_TLS_DTPMOD32;
4626 else if (GOT_TLS_GDESC_P (tls_type))
4628 else if (tls_type == GOT_TLS_IE_POS)
4629 dr_type = R_386_TLS_TPOFF;
4631 dr_type = R_386_TLS_TPOFF32;
4633 if (dr_type == R_386_TLS_TPOFF && indx == 0)
4634 bfd_put_32 (output_bfd,
4635 relocation - elf_i386_dtpoff_base (info),
4636 htab->elf.sgot->contents + off);
4637 else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
4638 bfd_put_32 (output_bfd,
4639 elf_i386_dtpoff_base (info) - relocation,
4640 htab->elf.sgot->contents + off);
4641 else if (dr_type != R_386_TLS_DESC)
4642 bfd_put_32 (output_bfd, 0,
4643 htab->elf.sgot->contents + off);
4644 outrel.r_info = ELF32_R_INFO (indx, dr_type);
4646 elf_append_rel (output_bfd, sreloc, &outrel);
4648 if (GOT_TLS_GD_P (tls_type))
4652 BFD_ASSERT (! unresolved_reloc);
4653 bfd_put_32 (output_bfd,
4654 relocation - elf_i386_dtpoff_base (info),
4655 htab->elf.sgot->contents + off + 4);
4659 bfd_put_32 (output_bfd, 0,
4660 htab->elf.sgot->contents + off + 4);
4661 outrel.r_info = ELF32_R_INFO (indx,
4662 R_386_TLS_DTPOFF32);
4663 outrel.r_offset += 4;
4664 elf_append_rel (output_bfd, sreloc, &outrel);
4667 else if (tls_type == GOT_TLS_IE_BOTH)
4669 bfd_put_32 (output_bfd,
4671 ? relocation - elf_i386_dtpoff_base (info)
4673 htab->elf.sgot->contents + off + 4);
4674 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4675 outrel.r_offset += 4;
4676 elf_append_rel (output_bfd, sreloc, &outrel);
4683 local_got_offsets[r_symndx] |= 1;
4686 if (off >= (bfd_vma) -2
4687 && ! GOT_TLS_GDESC_P (tls_type))
4689 if (r_type == R_386_TLS_GOTDESC
4690 || r_type == R_386_TLS_DESC_CALL)
4692 relocation = htab->sgotplt_jump_table_size + offplt;
4693 unresolved_reloc = FALSE;
4695 else if (r_type == ELF32_R_TYPE (rel->r_info))
4697 bfd_vma g_o_t = htab->elf.sgotplt->output_section->vma
4698 + htab->elf.sgotplt->output_offset;
4699 relocation = htab->elf.sgot->output_section->vma
4700 + htab->elf.sgot->output_offset + off - g_o_t;
4701 if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
4702 && tls_type == GOT_TLS_IE_BOTH)
4704 if (r_type == R_386_TLS_IE)
4705 relocation += g_o_t;
4706 unresolved_reloc = FALSE;
4708 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
4710 unsigned int val, type;
4713 /* GD->IE transition. */
4714 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
4715 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4718 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
4720 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
4722 roff = rel->r_offset - 3;
4726 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
4728 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
4729 roff = rel->r_offset - 2;
4731 memcpy (contents + roff,
4732 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
4733 contents[roff + 7] = 0x80 | (val & 7);
4734 /* If foo is used only with foo@gotntpoff(%reg) and
4735 foo@indntpoff, but not with foo@gottpoff(%reg), change
4736 subl $foo@gottpoff(%reg), %eax
4738 addl $foo@gotntpoff(%reg), %eax. */
4739 if (tls_type == GOT_TLS_IE_POS)
4740 contents[roff + 6] = 0x03;
4741 bfd_put_32 (output_bfd,
4742 htab->elf.sgot->output_section->vma
4743 + htab->elf.sgot->output_offset + off
4744 - htab->elf.sgotplt->output_section->vma
4745 - htab->elf.sgotplt->output_offset,
4746 contents + roff + 8);
4747 /* Skip R_386_PLT32. */
4752 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4754 /* GDesc -> IE transition.
4755 It's originally something like:
4756 leal x@tlsdesc(%ebx), %eax
4759 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
4761 movl x@gottpoff(%ebx), %eax # before negl %eax
4763 Registers other than %eax may be set up here. */
4767 /* First, make sure it's a leal adding ebx to a 32-bit
4768 offset into any register, although it's probably
4769 almost always going to be eax. */
4770 roff = rel->r_offset;
4772 /* Now modify the instruction as appropriate. */
4773 /* To turn a leal into a movl in the form we use it, it
4774 suffices to change the first byte from 0x8d to 0x8b.
4775 aoliva FIXME: should we decide to keep the leal, all
4776 we have to do is remove the statement below, and
4777 adjust the relaxation of R_386_TLS_DESC_CALL. */
4778 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4780 if (tls_type == GOT_TLS_IE_BOTH)
4783 bfd_put_32 (output_bfd,
4784 htab->elf.sgot->output_section->vma
4785 + htab->elf.sgot->output_offset + off
4786 - htab->elf.sgotplt->output_section->vma
4787 - htab->elf.sgotplt->output_offset,
4791 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4793 /* GDesc -> IE transition.
4801 depending on how we transformed the TLS_GOTDESC above.
4806 roff = rel->r_offset;
4808 /* Now modify the instruction as appropriate. */
4809 if (tls_type != GOT_TLS_IE_NEG)
4812 bfd_put_8 (output_bfd, 0x66, contents + roff);
4813 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4818 bfd_put_8 (output_bfd, 0xf7, contents + roff);
4819 bfd_put_8 (output_bfd, 0xd8, contents + roff + 1);
4829 if (! elf_i386_tls_transition (info, input_bfd,
4830 input_section, contents,
4831 symtab_hdr, sym_hashes,
4832 &r_type, GOT_UNKNOWN, rel,
4833 relend, h, r_symndx, TRUE))
4836 if (r_type != R_386_TLS_LDM)
4838 /* LD->LE transition:
4839 leal foo(%reg), %eax; call ___tls_get_addr.
4841 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
4842 BFD_ASSERT (r_type == R_386_TLS_LE_32);
4843 memcpy (contents + rel->r_offset - 2,
4844 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
4845 /* Skip R_386_PC32/R_386_PLT32. */
4851 if (htab->elf.sgot == NULL)
4854 off = htab->tls_ldm_got.offset;
4859 Elf_Internal_Rela outrel;
4861 if (htab->elf.srelgot == NULL)
4864 outrel.r_offset = (htab->elf.sgot->output_section->vma
4865 + htab->elf.sgot->output_offset + off);
4867 bfd_put_32 (output_bfd, 0,
4868 htab->elf.sgot->contents + off);
4869 bfd_put_32 (output_bfd, 0,
4870 htab->elf.sgot->contents + off + 4);
4871 outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
4872 elf_append_rel (output_bfd, htab->elf.srelgot, &outrel);
4873 htab->tls_ldm_got.offset |= 1;
4875 relocation = htab->elf.sgot->output_section->vma
4876 + htab->elf.sgot->output_offset + off
4877 - htab->elf.sgotplt->output_section->vma
4878 - htab->elf.sgotplt->output_offset;
4879 unresolved_reloc = FALSE;
4882 case R_386_TLS_LDO_32:
4883 if (!bfd_link_executable (info)
4884 || (input_section->flags & SEC_CODE) == 0)
4885 relocation -= elf_i386_dtpoff_base (info);
4887 /* When converting LDO to LE, we must negate. */
4888 relocation = -elf_i386_tpoff (info, relocation);
4891 case R_386_TLS_LE_32:
4893 if (!bfd_link_executable (info))
4895 Elf_Internal_Rela outrel;
4898 outrel.r_offset = rel->r_offset
4899 + input_section->output_section->vma
4900 + input_section->output_offset;
4901 if (h != NULL && h->dynindx != -1)
4905 if (r_type == R_386_TLS_LE_32)
4906 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
4908 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4909 sreloc = elf_section_data (input_section)->sreloc;
4912 elf_append_rel (output_bfd, sreloc, &outrel);
4915 else if (r_type == R_386_TLS_LE_32)
4916 relocation = elf_i386_dtpoff_base (info) - relocation;
4918 relocation -= elf_i386_dtpoff_base (info);
4920 else if (r_type == R_386_TLS_LE_32)
4921 relocation = elf_i386_tpoff (info, relocation);
4923 relocation = -elf_i386_tpoff (info, relocation);
4930 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4931 because such sections are not SEC_ALLOC and thus ld.so will
4932 not process them. */
4933 if (unresolved_reloc
4934 && !((input_section->flags & SEC_DEBUGGING) != 0
4936 && _bfd_elf_section_offset (output_bfd, info, input_section,
4937 rel->r_offset) != (bfd_vma) -1)
4939 (*_bfd_error_handler)
4940 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4943 (long) rel->r_offset,
4945 h->root.root.string);
4950 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4951 contents, rel->r_offset,
4954 check_relocation_error:
4955 if (r != bfd_reloc_ok)
4960 name = h->root.root.string;
4963 name = bfd_elf_string_from_elf_section (input_bfd,
4964 symtab_hdr->sh_link,
4969 name = bfd_section_name (input_bfd, sec);
4972 if (r == bfd_reloc_overflow)
4974 if (! ((*info->callbacks->reloc_overflow)
4975 (info, (h ? &h->root : NULL), name, howto->name,
4976 (bfd_vma) 0, input_bfd, input_section,
4982 (*_bfd_error_handler)
4983 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4984 input_bfd, input_section,
4985 (long) rel->r_offset, name, (int) r);
4996 Elf_Internal_Shdr *rel_hdr;
4997 size_t deleted = rel - wrel;
4999 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
5000 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
5001 if (rel_hdr->sh_size == 0)
5003 /* It is too late to remove an empty reloc section. Leave
5005 ??? What is wrong with an empty section??? */
5006 rel_hdr->sh_size = rel_hdr->sh_entsize;
5009 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
5010 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
5011 input_section->reloc_count -= deleted;
5017 /* Finish up dynamic symbol handling. We set the contents of various
5018 dynamic sections here. */
5021 elf_i386_finish_dynamic_symbol (bfd *output_bfd,
5022 struct bfd_link_info *info,
5023 struct elf_link_hash_entry *h,
5024 Elf_Internal_Sym *sym)
5026 struct elf_i386_link_hash_table *htab;
5027 unsigned plt_entry_size;
5028 const struct elf_i386_backend_data *abed;
5029 struct elf_i386_link_hash_entry *eh;
5030 bfd_boolean local_undefweak;
5032 htab = elf_i386_hash_table (info);
5036 abed = get_elf_i386_backend_data (output_bfd);
5037 plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
5039 eh = (struct elf_i386_link_hash_entry *) h;
5041 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5042 resolved undefined weak symbols in executable so that their
5043 references have value 0 at run-time. */
5044 local_undefweak = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
5048 if (h->plt.offset != (bfd_vma) -1)
5052 Elf_Internal_Rela rel;
5054 asection *plt, *gotplt, *relplt;
5056 /* When building a static executable, use .iplt, .igot.plt and
5057 .rel.iplt sections for STT_GNU_IFUNC symbols. */
5058 if (htab->elf.splt != NULL)
5060 plt = htab->elf.splt;
5061 gotplt = htab->elf.sgotplt;
5062 relplt = htab->elf.srelplt;
5066 plt = htab->elf.iplt;
5067 gotplt = htab->elf.igotplt;
5068 relplt = htab->elf.irelplt;
5071 /* This symbol has an entry in the procedure linkage table. Set
5074 if ((h->dynindx == -1
5076 && !((h->forced_local || bfd_link_executable (info))
5078 && h->type == STT_GNU_IFUNC))
5084 /* Get the index in the procedure linkage table which
5085 corresponds to this symbol. This is the index of this symbol
5086 in all the symbols for which we are making plt entries. The
5087 first entry in the procedure linkage table is reserved.
5089 Get the offset into the .got table of the entry that
5090 corresponds to this function. Each .got entry is 4 bytes.
5091 The first three are reserved.
5093 For static executables, we don't reserve anything. */
5095 if (plt == htab->elf.splt)
5097 got_offset = h->plt.offset / plt_entry_size - 1;
5098 got_offset = (got_offset + 3) * 4;
5102 got_offset = h->plt.offset / plt_entry_size;
5103 got_offset = got_offset * 4;
5106 /* Fill in the entry in the procedure linkage table. */
5107 if (! bfd_link_pic (info))
5109 memcpy (plt->contents + h->plt.offset, abed->plt->plt_entry,
5110 abed->plt->plt_entry_size);
5111 bfd_put_32 (output_bfd,
5112 (gotplt->output_section->vma
5113 + gotplt->output_offset
5115 plt->contents + h->plt.offset
5116 + abed->plt->plt_got_offset);
5118 if (abed->is_vxworks)
5120 int s, k, reloc_index;
5122 /* Create the R_386_32 relocation referencing the GOT
5123 for this PLT entry. */
5125 /* S: Current slot number (zero-based). */
5126 s = ((h->plt.offset - abed->plt->plt_entry_size)
5127 / abed->plt->plt_entry_size);
5128 /* K: Number of relocations for PLTResolve. */
5129 if (bfd_link_pic (info))
5130 k = PLTRESOLVE_RELOCS_SHLIB;
5132 k = PLTRESOLVE_RELOCS;
5133 /* Skip the PLTresolve relocations, and the relocations for
5134 the other PLT slots. */
5135 reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
5136 loc = (htab->srelplt2->contents + reloc_index
5137 * sizeof (Elf32_External_Rel));
5139 rel.r_offset = (htab->elf.splt->output_section->vma
5140 + htab->elf.splt->output_offset
5141 + h->plt.offset + 2),
5142 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
5143 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5145 /* Create the R_386_32 relocation referencing the beginning of
5146 the PLT for this GOT entry. */
5147 rel.r_offset = (htab->elf.sgotplt->output_section->vma
5148 + htab->elf.sgotplt->output_offset
5150 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
5151 bfd_elf32_swap_reloc_out (output_bfd, &rel,
5152 loc + sizeof (Elf32_External_Rel));
5157 memcpy (plt->contents + h->plt.offset, abed->plt->pic_plt_entry,
5158 abed->plt->plt_entry_size);
5159 bfd_put_32 (output_bfd, got_offset,
5160 plt->contents + h->plt.offset
5161 + abed->plt->plt_got_offset);
5164 /* Fill in the entry in the global offset table. Leave the entry
5165 as zero for undefined weak symbol in PIE. No PLT relocation
5166 against undefined weak symbol in PIE. */
5167 if (!local_undefweak)
5169 bfd_put_32 (output_bfd,
5170 (plt->output_section->vma
5171 + plt->output_offset
5173 + abed->plt->plt_lazy_offset),
5174 gotplt->contents + got_offset);
5176 /* Fill in the entry in the .rel.plt section. */
5177 rel.r_offset = (gotplt->output_section->vma
5178 + gotplt->output_offset
5180 if (h->dynindx == -1
5181 || ((bfd_link_executable (info)
5182 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
5184 && h->type == STT_GNU_IFUNC))
5186 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5187 R_386_IRELATIVE instead of R_386_JUMP_SLOT. Store addend
5188 in the .got.plt section. */
5189 bfd_put_32 (output_bfd,
5190 (h->root.u.def.value
5191 + h->root.u.def.section->output_section->vma
5192 + h->root.u.def.section->output_offset),
5193 gotplt->contents + got_offset);
5194 rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
5195 /* R_386_IRELATIVE comes last. */
5196 plt_index = htab->next_irelative_index--;
5200 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
5201 plt_index = htab->next_jump_slot_index++;
5204 loc = relplt->contents + plt_index * sizeof (Elf32_External_Rel);
5205 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5207 /* Don't fill PLT entry for static executables. */
5208 if (plt == htab->elf.splt)
5210 bfd_put_32 (output_bfd,
5211 plt_index * sizeof (Elf32_External_Rel),
5212 plt->contents + h->plt.offset
5213 + abed->plt->plt_reloc_offset);
5214 bfd_put_32 (output_bfd, - (h->plt.offset
5215 + abed->plt->plt_plt_offset + 4),
5216 plt->contents + h->plt.offset
5217 + abed->plt->plt_plt_offset);
5221 else if (eh->plt_got.offset != (bfd_vma) -1)
5223 bfd_vma got_offset, plt_offset;
5224 asection *plt, *got, *gotplt;
5225 const bfd_byte *got_plt_entry;
5227 /* Offset of displacement of the indirect jump. */
5228 bfd_vma plt_got_offset = 2;
5230 /* Set the entry in the GOT procedure linkage table. */
5231 plt = htab->plt_got;
5232 got = htab->elf.sgot;
5233 gotplt = htab->elf.sgotplt;
5234 got_offset = h->got.offset;
5236 if (got_offset == (bfd_vma) -1
5242 /* Fill in the entry in the GOT procedure linkage table. */
5243 if (! bfd_link_pic (info))
5245 got_plt_entry = elf_i386_got_plt_entry;
5246 got_offset += got->output_section->vma + got->output_offset;
5250 got_plt_entry = elf_i386_pic_got_plt_entry;
5251 got_offset += (got->output_section->vma
5252 + got->output_offset
5253 - gotplt->output_section->vma
5254 - gotplt->output_offset);
5257 plt_offset = eh->plt_got.offset;
5258 memcpy (plt->contents + plt_offset, got_plt_entry,
5259 sizeof (elf_i386_got_plt_entry));
5260 bfd_put_32 (output_bfd, got_offset,
5261 plt->contents + plt_offset + plt_got_offset);
5264 if (!local_undefweak
5266 && (h->plt.offset != (bfd_vma) -1
5267 || eh->plt_got.offset != (bfd_vma) -1))
5269 /* Mark the symbol as undefined, rather than as defined in
5270 the .plt section. Leave the value if there were any
5271 relocations where pointer equality matters (this is a clue
5272 for the dynamic linker, to make function pointer
5273 comparisons work between an application and shared
5274 library), otherwise set it to zero. If a function is only
5275 called from a binary, there is no need to slow down
5276 shared libraries because of that. */
5277 sym->st_shndx = SHN_UNDEF;
5278 if (!h->pointer_equality_needed)
5282 /* Don't generate dynamic GOT relocation against undefined weak
5283 symbol in executable. */
5284 if (h->got.offset != (bfd_vma) -1
5285 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h)->tls_type)
5286 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0
5287 && !local_undefweak)
5289 Elf_Internal_Rela rel;
5291 /* This symbol has an entry in the global offset table. Set it
5294 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
5297 rel.r_offset = (htab->elf.sgot->output_section->vma
5298 + htab->elf.sgot->output_offset
5299 + (h->got.offset & ~(bfd_vma) 1));
5301 /* If this is a static link, or it is a -Bsymbolic link and the
5302 symbol is defined locally or was forced to be local because
5303 of a version file, we just want to emit a RELATIVE reloc.
5304 The entry in the global offset table will already have been
5305 initialized in the relocate_section function. */
5307 && h->type == STT_GNU_IFUNC)
5309 if (bfd_link_pic (info))
5311 /* Generate R_386_GLOB_DAT. */
5318 if (!h->pointer_equality_needed)
5321 /* For non-shared object, we can't use .got.plt, which
5322 contains the real function addres if we need pointer
5323 equality. We load the GOT entry with the PLT entry. */
5324 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
5325 bfd_put_32 (output_bfd,
5326 (plt->output_section->vma
5327 + plt->output_offset + h->plt.offset),
5328 htab->elf.sgot->contents + h->got.offset);
5332 else if (bfd_link_pic (info)
5333 && SYMBOL_REFERENCES_LOCAL (info, h))
5335 BFD_ASSERT((h->got.offset & 1) != 0);
5336 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
5340 BFD_ASSERT((h->got.offset & 1) == 0);
5342 bfd_put_32 (output_bfd, (bfd_vma) 0,
5343 htab->elf.sgot->contents + h->got.offset);
5344 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
5347 elf_append_rel (output_bfd, htab->elf.srelgot, &rel);
5352 Elf_Internal_Rela rel;
5354 /* This symbol needs a copy reloc. Set it up. */
5356 if (h->dynindx == -1
5357 || (h->root.type != bfd_link_hash_defined
5358 && h->root.type != bfd_link_hash_defweak)
5359 || htab->srelbss == NULL)
5362 rel.r_offset = (h->root.u.def.value
5363 + h->root.u.def.section->output_section->vma
5364 + h->root.u.def.section->output_offset);
5365 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
5366 elf_append_rel (output_bfd, htab->srelbss, &rel);
5372 /* Finish up local dynamic symbol handling. We set the contents of
5373 various dynamic sections here. */
5376 elf_i386_finish_local_dynamic_symbol (void **slot, void *inf)
5378 struct elf_link_hash_entry *h
5379 = (struct elf_link_hash_entry *) *slot;
5380 struct bfd_link_info *info
5381 = (struct bfd_link_info *) inf;
5383 return elf_i386_finish_dynamic_symbol (info->output_bfd, info,
5387 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5388 here since undefined weak symbol may not be dynamic and may not be
5389 called for elf_i386_finish_dynamic_symbol. */
5392 elf_i386_pie_finish_undefweak_symbol (struct bfd_hash_entry *bh,
5395 struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
5396 struct bfd_link_info *info = (struct bfd_link_info *) inf;
5398 if (h->root.type != bfd_link_hash_undefweak
5399 || h->dynindx != -1)
5402 return elf_i386_finish_dynamic_symbol (info->output_bfd,
5406 /* Used to decide how to sort relocs in an optimal manner for the
5407 dynamic linker, before writing them out. */
5409 static enum elf_reloc_type_class
5410 elf_i386_reloc_type_class (const struct bfd_link_info *info,
5411 const asection *rel_sec ATTRIBUTE_UNUSED,
5412 const Elf_Internal_Rela *rela)
5414 bfd *abfd = info->output_bfd;
5415 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5416 struct elf_link_hash_table *htab = elf_hash_table (info);
5418 if (htab->dynsym != NULL
5419 && htab->dynsym->contents != NULL)
5421 /* Check relocation against STT_GNU_IFUNC symbol if there are
5423 unsigned long r_symndx = ELF32_R_SYM (rela->r_info);
5424 Elf_Internal_Sym sym;
5425 if (!bed->s->swap_symbol_in (abfd,
5426 (htab->dynsym->contents
5427 + r_symndx * sizeof (Elf32_External_Sym)),
5431 if (ELF32_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
5432 return reloc_class_ifunc;
5435 switch (ELF32_R_TYPE (rela->r_info))
5437 case R_386_RELATIVE:
5438 return reloc_class_relative;
5439 case R_386_JUMP_SLOT:
5440 return reloc_class_plt;
5442 return reloc_class_copy;
5444 return reloc_class_normal;
5448 /* Finish up the dynamic sections. */
5451 elf_i386_finish_dynamic_sections (bfd *output_bfd,
5452 struct bfd_link_info *info)
5454 struct elf_i386_link_hash_table *htab;
5457 const struct elf_i386_backend_data *abed;
5459 htab = elf_i386_hash_table (info);
5463 dynobj = htab->elf.dynobj;
5464 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
5465 abed = get_elf_i386_backend_data (output_bfd);
5467 if (htab->elf.dynamic_sections_created)
5469 Elf32_External_Dyn *dyncon, *dynconend;
5471 if (sdyn == NULL || htab->elf.sgot == NULL)
5474 dyncon = (Elf32_External_Dyn *) sdyn->contents;
5475 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5476 for (; dyncon < dynconend; dyncon++)
5478 Elf_Internal_Dyn dyn;
5481 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5486 if (abed->is_vxworks
5487 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
5492 s = htab->elf.sgotplt;
5493 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5497 s = htab->elf.srelplt;
5498 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5502 s = htab->elf.srelplt;
5503 dyn.d_un.d_val = s->size;
5507 /* My reading of the SVR4 ABI indicates that the
5508 procedure linkage table relocs (DT_JMPREL) should be
5509 included in the overall relocs (DT_REL). This is
5510 what Solaris does. However, UnixWare can not handle
5511 that case. Therefore, we override the DT_RELSZ entry
5512 here to make it not include the JMPREL relocs. */
5513 s = htab->elf.srelplt;
5516 dyn.d_un.d_val -= s->size;
5520 /* We may not be using the standard ELF linker script.
5521 If .rel.plt is the first .rel section, we adjust
5522 DT_REL to not include it. */
5523 s = htab->elf.srelplt;
5526 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
5528 dyn.d_un.d_ptr += s->size;
5532 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5535 /* Fill in the first entry in the procedure linkage table. */
5536 if (htab->elf.splt && htab->elf.splt->size > 0)
5538 if (bfd_link_pic (info))
5540 memcpy (htab->elf.splt->contents, abed->plt->pic_plt0_entry,
5541 abed->plt->plt0_entry_size);
5542 memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
5543 abed->plt0_pad_byte,
5544 abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
5548 memcpy (htab->elf.splt->contents, abed->plt->plt0_entry,
5549 abed->plt->plt0_entry_size);
5550 memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
5551 abed->plt0_pad_byte,
5552 abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
5553 bfd_put_32 (output_bfd,
5554 (htab->elf.sgotplt->output_section->vma
5555 + htab->elf.sgotplt->output_offset
5557 htab->elf.splt->contents
5558 + abed->plt->plt0_got1_offset);
5559 bfd_put_32 (output_bfd,
5560 (htab->elf.sgotplt->output_section->vma
5561 + htab->elf.sgotplt->output_offset
5563 htab->elf.splt->contents
5564 + abed->plt->plt0_got2_offset);
5566 if (abed->is_vxworks)
5568 Elf_Internal_Rela rel;
5570 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
5571 On IA32 we use REL relocations so the addend goes in
5572 the PLT directly. */
5573 rel.r_offset = (htab->elf.splt->output_section->vma
5574 + htab->elf.splt->output_offset
5575 + abed->plt->plt0_got1_offset);
5576 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
5577 bfd_elf32_swap_reloc_out (output_bfd, &rel,
5578 htab->srelplt2->contents);
5579 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
5580 rel.r_offset = (htab->elf.splt->output_section->vma
5581 + htab->elf.splt->output_offset
5582 + abed->plt->plt0_got2_offset);
5583 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
5584 bfd_elf32_swap_reloc_out (output_bfd, &rel,
5585 htab->srelplt2->contents +
5586 sizeof (Elf32_External_Rel));
5590 /* UnixWare sets the entsize of .plt to 4, although that doesn't
5591 really seem like the right value. */
5592 elf_section_data (htab->elf.splt->output_section)
5593 ->this_hdr.sh_entsize = 4;
5595 /* Correct the .rel.plt.unloaded relocations. */
5596 if (abed->is_vxworks && !bfd_link_pic (info))
5598 int num_plts = (htab->elf.splt->size
5599 / abed->plt->plt_entry_size) - 1;
5602 p = htab->srelplt2->contents;
5603 if (bfd_link_pic (info))
5604 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
5606 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
5608 for (; num_plts; num_plts--)
5610 Elf_Internal_Rela rel;
5611 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
5612 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
5613 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
5614 p += sizeof (Elf32_External_Rel);
5616 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
5617 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
5618 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
5619 p += sizeof (Elf32_External_Rel);
5625 if (htab->elf.sgotplt)
5627 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
5629 (*_bfd_error_handler)
5630 (_("discarded output section: `%A'"), htab->elf.sgotplt);
5634 /* Fill in the first three entries in the global offset table. */
5635 if (htab->elf.sgotplt->size > 0)
5637 bfd_put_32 (output_bfd,
5639 : sdyn->output_section->vma + sdyn->output_offset),
5640 htab->elf.sgotplt->contents);
5641 bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 4);
5642 bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 8);
5645 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize = 4;
5648 /* Adjust .eh_frame for .plt section. */
5649 if (htab->plt_eh_frame != NULL
5650 && htab->plt_eh_frame->contents != NULL)
5652 if (htab->elf.splt != NULL
5653 && htab->elf.splt->size != 0
5654 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
5655 && htab->elf.splt->output_section != NULL
5656 && htab->plt_eh_frame->output_section != NULL)
5658 bfd_vma plt_start = htab->elf.splt->output_section->vma;
5659 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
5660 + htab->plt_eh_frame->output_offset
5661 + PLT_FDE_START_OFFSET;
5662 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
5663 htab->plt_eh_frame->contents
5664 + PLT_FDE_START_OFFSET);
5666 if (htab->plt_eh_frame->sec_info_type
5667 == SEC_INFO_TYPE_EH_FRAME)
5669 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
5671 htab->plt_eh_frame->contents))
5676 if (htab->elf.sgot && htab->elf.sgot->size > 0)
5677 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 4;
5679 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5680 htab_traverse (htab->loc_hash_table,
5681 elf_i386_finish_local_dynamic_symbol,
5684 /* Fill PLT entries for undefined weak symbols in PIE. */
5685 if (bfd_link_pie (info))
5686 bfd_hash_traverse (&info->hash->table,
5687 elf_i386_pie_finish_undefweak_symbol,
5693 /* Return an array of PLT entry symbol values. */
5696 elf_i386_get_plt_sym_val (bfd *abfd, asymbol **dynsyms, asection *plt,
5699 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
5702 bfd_vma *plt_sym_val;
5704 bfd_byte *plt_contents;
5705 const struct elf_i386_backend_data *bed
5706 = get_elf_i386_backend_data (abfd);
5707 Elf_Internal_Shdr *hdr;
5709 /* Get the .plt section contents. */
5710 plt_contents = (bfd_byte *) bfd_malloc (plt->size);
5711 if (plt_contents == NULL)
5713 if (!bfd_get_section_contents (abfd, (asection *) plt,
5714 plt_contents, 0, plt->size))
5717 free (plt_contents);
5721 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
5722 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
5725 hdr = &elf_section_data (relplt)->this_hdr;
5726 count = relplt->size / hdr->sh_entsize;
5728 plt_sym_val = (bfd_vma *) bfd_malloc (sizeof (bfd_vma) * count);
5729 if (plt_sym_val == NULL)
5732 for (i = 0; i < count; i++)
5733 plt_sym_val[i] = -1;
5735 plt_offset = bed->plt->plt_entry_size;
5736 p = relplt->relocation;
5737 for (i = 0; i < count; i++, p++)
5741 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
5742 if (p->howto == NULL)
5745 if (p->howto->type != R_386_JUMP_SLOT
5746 && p->howto->type != R_386_IRELATIVE)
5749 reloc_index = H_GET_32 (abfd, (plt_contents + plt_offset
5750 + bed->plt->plt_reloc_offset));
5751 reloc_index /= sizeof (Elf32_External_Rel);
5752 if (reloc_index < count)
5753 plt_sym_val[reloc_index] = plt->vma + plt_offset;
5755 plt_offset += bed->plt->plt_entry_size;
5757 /* PR binutils/18437: Skip extra relocations in the .rel.plt
5759 if (plt_offset >= plt->size)
5763 free (plt_contents);
5768 /* Similar to _bfd_elf_get_synthetic_symtab. */
5771 elf_i386_get_synthetic_symtab (bfd *abfd,
5778 asection *plt = bfd_get_section_by_name (abfd, ".plt");
5779 return _bfd_elf_ifunc_get_synthetic_symtab (abfd, symcount, syms,
5780 dynsymcount, dynsyms, ret,
5782 elf_i386_get_plt_sym_val);
5785 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5788 elf_i386_hash_symbol (struct elf_link_hash_entry *h)
5790 if (h->plt.offset != (bfd_vma) -1
5792 && !h->pointer_equality_needed)
5795 return _bfd_elf_hash_symbol (h);
5798 /* Hook called by the linker routine which adds symbols from an object
5802 elf_i386_add_symbol_hook (bfd * abfd,
5803 struct bfd_link_info * info,
5804 Elf_Internal_Sym * sym,
5805 const char ** namep ATTRIBUTE_UNUSED,
5806 flagword * flagsp ATTRIBUTE_UNUSED,
5807 asection ** secp ATTRIBUTE_UNUSED,
5808 bfd_vma * valp ATTRIBUTE_UNUSED)
5810 if (ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE
5811 && (abfd->flags & DYNAMIC) == 0
5812 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
5813 elf_tdata (info->output_bfd)->has_gnu_symbols
5814 |= elf_gnu_symbol_unique;
5819 #define TARGET_LITTLE_SYM i386_elf32_vec
5820 #define TARGET_LITTLE_NAME "elf32-i386"
5821 #define ELF_ARCH bfd_arch_i386
5822 #define ELF_TARGET_ID I386_ELF_DATA
5823 #define ELF_MACHINE_CODE EM_386
5824 #define ELF_MAXPAGESIZE 0x1000
5826 #define elf_backend_can_gc_sections 1
5827 #define elf_backend_can_refcount 1
5828 #define elf_backend_want_got_plt 1
5829 #define elf_backend_plt_readonly 1
5830 #define elf_backend_want_plt_sym 0
5831 #define elf_backend_got_header_size 12
5832 #define elf_backend_plt_alignment 4
5833 #define elf_backend_extern_protected_data 1
5834 #define elf_backend_caches_rawsize 1
5836 /* Support RELA for objdump of prelink objects. */
5837 #define elf_info_to_howto elf_i386_info_to_howto_rel
5838 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
5840 #define bfd_elf32_mkobject elf_i386_mkobject
5842 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
5843 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
5844 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
5845 #define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
5846 #define bfd_elf32_get_synthetic_symtab elf_i386_get_synthetic_symtab
5848 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
5849 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
5850 #define elf_backend_check_relocs elf_i386_check_relocs
5851 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
5852 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
5853 #define elf_backend_fake_sections elf_i386_fake_sections
5854 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
5855 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
5856 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
5857 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
5858 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
5859 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
5860 #define elf_backend_relocate_section elf_i386_relocate_section
5861 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
5862 #define elf_backend_always_size_sections elf_i386_always_size_sections
5863 #define elf_backend_omit_section_dynsym \
5864 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5865 #define elf_backend_hash_symbol elf_i386_hash_symbol
5866 #define elf_backend_add_symbol_hook elf_i386_add_symbol_hook
5867 #define elf_backend_fixup_symbol elf_i386_fixup_symbol
5869 #include "elf32-target.h"
5871 /* FreeBSD support. */
5873 #undef TARGET_LITTLE_SYM
5874 #define TARGET_LITTLE_SYM i386_elf32_fbsd_vec
5875 #undef TARGET_LITTLE_NAME
5876 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
5878 #define ELF_OSABI ELFOSABI_FREEBSD
5880 /* The kernel recognizes executables as valid only if they carry a
5881 "FreeBSD" label in the ELF header. So we put this label on all
5882 executables and (for simplicity) also all other object files. */
5885 elf_i386_fbsd_post_process_headers (bfd *abfd, struct bfd_link_info *info)
5887 _bfd_elf_post_process_headers (abfd, info);
5889 #ifdef OLD_FREEBSD_ABI_LABEL
5891 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
5892 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
5893 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
5898 #undef elf_backend_post_process_headers
5899 #define elf_backend_post_process_headers elf_i386_fbsd_post_process_headers
5901 #define elf32_bed elf32_i386_fbsd_bed
5903 #undef elf_backend_add_symbol_hook
5905 #include "elf32-target.h"
5909 #undef TARGET_LITTLE_SYM
5910 #define TARGET_LITTLE_SYM i386_elf32_sol2_vec
5911 #undef TARGET_LITTLE_NAME
5912 #define TARGET_LITTLE_NAME "elf32-i386-sol2"
5914 #undef elf_backend_post_process_headers
5916 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5917 objects won't be recognized. */
5921 #define elf32_bed elf32_i386_sol2_bed
5923 /* The 32-bit static TLS arena size is rounded to the nearest 8-byte
5925 #undef elf_backend_static_tls_alignment
5926 #define elf_backend_static_tls_alignment 8
5928 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5930 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5932 #undef elf_backend_want_plt_sym
5933 #define elf_backend_want_plt_sym 1
5935 #undef elf_backend_strtab_flags
5936 #define elf_backend_strtab_flags SHF_STRINGS
5938 /* Called to set the sh_flags, sh_link and sh_info fields of OSECTION which
5939 has a type >= SHT_LOOS. Returns TRUE if these fields were initialised
5940 FALSE otherwise. ISECTION is the best guess matching section from the
5941 input bfd IBFD, but it might be NULL. */
5944 elf32_i386_copy_solaris_special_section_fields (const bfd *ibfd ATTRIBUTE_UNUSED,
5945 bfd *obfd ATTRIBUTE_UNUSED,
5946 const Elf_Internal_Shdr *isection ATTRIBUTE_UNUSED,
5947 Elf_Internal_Shdr *osection ATTRIBUTE_UNUSED)
5949 /* PR 19938: FIXME: Need to add code for setting the sh_info
5950 and sh_link fields of Solaris specific section types. */
5953 /* Based upon Oracle Solaris 11.3 Linkers and Libraries Guide, Ch. 13,
5954 Object File Format, Table 13-9 ELF sh_link and sh_info Interpretation:
5956 http://docs.oracle.com/cd/E53394_01/html/E54813/chapter6-94076.html#scrolltoc
5958 The following values should be set:
5961 -----------------------------------------------------------------------------
5962 SHT_SUNW_ancillary The section header index of 0
5963 [0x6fffffee] the associated string table.
5965 SHT_SUNW_capinfo The section header index of For a dynamic object, the
5966 [0x6ffffff0] the associated symbol table. section header index of
5968 SHT_SUNW_capchain table,
5971 SHT_SUNW_symsort The section header index of 0
5972 [0x6ffffff1] the associated symbol table.
5974 SHT_SUNW_tlssort The section header index of 0
5975 [0x6ffffff2] the associated symbol table.
5977 SHT_SUNW_LDYNSYM The section header index of One greater than the
5978 [0x6ffffff3] the associated string table. symbol table index of the
5979 This index is the same string last local symbol,
5980 table used by the SHT_DYNSYM STB_LOCAL. Since
5981 section. SHT_SUNW_LDYNSYM only
5982 contains local symbols,
5983 sh_info is equivalent to
5984 the number of symbols in
5987 SHT_SUNW_cap If symbol capabilities exist, If any capabilities refer
5988 [0x6ffffff5] the section header index of to named strings, the
5989 the associated section header index of
5990 SHT_SUNW_capinfo table, the associated string
5991 otherwise 0. table, otherwise 0.
5993 SHT_SUNW_move The section header index of 0
5994 [0x6ffffffa] the associated symbol table.
5999 SHT_SUNW_syminfo The section header index of The section header index
6000 [0x6ffffffc] the associated symbol table. of the associated
6003 SHT_SUNW_verdef The section header index of The number of version
6004 [0x6ffffffd] the associated string table. definitions within the
6007 SHT_SUNW_verneed The section header index of The number of version
6008 [0x6ffffffe] the associated string table. dependencies within the
6011 SHT_SUNW_versym The section header index of 0
6012 [0x6fffffff] the associated symbol table. */
6015 #undef elf_backend_copy_special_section_fields
6016 #define elf_backend_copy_special_section_fields elf32_i386_copy_solaris_special_section_fields
6018 #include "elf32-target.h"
6020 /* Intel MCU support. */
6023 elf32_iamcu_elf_object_p (bfd *abfd)
6025 /* Set the right machine number for an IAMCU elf32 file. */
6026 bfd_default_set_arch_mach (abfd, bfd_arch_iamcu, bfd_mach_i386_iamcu);
6030 #undef TARGET_LITTLE_SYM
6031 #define TARGET_LITTLE_SYM iamcu_elf32_vec
6032 #undef TARGET_LITTLE_NAME
6033 #define TARGET_LITTLE_NAME "elf32-iamcu"
6035 #define ELF_ARCH bfd_arch_iamcu
6037 #undef ELF_MACHINE_CODE
6038 #define ELF_MACHINE_CODE EM_IAMCU
6043 #define elf32_bed elf32_iamcu_bed
6045 #undef elf_backend_object_p
6046 #define elf_backend_object_p elf32_iamcu_elf_object_p
6048 #undef elf_backend_static_tls_alignment
6050 #undef elf_backend_want_plt_sym
6051 #define elf_backend_want_plt_sym 0
6053 #undef elf_backend_strtab_flags
6054 #undef elf_backend_copy_special_section_fields
6056 #undef elf_backend_add_symbol_hook
6057 #define elf_backend_add_symbol_hook elf_i386_add_symbol_hook
6059 #include "elf32-target.h"
6061 /* Restore defaults. */
6063 #define ELF_ARCH bfd_arch_i386
6064 #undef ELF_MACHINE_CODE
6065 #define ELF_MACHINE_CODE EM_386
6067 /* Native Client support. */
6069 #undef TARGET_LITTLE_SYM
6070 #define TARGET_LITTLE_SYM i386_elf32_nacl_vec
6071 #undef TARGET_LITTLE_NAME
6072 #define TARGET_LITTLE_NAME "elf32-i386-nacl"
6074 #define elf32_bed elf32_i386_nacl_bed
6076 #undef ELF_MAXPAGESIZE
6077 #define ELF_MAXPAGESIZE 0x10000
6079 /* Restore defaults. */
6081 #undef elf_backend_want_plt_sym
6082 #define elf_backend_want_plt_sym 0
6083 #undef elf_backend_post_process_headers
6084 #undef elf_backend_static_tls_alignment
6086 /* NaCl uses substantially different PLT entries for the same effects. */
6088 #undef elf_backend_plt_alignment
6089 #define elf_backend_plt_alignment 5
6090 #define NACL_PLT_ENTRY_SIZE 64
6091 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6093 static const bfd_byte elf_i386_nacl_plt0_entry[] =
6095 0xff, 0x35, /* pushl contents of address */
6096 0, 0, 0, 0, /* replaced with address of .got + 4. */
6097 0x8b, 0x0d, /* movl contents of address, %ecx */
6098 0, 0, 0, 0, /* replaced with address of .got + 8. */
6099 0x83, 0xe1, NACLMASK, /* andl $NACLMASK, %ecx */
6100 0xff, 0xe1 /* jmp *%ecx */
6103 static const bfd_byte elf_i386_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
6105 0x8b, 0x0d, /* movl contents of address, %ecx */
6106 0, 0, 0, 0, /* replaced with GOT slot address. */
6107 0x83, 0xe1, NACLMASK, /* andl $NACLMASK, %ecx */
6108 0xff, 0xe1, /* jmp *%ecx */
6110 /* Pad to the next 32-byte boundary with nop instructions. */
6112 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6113 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6115 /* Lazy GOT entries point here (32-byte aligned). */
6116 0x68, /* pushl immediate */
6117 0, 0, 0, 0, /* replaced with reloc offset. */
6118 0xe9, /* jmp relative */
6119 0, 0, 0, 0, /* replaced with offset to .plt. */
6121 /* Pad to the next 32-byte boundary with nop instructions. */
6122 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6123 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6127 static const bfd_byte
6128 elf_i386_nacl_pic_plt0_entry[sizeof (elf_i386_nacl_plt0_entry)] =
6130 0xff, 0x73, 0x04, /* pushl 4(%ebx) */
6131 0x8b, 0x4b, 0x08, /* mov 0x8(%ebx), %ecx */
6132 0x83, 0xe1, 0xe0, /* and $NACLMASK, %ecx */
6133 0xff, 0xe1, /* jmp *%ecx */
6135 /* This is expected to be the same size as elf_i386_nacl_plt0_entry,
6136 so pad to that size with nop instructions. */
6137 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
6140 static const bfd_byte elf_i386_nacl_pic_plt_entry[NACL_PLT_ENTRY_SIZE] =
6142 0x8b, 0x8b, /* movl offset(%ebx), %ecx */
6143 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
6144 0x83, 0xe1, 0xe0, /* andl $NACLMASK, %ecx */
6145 0xff, 0xe1, /* jmp *%ecx */
6147 /* Pad to the next 32-byte boundary with nop instructions. */
6149 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6150 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6152 /* Lazy GOT entries point here (32-byte aligned). */
6153 0x68, /* pushl immediate */
6154 0, 0, 0, 0, /* replaced with offset into relocation table. */
6155 0xe9, /* jmp relative */
6156 0, 0, 0, 0, /* replaced with offset to start of .plt. */
6158 /* Pad to the next 32-byte boundary with nop instructions. */
6159 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6160 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6164 static const bfd_byte elf_i386_nacl_eh_frame_plt[] =
6166 #if (PLT_CIE_LENGTH != 20 \
6167 || PLT_FDE_LENGTH != 36 \
6168 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6169 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6170 # error "Need elf_i386_backend_data parameters for eh_frame_plt offsets!"
6172 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
6173 0, 0, 0, 0, /* CIE ID */
6174 1, /* CIE version */
6175 'z', 'R', 0, /* Augmentation string */
6176 1, /* Code alignment factor */
6177 0x7c, /* Data alignment factor: -4 */
6178 8, /* Return address column */
6179 1, /* Augmentation size */
6180 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
6181 DW_CFA_def_cfa, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
6182 DW_CFA_offset + 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
6183 DW_CFA_nop, DW_CFA_nop,
6185 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
6186 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
6187 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
6188 0, 0, 0, 0, /* .plt size goes here */
6189 0, /* Augmentation size */
6190 DW_CFA_def_cfa_offset, 8, /* DW_CFA_def_cfa_offset: 8 */
6191 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6192 DW_CFA_def_cfa_offset, 12, /* DW_CFA_def_cfa_offset: 12 */
6193 DW_CFA_advance_loc + 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6194 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
6195 13, /* Block length */
6196 DW_OP_breg4, 4, /* DW_OP_breg4 (esp): 4 */
6197 DW_OP_breg8, 0, /* DW_OP_breg8 (eip): 0 */
6198 DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
6199 DW_OP_lit2, DW_OP_shl, DW_OP_plus,
6200 DW_CFA_nop, DW_CFA_nop
6203 static const struct elf_i386_plt_layout elf_i386_nacl_plt =
6205 elf_i386_nacl_plt0_entry, /* plt0_entry */
6206 sizeof (elf_i386_nacl_plt0_entry), /* plt0_entry_size */
6207 2, /* plt0_got1_offset */
6208 8, /* plt0_got2_offset */
6209 elf_i386_nacl_plt_entry, /* plt_entry */
6210 NACL_PLT_ENTRY_SIZE, /* plt_entry_size */
6211 2, /* plt_got_offset */
6212 33, /* plt_reloc_offset */
6213 38, /* plt_plt_offset */
6214 32, /* plt_lazy_offset */
6215 elf_i386_nacl_pic_plt0_entry, /* pic_plt0_entry */
6216 elf_i386_nacl_pic_plt_entry, /* pic_plt_entry */
6217 elf_i386_nacl_eh_frame_plt, /* eh_frame_plt */
6218 sizeof (elf_i386_nacl_eh_frame_plt),/* eh_frame_plt_size */
6221 static const struct elf_i386_backend_data elf_i386_nacl_arch_bed =
6223 &elf_i386_nacl_plt, /* plt */
6224 0x90, /* plt0_pad_byte: nop insn */
6229 elf32_i386_nacl_elf_object_p (bfd *abfd)
6231 /* Set the right machine number for a NaCl i386 ELF32 file. */
6232 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_i386_i386_nacl);
6236 #undef elf_backend_arch_data
6237 #define elf_backend_arch_data &elf_i386_nacl_arch_bed
6239 #undef elf_backend_object_p
6240 #define elf_backend_object_p elf32_i386_nacl_elf_object_p
6241 #undef elf_backend_modify_segment_map
6242 #define elf_backend_modify_segment_map nacl_modify_segment_map
6243 #undef elf_backend_modify_program_headers
6244 #define elf_backend_modify_program_headers nacl_modify_program_headers
6245 #undef elf_backend_final_write_processing
6246 #define elf_backend_final_write_processing nacl_final_write_processing
6248 #include "elf32-target.h"
6250 /* Restore defaults. */
6251 #undef elf_backend_object_p
6252 #undef elf_backend_modify_segment_map
6253 #undef elf_backend_modify_program_headers
6254 #undef elf_backend_final_write_processing
6256 /* VxWorks support. */
6258 #undef TARGET_LITTLE_SYM
6259 #define TARGET_LITTLE_SYM i386_elf32_vxworks_vec
6260 #undef TARGET_LITTLE_NAME
6261 #define TARGET_LITTLE_NAME "elf32-i386-vxworks"
6263 #undef elf_backend_plt_alignment
6264 #define elf_backend_plt_alignment 4
6266 static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed =
6268 &elf_i386_plt, /* plt */
6269 0x90, /* plt0_pad_byte */
6273 #undef elf_backend_arch_data
6274 #define elf_backend_arch_data &elf_i386_vxworks_arch_bed
6276 #undef elf_backend_relocs_compatible
6277 #undef elf_backend_add_symbol_hook
6278 #define elf_backend_add_symbol_hook \
6279 elf_vxworks_add_symbol_hook
6280 #undef elf_backend_link_output_symbol_hook
6281 #define elf_backend_link_output_symbol_hook \
6282 elf_vxworks_link_output_symbol_hook
6283 #undef elf_backend_emit_relocs
6284 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
6285 #undef elf_backend_final_write_processing
6286 #define elf_backend_final_write_processing \
6287 elf_vxworks_final_write_processing
6288 #undef elf_backend_static_tls_alignment
6290 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
6292 #undef elf_backend_want_plt_sym
6293 #define elf_backend_want_plt_sym 1
6296 #define elf32_bed elf32_i386_vxworks_bed
6298 #include "elf32-target.h"