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 /* 0: symbol isn't ___tls_get_addr.
791 1: symbol is ___tls_get_addr.
792 2: symbol is unknown. */
793 unsigned int tls_get_addr : 2;
795 /* Reference count of C/C++ function pointer relocations in read-write
796 section which can be resolved at run-time. */
797 bfd_signed_vma func_pointer_refcount;
799 /* Information about the GOT PLT entry. Filled when there are both
800 GOT and PLT relocations against the same function. */
801 union gotplt_union plt_got;
803 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
804 starting at the end of the jump table. */
808 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
810 struct elf_i386_obj_tdata
812 struct elf_obj_tdata root;
814 /* tls_type for each local got entry. */
815 char *local_got_tls_type;
817 /* GOTPLT entries for TLS descriptors. */
818 bfd_vma *local_tlsdesc_gotent;
821 #define elf_i386_tdata(abfd) \
822 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
824 #define elf_i386_local_got_tls_type(abfd) \
825 (elf_i386_tdata (abfd)->local_got_tls_type)
827 #define elf_i386_local_tlsdesc_gotent(abfd) \
828 (elf_i386_tdata (abfd)->local_tlsdesc_gotent)
830 #define is_i386_elf(bfd) \
831 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
832 && elf_tdata (bfd) != NULL \
833 && elf_object_id (bfd) == I386_ELF_DATA)
836 elf_i386_mkobject (bfd *abfd)
838 return bfd_elf_allocate_object (abfd, sizeof (struct elf_i386_obj_tdata),
842 /* i386 ELF linker hash table. */
844 struct elf_i386_link_hash_table
846 struct elf_link_hash_table elf;
848 /* Short-cuts to get to dynamic linker sections. */
852 asection *plt_eh_frame;
857 bfd_signed_vma refcount;
861 /* The amount of space used by the reserved portion of the sgotplt
862 section, plus whatever space is used by the jump slots. */
863 bfd_vma sgotplt_jump_table_size;
865 /* Small local sym cache. */
866 struct sym_cache sym_cache;
868 /* _TLS_MODULE_BASE_ symbol. */
869 struct bfd_link_hash_entry *tls_module_base;
871 /* Used by local STT_GNU_IFUNC symbols. */
872 htab_t loc_hash_table;
873 void * loc_hash_memory;
875 /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */
878 /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */
879 bfd_vma next_tls_desc_index;
881 /* The index of the next unused R_386_JUMP_SLOT slot in .rel.plt. */
882 bfd_vma next_jump_slot_index;
884 /* The index of the next unused R_386_IRELATIVE slot in .rel.plt. */
885 bfd_vma next_irelative_index;
887 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
888 to read-only sections. */
889 bfd_boolean readonly_dynrelocs_against_ifunc;
892 /* Get the i386 ELF linker hash table from a link_info structure. */
894 #define elf_i386_hash_table(p) \
895 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
896 == I386_ELF_DATA ? ((struct elf_i386_link_hash_table *) ((p)->hash)) : NULL)
898 #define elf_i386_compute_jump_table_size(htab) \
899 ((htab)->elf.srelplt->reloc_count * 4)
901 /* Create an entry in an i386 ELF linker hash table. */
903 static struct bfd_hash_entry *
904 elf_i386_link_hash_newfunc (struct bfd_hash_entry *entry,
905 struct bfd_hash_table *table,
908 /* Allocate the structure if it has not already been allocated by a
912 entry = (struct bfd_hash_entry *)
913 bfd_hash_allocate (table, sizeof (struct elf_i386_link_hash_entry));
918 /* Call the allocation method of the superclass. */
919 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
922 struct elf_i386_link_hash_entry *eh;
924 eh = (struct elf_i386_link_hash_entry *) entry;
925 eh->dyn_relocs = NULL;
926 eh->tls_type = GOT_UNKNOWN;
928 eh->has_got_reloc = 0;
929 eh->has_non_got_reloc = 0;
930 eh->tls_get_addr = 2;
931 eh->func_pointer_refcount = 0;
932 eh->plt_got.offset = (bfd_vma) -1;
933 eh->tlsdesc_got = (bfd_vma) -1;
939 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
940 for local symbol so that we can handle local STT_GNU_IFUNC symbols
941 as global symbol. We reuse indx and dynstr_index for local symbol
942 hash since they aren't used by global symbols in this backend. */
945 elf_i386_local_htab_hash (const void *ptr)
947 struct elf_link_hash_entry *h
948 = (struct elf_link_hash_entry *) ptr;
949 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
952 /* Compare local hash entries. */
955 elf_i386_local_htab_eq (const void *ptr1, const void *ptr2)
957 struct elf_link_hash_entry *h1
958 = (struct elf_link_hash_entry *) ptr1;
959 struct elf_link_hash_entry *h2
960 = (struct elf_link_hash_entry *) ptr2;
962 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
965 /* Find and/or create a hash entry for local symbol. */
967 static struct elf_link_hash_entry *
968 elf_i386_get_local_sym_hash (struct elf_i386_link_hash_table *htab,
969 bfd *abfd, const Elf_Internal_Rela *rel,
972 struct elf_i386_link_hash_entry e, *ret;
973 asection *sec = abfd->sections;
974 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
975 ELF32_R_SYM (rel->r_info));
978 e.elf.indx = sec->id;
979 e.elf.dynstr_index = ELF32_R_SYM (rel->r_info);
980 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
981 create ? INSERT : NO_INSERT);
988 ret = (struct elf_i386_link_hash_entry *) *slot;
992 ret = (struct elf_i386_link_hash_entry *)
993 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
994 sizeof (struct elf_i386_link_hash_entry));
997 memset (ret, 0, sizeof (*ret));
998 ret->elf.indx = sec->id;
999 ret->elf.dynstr_index = ELF32_R_SYM (rel->r_info);
1000 ret->elf.dynindx = -1;
1001 ret->func_pointer_refcount = 0;
1002 ret->plt_got.offset = (bfd_vma) -1;
1008 /* Destroy an i386 ELF linker hash table. */
1011 elf_i386_link_hash_table_free (bfd *obfd)
1013 struct elf_i386_link_hash_table *htab
1014 = (struct elf_i386_link_hash_table *) obfd->link.hash;
1016 if (htab->loc_hash_table)
1017 htab_delete (htab->loc_hash_table);
1018 if (htab->loc_hash_memory)
1019 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
1020 _bfd_elf_link_hash_table_free (obfd);
1023 /* Create an i386 ELF linker hash table. */
1025 static struct bfd_link_hash_table *
1026 elf_i386_link_hash_table_create (bfd *abfd)
1028 struct elf_i386_link_hash_table *ret;
1029 bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
1031 ret = (struct elf_i386_link_hash_table *) bfd_zmalloc (amt);
1035 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
1036 elf_i386_link_hash_newfunc,
1037 sizeof (struct elf_i386_link_hash_entry),
1044 ret->loc_hash_table = htab_try_create (1024,
1045 elf_i386_local_htab_hash,
1046 elf_i386_local_htab_eq,
1048 ret->loc_hash_memory = objalloc_create ();
1049 if (!ret->loc_hash_table || !ret->loc_hash_memory)
1051 elf_i386_link_hash_table_free (abfd);
1054 ret->elf.root.hash_table_free = elf_i386_link_hash_table_free;
1056 return &ret->elf.root;
1059 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
1060 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
1064 elf_i386_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
1066 struct elf_i386_link_hash_table *htab;
1068 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1071 htab = elf_i386_hash_table (info);
1075 /* Set the contents of the .interp section to the interpreter. */
1076 if (bfd_link_executable (info) && !info->nointerp)
1078 asection *s = bfd_get_linker_section (dynobj, ".interp");
1081 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1082 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1086 htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
1090 if (bfd_link_executable (info))
1092 /* Always allow copy relocs for building executables. */
1093 asection *s = bfd_get_linker_section (dynobj, ".rel.bss");
1096 const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
1097 s = bfd_make_section_anyway_with_flags (dynobj,
1099 (bed->dynamic_sec_flags
1102 || ! bfd_set_section_alignment (dynobj, s,
1103 bed->s->log_file_align))
1109 if (get_elf_i386_backend_data (dynobj)->is_vxworks
1110 && !elf_vxworks_create_dynamic_sections (dynobj, info,
1114 if (!info->no_ld_generated_unwind_info
1115 && htab->plt_eh_frame == NULL
1116 && htab->elf.splt != NULL)
1118 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
1119 | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1120 | SEC_LINKER_CREATED);
1122 = bfd_make_section_anyway_with_flags (dynobj, ".eh_frame", flags);
1123 if (htab->plt_eh_frame == NULL
1124 || !bfd_set_section_alignment (dynobj, htab->plt_eh_frame, 2))
1131 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1134 elf_i386_copy_indirect_symbol (struct bfd_link_info *info,
1135 struct elf_link_hash_entry *dir,
1136 struct elf_link_hash_entry *ind)
1138 struct elf_i386_link_hash_entry *edir, *eind;
1140 edir = (struct elf_i386_link_hash_entry *) dir;
1141 eind = (struct elf_i386_link_hash_entry *) ind;
1143 if (eind->dyn_relocs != NULL)
1145 if (edir->dyn_relocs != NULL)
1147 struct elf_dyn_relocs **pp;
1148 struct elf_dyn_relocs *p;
1150 /* Add reloc counts against the indirect sym to the direct sym
1151 list. Merge any entries against the same section. */
1152 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1154 struct elf_dyn_relocs *q;
1156 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1157 if (q->sec == p->sec)
1159 q->pc_count += p->pc_count;
1160 q->count += p->count;
1167 *pp = edir->dyn_relocs;
1170 edir->dyn_relocs = eind->dyn_relocs;
1171 eind->dyn_relocs = NULL;
1174 if (ind->root.type == bfd_link_hash_indirect
1175 && dir->got.refcount <= 0)
1177 edir->tls_type = eind->tls_type;
1178 eind->tls_type = GOT_UNKNOWN;
1181 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1182 generate a R_386_COPY reloc. */
1183 edir->gotoff_ref |= eind->gotoff_ref;
1185 edir->has_got_reloc |= eind->has_got_reloc;
1186 edir->has_non_got_reloc |= eind->has_non_got_reloc;
1188 if (ELIMINATE_COPY_RELOCS
1189 && ind->root.type != bfd_link_hash_indirect
1190 && dir->dynamic_adjusted)
1192 /* If called to transfer flags for a weakdef during processing
1193 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1194 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1195 dir->ref_dynamic |= ind->ref_dynamic;
1196 dir->ref_regular |= ind->ref_regular;
1197 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1198 dir->needs_plt |= ind->needs_plt;
1199 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1203 if (eind->func_pointer_refcount > 0)
1205 edir->func_pointer_refcount += eind->func_pointer_refcount;
1206 eind->func_pointer_refcount = 0;
1209 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1213 /* Return TRUE if the TLS access code sequence support transition
1217 elf_i386_check_tls_transition (asection *sec,
1219 Elf_Internal_Shdr *symtab_hdr,
1220 struct elf_link_hash_entry **sym_hashes,
1221 unsigned int r_type,
1222 const Elf_Internal_Rela *rel,
1223 const Elf_Internal_Rela *relend)
1225 unsigned int val, type, reg;
1226 unsigned long r_symndx;
1227 struct elf_link_hash_entry *h;
1230 bfd_boolean indirect_call, tls_get_addr;
1232 offset = rel->r_offset;
1237 if (offset < 2 || (rel + 1) >= relend)
1240 indirect_call = FALSE;
1241 call = contents + offset + 4;
1244 if (r_type == R_386_TLS_GD)
1246 /* Check transition from GD access model. Only
1247 leal foo@tlsgd(,%ebx,1), %eax
1248 call ___tls_get_addr@PLT
1250 leal foo@tlsgd(%ebx) %eax
1251 call ___tls_get_addr@PLT
1254 leal foo@tlsgd(%reg), %eax
1255 call *___tls_get_addr@GOT(%reg)
1256 which may be converted to
1257 addr32 call ___tls_get_addr
1258 can transit to different access model. */
1259 if ((offset + 10) > sec->size
1260 || (type != 0x8d && type != 0x04))
1265 /* leal foo@tlsgd(,%ebx,1), %eax
1266 call ___tls_get_addr@PLT */
1270 if (*(call - 7) != 0x8d
1278 leal foo@tlsgd(%ebx), %eax
1279 call ___tls_get_addr@PLT
1282 leal foo@tlsgd(%reg), %eax
1283 call *___tls_get_addr@GOT(%reg)
1284 which may be converted to
1285 addr32 call ___tls_get_addr
1287 %eax can't be used as the GOT base register since it
1288 is used to pass parameter to ___tls_get_addr. */
1290 if ((val & 0xf8) != 0x80 || reg == 4 || reg == 0)
1293 indirect_call = call[0] == 0xff;
1294 if (!(reg == 3 && call[0] == 0xe8 && call[5] == 0x90)
1295 && !(call[0] == 0x67 && call[1] == 0xe8)
1297 && (call[1] & 0xf8) == 0x90
1298 && (call[1] & 0x7) == reg))
1304 /* Check transition from LD access model. Only
1305 leal foo@tlsldm(%ebx), %eax
1306 call ___tls_get_addr@PLT
1308 leal foo@tlsldm(%reg), %eax
1309 call *___tls_get_addr@GOT(%reg)
1310 which may be converted to
1311 addr32 call ___tls_get_addr
1312 can transit to different access model. */
1313 if (type != 0x8d || (offset + 9) > sec->size)
1316 /* %eax can't be used as the GOT base register since it is
1317 used to pass parameter to ___tls_get_addr. */
1319 if ((val & 0xf8) != 0x80 || reg == 4 || reg == 0)
1322 indirect_call = call[0] == 0xff;
1323 if (!(reg == 3 && call[0] == 0xe8)
1324 && !(call[0] == 0x67 && call[1] == 0xe8)
1326 && (call[1] & 0xf8) == 0x90
1327 && (call[1] & 0x7) == reg))
1331 r_symndx = ELF32_R_SYM (rel[1].r_info);
1332 if (r_symndx < symtab_hdr->sh_info)
1335 tls_get_addr = FALSE;
1336 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1337 if (h != NULL && h->root.root.string != NULL)
1339 struct elf_i386_link_hash_entry *eh
1340 = (struct elf_i386_link_hash_entry *) h;
1341 tls_get_addr = eh->tls_get_addr == 1;
1342 if (eh->tls_get_addr > 1)
1344 /* Use strncmp to check ___tls_get_addr since
1345 ___tls_get_addr may be versioned. */
1346 if (strncmp (h->root.root.string, "___tls_get_addr", 15)
1349 eh->tls_get_addr = 1;
1350 tls_get_addr = TRUE;
1353 eh->tls_get_addr = 0;
1359 else if (indirect_call)
1360 return (ELF32_R_TYPE (rel[1].r_info) == R_386_GOT32X);
1362 return (ELF32_R_TYPE (rel[1].r_info) == R_386_PC32
1363 || ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
1366 /* Check transition from IE access model:
1367 movl foo@indntpoff(%rip), %eax
1368 movl foo@indntpoff(%rip), %reg
1369 addl foo@indntpoff(%rip), %reg
1372 if (offset < 1 || (offset + 4) > sec->size)
1375 /* Check "movl foo@tpoff(%rip), %eax" first. */
1376 val = bfd_get_8 (abfd, contents + offset - 1);
1383 /* Check movl|addl foo@tpoff(%rip), %reg. */
1384 type = bfd_get_8 (abfd, contents + offset - 2);
1385 return ((type == 0x8b || type == 0x03)
1386 && (val & 0xc7) == 0x05);
1388 case R_386_TLS_GOTIE:
1389 case R_386_TLS_IE_32:
1390 /* Check transition from {IE_32,GOTIE} access model:
1391 subl foo@{tpoff,gontoff}(%reg1), %reg2
1392 movl foo@{tpoff,gontoff}(%reg1), %reg2
1393 addl foo@{tpoff,gontoff}(%reg1), %reg2
1396 if (offset < 2 || (offset + 4) > sec->size)
1399 val = bfd_get_8 (abfd, contents + offset - 1);
1400 if ((val & 0xc0) != 0x80 || (val & 7) == 4)
1403 type = bfd_get_8 (abfd, contents + offset - 2);
1404 return type == 0x8b || type == 0x2b || type == 0x03;
1406 case R_386_TLS_GOTDESC:
1407 /* Check transition from GDesc access model:
1408 leal x@tlsdesc(%ebx), %eax
1410 Make sure it's a leal adding ebx to a 32-bit offset
1411 into any register, although it's probably almost always
1414 if (offset < 2 || (offset + 4) > sec->size)
1417 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1420 val = bfd_get_8 (abfd, contents + offset - 1);
1421 return (val & 0xc7) == 0x83;
1423 case R_386_TLS_DESC_CALL:
1424 /* Check transition from GDesc access model:
1425 call *x@tlsdesc(%eax)
1427 if (offset + 2 <= sec->size)
1429 /* Make sure that it's a call *x@tlsdesc(%eax). */
1430 call = contents + offset;
1431 return call[0] == 0xff && call[1] == 0x10;
1441 /* Return TRUE if the TLS access transition is OK or no transition
1442 will be performed. Update R_TYPE if there is a transition. */
1445 elf_i386_tls_transition (struct bfd_link_info *info, bfd *abfd,
1446 asection *sec, bfd_byte *contents,
1447 Elf_Internal_Shdr *symtab_hdr,
1448 struct elf_link_hash_entry **sym_hashes,
1449 unsigned int *r_type, int tls_type,
1450 const Elf_Internal_Rela *rel,
1451 const Elf_Internal_Rela *relend,
1452 struct elf_link_hash_entry *h,
1453 unsigned long r_symndx,
1454 bfd_boolean from_relocate_section)
1456 unsigned int from_type = *r_type;
1457 unsigned int to_type = from_type;
1458 bfd_boolean check = TRUE;
1460 /* Skip TLS transition for functions. */
1462 && (h->type == STT_FUNC
1463 || h->type == STT_GNU_IFUNC))
1469 case R_386_TLS_GOTDESC:
1470 case R_386_TLS_DESC_CALL:
1471 case R_386_TLS_IE_32:
1473 case R_386_TLS_GOTIE:
1474 if (bfd_link_executable (info))
1477 to_type = R_386_TLS_LE_32;
1478 else if (from_type != R_386_TLS_IE
1479 && from_type != R_386_TLS_GOTIE)
1480 to_type = R_386_TLS_IE_32;
1483 /* When we are called from elf_i386_relocate_section, there may
1484 be additional transitions based on TLS_TYPE. */
1485 if (from_relocate_section)
1487 unsigned int new_to_type = to_type;
1489 if (bfd_link_executable (info)
1492 && (tls_type & GOT_TLS_IE))
1493 new_to_type = R_386_TLS_LE_32;
1495 if (to_type == R_386_TLS_GD
1496 || to_type == R_386_TLS_GOTDESC
1497 || to_type == R_386_TLS_DESC_CALL)
1499 if (tls_type == GOT_TLS_IE_POS)
1500 new_to_type = R_386_TLS_GOTIE;
1501 else if (tls_type & GOT_TLS_IE)
1502 new_to_type = R_386_TLS_IE_32;
1505 /* We checked the transition before when we were called from
1506 elf_i386_check_relocs. We only want to check the new
1507 transition which hasn't been checked before. */
1508 check = new_to_type != to_type && from_type == to_type;
1509 to_type = new_to_type;
1515 if (bfd_link_executable (info))
1516 to_type = R_386_TLS_LE_32;
1523 /* Return TRUE if there is no transition. */
1524 if (from_type == to_type)
1527 /* Check if the transition can be performed. */
1529 && ! elf_i386_check_tls_transition (sec, contents,
1530 symtab_hdr, sym_hashes,
1531 from_type, rel, relend))
1533 reloc_howto_type *from, *to;
1536 from = elf_i386_rtype_to_howto (abfd, from_type);
1537 to = elf_i386_rtype_to_howto (abfd, to_type);
1540 name = h->root.root.string;
1543 struct elf_i386_link_hash_table *htab;
1545 htab = elf_i386_hash_table (info);
1550 Elf_Internal_Sym *isym;
1552 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1554 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1558 (*_bfd_error_handler)
1559 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1560 "in section `%A' failed"),
1561 abfd, sec, from->name, to->name, name,
1562 (unsigned long) rel->r_offset);
1563 bfd_set_error (bfd_error_bad_value);
1571 /* With the local symbol, foo, we convert
1572 mov foo@GOT[(%reg1)], %reg2
1574 lea foo[@GOTOFF(%reg1)], %reg2
1576 call/jmp *foo@GOT[(%reg)]
1578 nop call foo/jmp foo nop
1579 When PIC is false, convert
1580 test %reg1, foo@GOT[(%reg2)]
1584 binop foo@GOT[(%reg1)], %reg2
1587 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1592 elf_i386_convert_load_reloc (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
1594 Elf_Internal_Rela *irel,
1595 struct elf_link_hash_entry *h,
1596 bfd_boolean *converted,
1597 struct bfd_link_info *link_info)
1599 struct elf_i386_link_hash_table *htab;
1600 unsigned int opcode;
1602 bfd_boolean baseless;
1603 Elf_Internal_Sym *isym;
1604 unsigned int addend;
1608 bfd_boolean to_reloc_32;
1609 unsigned int r_type;
1610 unsigned int r_symndx;
1611 bfd_vma roff = irel->r_offset;
1616 /* Addend for R_386_GOT32X relocations must be 0. */
1617 addend = bfd_get_32 (abfd, contents + roff);
1621 htab = elf_i386_hash_table (link_info);
1622 is_pic = bfd_link_pic (link_info);
1624 r_type = ELF32_R_TYPE (irel->r_info);
1625 r_symndx = ELF32_R_SYM (irel->r_info);
1627 modrm = bfd_get_8 (abfd, contents + roff - 1);
1628 baseless = (modrm & 0xc7) == 0x5;
1630 if (baseless && is_pic)
1632 /* For PIC, disallow R_386_GOT32X without a base register
1633 since we don't know what the GOT base is. */
1638 isym = bfd_sym_from_r_symndx (&htab->sym_cache, abfd,
1640 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1643 name = h->root.root.string;
1645 (*_bfd_error_handler)
1646 (_("%B: direct GOT relocation R_386_GOT32X against `%s' without base register can not be used when making a shared object"),
1651 opcode = bfd_get_8 (abfd, contents + roff - 2);
1653 /* Convert to R_386_32 if PIC is false or there is no base
1655 to_reloc_32 = !is_pic || baseless;
1657 /* Try to convert R_386_GOT32X. Get the symbol referred to by the
1661 if (opcode == 0x0ff)
1662 /* Convert "call/jmp *foo@GOT[(%reg)]". */
1663 goto convert_branch;
1665 /* Convert "mov foo@GOT[(%reg1)], %reg2",
1666 "test %reg1, foo@GOT(%reg2)" and
1667 "binop foo@GOT[(%reg1)], %reg2". */
1671 /* Undefined weak symbol is only bound locally in executable
1672 and its reference is resolved as 0. */
1673 if (UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info, TRUE,
1674 elf_i386_hash_entry (h)))
1678 /* No direct branch to 0 for PIC. */
1682 goto convert_branch;
1686 /* We can convert load of address 0 to R_386_32. */
1694 /* We have "call/jmp *foo@GOT[(%reg)]". */
1695 if ((h->root.type == bfd_link_hash_defined
1696 || h->root.type == bfd_link_hash_defweak)
1697 && SYMBOL_REFERENCES_LOCAL (link_info, h))
1699 /* The function is locally defined. */
1701 /* Convert R_386_GOT32X to R_386_PC32. */
1702 if (modrm == 0x15 || (modrm & 0xf8) == 0x90)
1704 struct elf_i386_link_hash_entry *eh
1705 = (struct elf_i386_link_hash_entry *) h;
1707 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
1710 /* To support TLS optimization, always use addr32 prefix
1711 for "call *___tls_get_addr@GOT(%reg)". */
1712 if (eh && eh->tls_get_addr == 1)
1715 nop_offset = irel->r_offset - 2;
1719 nop = link_info->call_nop_byte;
1720 if (link_info->call_nop_as_suffix)
1722 nop_offset = roff + 3;
1723 irel->r_offset -= 1;
1726 nop_offset = roff - 2;
1731 /* Convert to "jmp foo nop". */
1734 nop_offset = roff + 3;
1735 irel->r_offset -= 1;
1738 bfd_put_8 (abfd, nop, contents + nop_offset);
1739 bfd_put_8 (abfd, modrm, contents + irel->r_offset - 1);
1740 /* When converting to PC-relative relocation, we
1741 need to adjust addend by -4. */
1742 bfd_put_32 (abfd, -4, contents + irel->r_offset);
1743 irel->r_info = ELF32_R_INFO (r_symndx, R_386_PC32);
1750 /* We have "mov foo@GOT[(%re1g)], %reg2",
1751 "test %reg1, foo@GOT(%reg2)" and
1752 "binop foo@GOT[(%reg1)], %reg2".
1754 Avoid optimizing _DYNAMIC since ld.so may use its
1755 link-time address. */
1756 if (h == htab->elf.hdynamic)
1759 /* def_regular is set by an assignment in a linker script in
1760 bfd_elf_record_link_assignment. */
1762 || h->root.type == bfd_link_hash_defined
1763 || h->root.type == bfd_link_hash_defweak)
1764 && SYMBOL_REFERENCES_LOCAL (link_info, h))
1771 /* Convert "mov foo@GOT[(%reg1)], %reg2" to
1772 "mov $foo, %reg2" with R_386_32. */
1774 modrm = 0xc0 | (modrm & 0x38) >> 3;
1775 bfd_put_8 (abfd, modrm, contents + roff - 1);
1780 /* Convert "mov foo@GOT(%reg1), %reg2" to
1781 "lea foo@GOTOFF(%reg1), %reg2". */
1782 r_type = R_386_GOTOFF;
1788 /* Only R_386_32 is supported. */
1794 /* Convert "test %reg1, foo@GOT(%reg2)" to
1795 "test $foo, %reg1". */
1796 modrm = 0xc0 | (modrm & 0x38) >> 3;
1801 /* Convert "binop foo@GOT(%reg1), %reg2" to
1802 "binop $foo, %reg2". */
1804 | (modrm & 0x38) >> 3
1808 bfd_put_8 (abfd, modrm, contents + roff - 1);
1812 bfd_put_8 (abfd, opcode, contents + roff - 2);
1813 irel->r_info = ELF32_R_INFO (r_symndx, r_type);
1822 /* Rename some of the generic section flags to better document how they
1824 #define need_convert_load sec_flg0
1825 #define check_relocs_failed sec_flg1
1827 /* Look through the relocs for a section during the first phase, and
1828 calculate needed space in the global offset table, procedure linkage
1829 table, and dynamic reloc sections. */
1832 elf_i386_check_relocs (bfd *abfd,
1833 struct bfd_link_info *info,
1835 const Elf_Internal_Rela *relocs)
1837 struct elf_i386_link_hash_table *htab;
1838 Elf_Internal_Shdr *symtab_hdr;
1839 struct elf_link_hash_entry **sym_hashes;
1840 const Elf_Internal_Rela *rel;
1841 const Elf_Internal_Rela *rel_end;
1844 bfd_boolean use_plt_got;
1846 if (bfd_link_relocatable (info))
1849 BFD_ASSERT (is_i386_elf (abfd));
1851 htab = elf_i386_hash_table (info);
1854 sec->check_relocs_failed = 1;
1858 /* Get the section contents. */
1859 if (elf_section_data (sec)->this_hdr.contents != NULL)
1860 contents = elf_section_data (sec)->this_hdr.contents;
1861 else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1863 sec->check_relocs_failed = 1;
1867 use_plt_got = (!get_elf_i386_backend_data (abfd)->is_vxworks
1868 && (get_elf_i386_backend_data (abfd)
1869 == &elf_i386_arch_bed));
1871 symtab_hdr = &elf_symtab_hdr (abfd);
1872 sym_hashes = elf_sym_hashes (abfd);
1876 rel_end = relocs + sec->reloc_count;
1877 for (rel = relocs; rel < rel_end; rel++)
1879 unsigned int r_type;
1880 unsigned long r_symndx;
1881 struct elf_link_hash_entry *h;
1882 struct elf_i386_link_hash_entry *eh;
1883 Elf_Internal_Sym *isym;
1885 bfd_boolean size_reloc;
1887 r_symndx = ELF32_R_SYM (rel->r_info);
1888 r_type = ELF32_R_TYPE (rel->r_info);
1890 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1892 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1898 if (r_symndx < symtab_hdr->sh_info)
1900 /* A local symbol. */
1901 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1906 /* Check relocation against local STT_GNU_IFUNC symbol. */
1907 if (ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1909 h = elf_i386_get_local_sym_hash (htab, abfd, rel, TRUE);
1913 /* Fake a STT_GNU_IFUNC symbol. */
1914 h->type = STT_GNU_IFUNC;
1917 h->forced_local = 1;
1918 h->root.type = bfd_link_hash_defined;
1926 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1927 while (h->root.type == bfd_link_hash_indirect
1928 || h->root.type == bfd_link_hash_warning)
1929 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1932 eh = (struct elf_i386_link_hash_entry *) h;
1947 if (htab->elf.dynobj == NULL)
1948 htab->elf.dynobj = abfd;
1949 /* Create the ifunc sections for static executables. */
1950 if (h->type == STT_GNU_IFUNC
1951 && !_bfd_elf_create_ifunc_sections (htab->elf.dynobj,
1957 /* It is referenced by a non-shared object. */
1959 h->root.non_ir_ref = 1;
1961 if (h->type == STT_GNU_IFUNC)
1962 elf_tdata (info->output_bfd)->has_gnu_symbols
1963 |= elf_gnu_symbol_ifunc;
1966 if (! elf_i386_tls_transition (info, abfd, sec, contents,
1967 symtab_hdr, sym_hashes,
1968 &r_type, GOT_UNKNOWN,
1969 rel, rel_end, h, r_symndx, FALSE))
1975 htab->tls_ldm_got.refcount += 1;
1979 /* This symbol requires a procedure linkage table entry. We
1980 actually build the entry in adjust_dynamic_symbol,
1981 because this might be a case of linking PIC code which is
1982 never referenced by a dynamic object, in which case we
1983 don't need to generate a procedure linkage table entry
1986 /* If this is a local symbol, we resolve it directly without
1987 creating a procedure linkage table entry. */
1991 eh->has_got_reloc = 1;
1993 h->plt.refcount += 1;
2000 case R_386_TLS_IE_32:
2002 case R_386_TLS_GOTIE:
2003 if (!bfd_link_executable (info))
2004 info->flags |= DF_STATIC_TLS;
2010 case R_386_TLS_GOTDESC:
2011 case R_386_TLS_DESC_CALL:
2012 /* This symbol requires a global offset table entry. */
2014 int tls_type, old_tls_type;
2021 tls_type = GOT_NORMAL;
2023 case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
2024 case R_386_TLS_GOTDESC:
2025 case R_386_TLS_DESC_CALL:
2026 tls_type = GOT_TLS_GDESC; break;
2027 case R_386_TLS_IE_32:
2028 if (ELF32_R_TYPE (rel->r_info) == r_type)
2029 tls_type = GOT_TLS_IE_NEG;
2031 /* If this is a GD->IE transition, we may use either of
2032 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
2033 tls_type = GOT_TLS_IE;
2036 case R_386_TLS_GOTIE:
2037 tls_type = GOT_TLS_IE_POS; break;
2042 h->got.refcount += 1;
2043 old_tls_type = elf_i386_hash_entry(h)->tls_type;
2047 bfd_signed_vma *local_got_refcounts;
2049 /* This is a global offset table entry for a local symbol. */
2050 local_got_refcounts = elf_local_got_refcounts (abfd);
2051 if (local_got_refcounts == NULL)
2055 size = symtab_hdr->sh_info;
2056 size *= (sizeof (bfd_signed_vma)
2057 + sizeof (bfd_vma) + sizeof(char));
2058 local_got_refcounts = (bfd_signed_vma *)
2059 bfd_zalloc (abfd, size);
2060 if (local_got_refcounts == NULL)
2062 elf_local_got_refcounts (abfd) = local_got_refcounts;
2063 elf_i386_local_tlsdesc_gotent (abfd)
2064 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
2065 elf_i386_local_got_tls_type (abfd)
2066 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
2068 local_got_refcounts[r_symndx] += 1;
2069 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
2072 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
2073 tls_type |= old_tls_type;
2074 /* If a TLS symbol is accessed using IE at least once,
2075 there is no point to use dynamic model for it. */
2076 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
2077 && (! GOT_TLS_GD_ANY_P (old_tls_type)
2078 || (tls_type & GOT_TLS_IE) == 0))
2080 if ((old_tls_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (tls_type))
2081 tls_type = old_tls_type;
2082 else if (GOT_TLS_GD_ANY_P (old_tls_type)
2083 && GOT_TLS_GD_ANY_P (tls_type))
2084 tls_type |= old_tls_type;
2088 name = h->root.root.string;
2090 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
2092 (*_bfd_error_handler)
2093 (_("%B: `%s' accessed both as normal and "
2094 "thread local symbol"),
2096 bfd_set_error (bfd_error_bad_value);
2101 if (old_tls_type != tls_type)
2104 elf_i386_hash_entry (h)->tls_type = tls_type;
2106 elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
2114 if (htab->elf.sgot == NULL)
2116 if (htab->elf.dynobj == NULL)
2117 htab->elf.dynobj = abfd;
2118 if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
2121 if (r_type != R_386_TLS_IE)
2124 eh->has_got_reloc = 1;
2129 case R_386_TLS_LE_32:
2132 eh->has_got_reloc = 1;
2133 if (bfd_link_executable (info))
2135 info->flags |= DF_STATIC_TLS;
2140 if (eh != NULL && (sec->flags & SEC_CODE) != 0)
2141 eh->has_non_got_reloc = 1;
2143 /* STT_GNU_IFUNC symbol must go through PLT even if it is
2144 locally defined and undefined symbol may turn out to be
2145 a STT_GNU_IFUNC symbol later. */
2147 && (bfd_link_executable (info)
2148 || ((h->type == STT_GNU_IFUNC
2149 || h->root.type == bfd_link_hash_undefweak
2150 || h->root.type == bfd_link_hash_undefined)
2151 && SYMBOLIC_BIND (info, h))))
2153 /* If this reloc is in a read-only section, we might
2154 need a copy reloc. We can't check reliably at this
2155 stage whether the section is read-only, as input
2156 sections have not yet been mapped to output sections.
2157 Tentatively set the flag for now, and correct in
2158 adjust_dynamic_symbol. */
2161 /* We may need a .plt entry if the function this reloc
2162 refers to is in a shared lib. */
2163 h->plt.refcount += 1;
2164 if (r_type == R_386_PC32)
2166 /* Since something like ".long foo - ." may be used
2167 as pointer, make sure that PLT is used if foo is
2168 a function defined in a shared library. */
2169 if ((sec->flags & SEC_CODE) == 0)
2170 h->pointer_equality_needed = 1;
2174 h->pointer_equality_needed = 1;
2175 /* R_386_32 can be resolved at run-time. */
2176 if (r_type == R_386_32
2177 && (sec->flags & SEC_READONLY) == 0)
2178 eh->func_pointer_refcount += 1;
2184 /* If we are creating a shared library, and this is a reloc
2185 against a global symbol, or a non PC relative reloc
2186 against a local symbol, then we need to copy the reloc
2187 into the shared library. However, if we are linking with
2188 -Bsymbolic, we do not need to copy a reloc against a
2189 global symbol which is defined in an object we are
2190 including in the link (i.e., DEF_REGULAR is set). At
2191 this point we have not seen all the input files, so it is
2192 possible that DEF_REGULAR is not set now but will be set
2193 later (it is never cleared). In case of a weak definition,
2194 DEF_REGULAR may be cleared later by a strong definition in
2195 a shared library. We account for that possibility below by
2196 storing information in the relocs_copied field of the hash
2197 table entry. A similar situation occurs when creating
2198 shared libraries and symbol visibility changes render the
2201 If on the other hand, we are creating an executable, we
2202 may need to keep relocations for symbols satisfied by a
2203 dynamic library if we manage to avoid copy relocs for the
2205 if ((bfd_link_pic (info)
2206 && (sec->flags & SEC_ALLOC) != 0
2207 && (r_type != R_386_PC32
2209 && (! (bfd_link_pie (info)
2210 || SYMBOLIC_BIND (info, h))
2211 || h->root.type == bfd_link_hash_defweak
2212 || !h->def_regular))))
2213 || (ELIMINATE_COPY_RELOCS
2214 && !bfd_link_pic (info)
2215 && (sec->flags & SEC_ALLOC) != 0
2217 && (h->root.type == bfd_link_hash_defweak
2218 || !h->def_regular)))
2220 struct elf_dyn_relocs *p;
2221 struct elf_dyn_relocs **head;
2223 /* We must copy these reloc types into the output file.
2224 Create a reloc section in dynobj and make room for
2228 if (htab->elf.dynobj == NULL)
2229 htab->elf.dynobj = abfd;
2231 sreloc = _bfd_elf_make_dynamic_reloc_section
2232 (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ FALSE);
2238 /* If this is a global symbol, we count the number of
2239 relocations we need for this symbol. */
2242 head = &eh->dyn_relocs;
2246 /* Track dynamic relocs needed for local syms too.
2247 We really need local syms available to do this
2252 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2257 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
2261 vpp = &elf_section_data (s)->local_dynrel;
2262 head = (struct elf_dyn_relocs **)vpp;
2266 if (p == NULL || p->sec != sec)
2268 bfd_size_type amt = sizeof *p;
2269 p = (struct elf_dyn_relocs *) bfd_alloc (htab->elf.dynobj,
2281 /* Count size relocation as PC-relative relocation. */
2282 if (r_type == R_386_PC32 || size_reloc)
2287 /* This relocation describes the C++ object vtable hierarchy.
2288 Reconstruct it for later use during GC. */
2289 case R_386_GNU_VTINHERIT:
2290 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2294 /* This relocation describes which C++ vtable entries are actually
2295 used. Record for later use during GC. */
2296 case R_386_GNU_VTENTRY:
2297 BFD_ASSERT (h != NULL);
2299 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
2309 && h->plt.refcount > 0
2310 && (((info->flags & DF_BIND_NOW) && !h->pointer_equality_needed)
2311 || h->got.refcount > 0)
2312 && htab->plt_got == NULL)
2314 /* Create the GOT procedure linkage table. */
2315 unsigned int plt_got_align;
2316 const struct elf_backend_data *bed;
2318 bed = get_elf_backend_data (info->output_bfd);
2319 BFD_ASSERT (sizeof (elf_i386_got_plt_entry) == 8
2320 && (sizeof (elf_i386_got_plt_entry)
2321 == sizeof (elf_i386_pic_got_plt_entry)));
2324 if (htab->elf.dynobj == NULL)
2325 htab->elf.dynobj = abfd;
2327 = bfd_make_section_anyway_with_flags (htab->elf.dynobj,
2329 (bed->dynamic_sec_flags
2334 if (htab->plt_got == NULL
2335 || !bfd_set_section_alignment (htab->elf.dynobj,
2341 if (r_type == R_386_GOT32X
2342 && (h == NULL || h->type != STT_GNU_IFUNC))
2343 sec->need_convert_load = 1;
2346 if (elf_section_data (sec)->this_hdr.contents != contents)
2348 if (!info->keep_memory)
2352 /* Cache the section contents for elf_link_input_bfd. */
2353 elf_section_data (sec)->this_hdr.contents = contents;
2360 if (elf_section_data (sec)->this_hdr.contents != contents)
2362 sec->check_relocs_failed = 1;
2366 /* Return the section that should be marked against GC for a given
2370 elf_i386_gc_mark_hook (asection *sec,
2371 struct bfd_link_info *info,
2372 Elf_Internal_Rela *rel,
2373 struct elf_link_hash_entry *h,
2374 Elf_Internal_Sym *sym)
2377 switch (ELF32_R_TYPE (rel->r_info))
2379 case R_386_GNU_VTINHERIT:
2380 case R_386_GNU_VTENTRY:
2384 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2387 /* Remove undefined weak symbol from the dynamic symbol table if it
2388 is resolved to 0. */
2391 elf_i386_fixup_symbol (struct bfd_link_info *info,
2392 struct elf_link_hash_entry *h)
2394 if (h->dynindx != -1
2395 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
2396 elf_i386_hash_entry (h)->has_got_reloc,
2397 elf_i386_hash_entry (h)))
2400 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
2406 /* Adjust a symbol defined by a dynamic object and referenced by a
2407 regular object. The current definition is in some section of the
2408 dynamic object, but we're not including those sections. We have to
2409 change the definition to something the rest of the link can
2413 elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info,
2414 struct elf_link_hash_entry *h)
2416 struct elf_i386_link_hash_table *htab;
2418 struct elf_i386_link_hash_entry *eh;
2419 struct elf_dyn_relocs *p;
2421 /* STT_GNU_IFUNC symbol must go through PLT. */
2422 if (h->type == STT_GNU_IFUNC)
2424 /* All local STT_GNU_IFUNC references must be treate as local
2425 calls via local PLT. */
2427 && SYMBOL_CALLS_LOCAL (info, h))
2429 bfd_size_type pc_count = 0, count = 0;
2430 struct elf_dyn_relocs **pp;
2432 eh = (struct elf_i386_link_hash_entry *) h;
2433 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2435 pc_count += p->pc_count;
2436 p->count -= p->pc_count;
2445 if (pc_count || count)
2449 if (h->plt.refcount <= 0)
2450 h->plt.refcount = 1;
2452 h->plt.refcount += 1;
2456 if (h->plt.refcount <= 0)
2458 h->plt.offset = (bfd_vma) -1;
2464 /* If this is a function, put it in the procedure linkage table. We
2465 will fill in the contents of the procedure linkage table later,
2466 when we know the address of the .got section. */
2467 if (h->type == STT_FUNC
2470 if (h->plt.refcount <= 0
2471 || SYMBOL_CALLS_LOCAL (info, h)
2472 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2473 && h->root.type == bfd_link_hash_undefweak))
2475 /* This case can occur if we saw a PLT32 reloc in an input
2476 file, but the symbol was never referred to by a dynamic
2477 object, or if all references were garbage collected. In
2478 such a case, we don't actually need to build a procedure
2479 linkage table, and we can just do a PC32 reloc instead. */
2480 h->plt.offset = (bfd_vma) -1;
2487 /* It's possible that we incorrectly decided a .plt reloc was
2488 needed for an R_386_PC32 reloc to a non-function sym in
2489 check_relocs. We can't decide accurately between function and
2490 non-function syms in check-relocs; Objects loaded later in
2491 the link may change h->type. So fix it now. */
2492 h->plt.offset = (bfd_vma) -1;
2494 /* If this is a weak symbol, and there is a real definition, the
2495 processor independent code will have arranged for us to see the
2496 real definition first, and we can just use the same value. */
2497 if (h->u.weakdef != NULL)
2499 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2500 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2501 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2502 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2503 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
2504 h->non_got_ref = h->u.weakdef->non_got_ref;
2508 /* This is a reference to a symbol defined by a dynamic object which
2509 is not a function. */
2511 /* If we are creating a shared library, we must presume that the
2512 only references to the symbol are via the global offset table.
2513 For such cases we need not do anything here; the relocations will
2514 be handled correctly by relocate_section. */
2515 if (!bfd_link_executable (info))
2518 /* If there are no references to this symbol that do not use the
2519 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
2521 eh = (struct elf_i386_link_hash_entry *) h;
2522 if (!h->non_got_ref && !eh->gotoff_ref)
2525 /* If -z nocopyreloc was given, we won't generate them either. */
2526 if (info->nocopyreloc)
2532 htab = elf_i386_hash_table (info);
2536 /* If there aren't any dynamic relocs in read-only sections nor
2537 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
2538 avoid the copy reloc. This doesn't work on VxWorks, where we can
2539 not have dynamic relocations (other than copy and jump slot
2540 relocations) in an executable. */
2541 if (ELIMINATE_COPY_RELOCS
2543 && !get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
2545 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2547 s = p->sec->output_section;
2548 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2559 /* We must allocate the symbol in our .dynbss section, which will
2560 become part of the .bss section of the executable. There will be
2561 an entry for this symbol in the .dynsym section. The dynamic
2562 object will contain position independent code, so all references
2563 from the dynamic object to this symbol will go through the global
2564 offset table. The dynamic linker will use the .dynsym entry to
2565 determine the address it must put in the global offset table, so
2566 both the dynamic object and the regular object will refer to the
2567 same memory location for the variable. */
2569 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
2570 copy the initial value out of the dynamic object and into the
2571 runtime process image. */
2572 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2574 htab->srelbss->size += sizeof (Elf32_External_Rel);
2580 return _bfd_elf_adjust_dynamic_copy (info, h, s);
2583 /* Allocate space in .plt, .got and associated reloc sections for
2587 elf_i386_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
2589 struct bfd_link_info *info;
2590 struct elf_i386_link_hash_table *htab;
2591 struct elf_i386_link_hash_entry *eh;
2592 struct elf_dyn_relocs *p;
2593 unsigned plt_entry_size;
2594 bfd_boolean resolved_to_zero;
2596 if (h->root.type == bfd_link_hash_indirect)
2599 eh = (struct elf_i386_link_hash_entry *) h;
2601 info = (struct bfd_link_info *) inf;
2602 htab = elf_i386_hash_table (info);
2606 plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
2608 resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
2612 /* Clear the reference count of function pointer relocations if
2613 symbol isn't a normal function. */
2614 if (h->type != STT_FUNC)
2615 eh->func_pointer_refcount = 0;
2617 /* We can't use the GOT PLT if pointer equality is needed since
2618 finish_dynamic_symbol won't clear symbol value and the dynamic
2619 linker won't update the GOT slot. We will get into an infinite
2620 loop at run-time. */
2621 if (htab->plt_got != NULL
2622 && h->type != STT_GNU_IFUNC
2623 && !h->pointer_equality_needed
2624 && h->plt.refcount > 0
2625 && h->got.refcount > 0)
2627 /* Don't use the regular PLT if there are both GOT and GOTPLT
2629 h->plt.offset = (bfd_vma) -1;
2631 /* Use the GOT PLT. */
2632 eh->plt_got.refcount = 1;
2635 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2636 here if it is defined and referenced in a non-shared object. */
2637 if (h->type == STT_GNU_IFUNC
2639 return _bfd_elf_allocate_ifunc_dyn_relocs (info, h, &eh->dyn_relocs,
2640 &htab->readonly_dynrelocs_against_ifunc,
2643 /* Don't create the PLT entry if there are only function pointer
2644 relocations which can be resolved at run-time. */
2645 else if (htab->elf.dynamic_sections_created
2646 && (h->plt.refcount > eh->func_pointer_refcount
2647 || eh->plt_got.refcount > 0))
2649 bfd_boolean use_plt_got;
2651 /* Clear the reference count of function pointer relocations
2653 eh->func_pointer_refcount = 0;
2655 if ((info->flags & DF_BIND_NOW) && !h->pointer_equality_needed)
2657 /* Don't use the regular PLT for DF_BIND_NOW. */
2658 h->plt.offset = (bfd_vma) -1;
2660 /* Use the GOT PLT. */
2661 h->got.refcount = 1;
2662 eh->plt_got.refcount = 1;
2665 use_plt_got = eh->plt_got.refcount > 0;
2667 /* Make sure this symbol is output as a dynamic symbol.
2668 Undefined weak syms won't yet be marked as dynamic. */
2669 if (h->dynindx == -1
2671 && !resolved_to_zero)
2673 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2677 if (bfd_link_pic (info)
2678 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2680 asection *s = htab->elf.splt;
2681 asection *got_s = htab->plt_got;
2683 /* If this is the first .plt entry, make room for the special
2684 first entry. The .plt section is used by prelink to undo
2685 prelinking for dynamic relocations. */
2687 s->size = plt_entry_size;
2690 eh->plt_got.offset = got_s->size;
2692 h->plt.offset = s->size;
2694 /* If this symbol is not defined in a regular file, and we are
2695 not generating a shared library, then set the symbol to this
2696 location in the .plt. This is required to make function
2697 pointers compare as equal between the normal executable and
2698 the shared library. */
2699 if (! bfd_link_pic (info)
2704 /* We need to make a call to the entry of the GOT PLT
2705 instead of regular PLT entry. */
2706 h->root.u.def.section = got_s;
2707 h->root.u.def.value = eh->plt_got.offset;
2711 h->root.u.def.section = s;
2712 h->root.u.def.value = h->plt.offset;
2716 /* Make room for this entry. */
2718 got_s->size += sizeof (elf_i386_got_plt_entry);
2721 s->size += plt_entry_size;
2723 /* We also need to make an entry in the .got.plt section,
2724 which will be placed in the .got section by the linker
2726 htab->elf.sgotplt->size += 4;
2728 /* There should be no PLT relocation against resolved
2729 undefined weak symbol in executable. */
2730 if (!resolved_to_zero)
2732 /* We also need to make an entry in the .rel.plt
2734 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2735 htab->elf.srelplt->reloc_count++;
2739 if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks
2740 && !bfd_link_pic (info))
2742 /* VxWorks has a second set of relocations for each PLT entry
2743 in executables. They go in a separate relocation section,
2744 which is processed by the kernel loader. */
2746 /* There are two relocations for the initial PLT entry: an
2747 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2748 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
2750 if (h->plt.offset == plt_entry_size)
2751 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2753 /* There are two extra relocations for each subsequent PLT entry:
2754 an R_386_32 relocation for the GOT entry, and an R_386_32
2755 relocation for the PLT entry. */
2757 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2762 eh->plt_got.offset = (bfd_vma) -1;
2763 h->plt.offset = (bfd_vma) -1;
2769 eh->plt_got.offset = (bfd_vma) -1;
2770 h->plt.offset = (bfd_vma) -1;
2774 eh->tlsdesc_got = (bfd_vma) -1;
2776 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
2777 make it a R_386_TLS_LE_32 requiring no TLS entry. */
2778 if (h->got.refcount > 0
2779 && bfd_link_executable (info)
2781 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
2782 h->got.offset = (bfd_vma) -1;
2783 else if (h->got.refcount > 0)
2787 int tls_type = elf_i386_hash_entry(h)->tls_type;
2789 /* Make sure this symbol is output as a dynamic symbol.
2790 Undefined weak syms won't yet be marked as dynamic. */
2791 if (h->dynindx == -1
2793 && !resolved_to_zero)
2795 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2800 if (GOT_TLS_GDESC_P (tls_type))
2802 eh->tlsdesc_got = htab->elf.sgotplt->size
2803 - elf_i386_compute_jump_table_size (htab);
2804 htab->elf.sgotplt->size += 8;
2805 h->got.offset = (bfd_vma) -2;
2807 if (! GOT_TLS_GDESC_P (tls_type)
2808 || GOT_TLS_GD_P (tls_type))
2810 h->got.offset = s->size;
2812 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
2813 if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
2816 dyn = htab->elf.dynamic_sections_created;
2817 /* R_386_TLS_IE_32 needs one dynamic relocation,
2818 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2819 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2820 need two), R_386_TLS_GD needs one if local symbol and two if
2821 global. No dynamic relocation against resolved undefined weak
2822 symbol in executable. */
2823 if (tls_type == GOT_TLS_IE_BOTH)
2824 htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
2825 else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
2826 || (tls_type & GOT_TLS_IE))
2827 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2828 else if (GOT_TLS_GD_P (tls_type))
2829 htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
2830 else if (! GOT_TLS_GDESC_P (tls_type)
2831 && ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2832 && !resolved_to_zero)
2833 || h->root.type != bfd_link_hash_undefweak)
2834 && (bfd_link_pic (info)
2835 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
2836 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2837 if (GOT_TLS_GDESC_P (tls_type))
2838 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2841 h->got.offset = (bfd_vma) -1;
2843 if (eh->dyn_relocs == NULL)
2846 /* In the shared -Bsymbolic case, discard space allocated for
2847 dynamic pc-relative relocs against symbols which turn out to be
2848 defined in regular objects. For the normal shared case, discard
2849 space for pc-relative relocs that have become local due to symbol
2850 visibility changes. */
2852 if (bfd_link_pic (info))
2854 /* The only reloc that uses pc_count is R_386_PC32, which will
2855 appear on a call or on something like ".long foo - .". We
2856 want calls to protected symbols to resolve directly to the
2857 function rather than going via the plt. If people want
2858 function pointer comparisons to work as expected then they
2859 should avoid writing assembly like ".long foo - .". */
2860 if (SYMBOL_CALLS_LOCAL (info, h))
2862 struct elf_dyn_relocs **pp;
2864 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2866 p->count -= p->pc_count;
2875 if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
2877 struct elf_dyn_relocs **pp;
2878 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2880 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2887 /* Also discard relocs on undefined weak syms with non-default
2888 visibility or in PIE. */
2889 if (eh->dyn_relocs != NULL
2890 && h->root.type == bfd_link_hash_undefweak)
2892 /* Undefined weak symbol is never bound locally in shared
2894 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2895 || resolved_to_zero)
2899 /* Keep dynamic non-GOT/non-PLT relocation so that we
2900 can branch to 0 without PLT. */
2901 struct elf_dyn_relocs **pp;
2903 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2904 if (p->pc_count == 0)
2908 /* Remove non-R_386_PC32 relocation. */
2909 p->count = p->pc_count;
2913 if (eh->dyn_relocs != NULL)
2915 /* Make sure undefined weak symbols are output
2916 as dynamic symbols in PIEs for dynamic non-GOT
2917 non-PLT reloations. */
2918 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2923 eh->dyn_relocs = NULL;
2925 else if (h->dynindx == -1
2926 && !h->forced_local)
2928 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2933 else if (ELIMINATE_COPY_RELOCS)
2935 /* For the non-shared case, discard space for relocs against
2936 symbols which turn out to need copy relocs or are not
2937 dynamic. Keep dynamic relocations for run-time function
2938 pointer initialization. */
2940 if ((!h->non_got_ref
2941 || eh->func_pointer_refcount > 0
2942 || (h->root.type == bfd_link_hash_undefweak
2943 && !resolved_to_zero))
2946 || (htab->elf.dynamic_sections_created
2947 && (h->root.type == bfd_link_hash_undefweak
2948 || h->root.type == bfd_link_hash_undefined))))
2950 /* Make sure this symbol is output as a dynamic symbol.
2951 Undefined weak syms won't yet be marked as dynamic. */
2952 if (h->dynindx == -1
2954 && !resolved_to_zero)
2956 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2960 /* If that succeeded, we know we'll be keeping all the
2962 if (h->dynindx != -1)
2966 eh->dyn_relocs = NULL;
2967 eh->func_pointer_refcount = 0;
2972 /* Finally, allocate space. */
2973 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2977 sreloc = elf_section_data (p->sec)->sreloc;
2979 BFD_ASSERT (sreloc != NULL);
2980 sreloc->size += p->count * sizeof (Elf32_External_Rel);
2986 /* Allocate space in .plt, .got and associated reloc sections for
2987 local dynamic relocs. */
2990 elf_i386_allocate_local_dynrelocs (void **slot, void *inf)
2992 struct elf_link_hash_entry *h
2993 = (struct elf_link_hash_entry *) *slot;
2995 if (h->type != STT_GNU_IFUNC
2999 || h->root.type != bfd_link_hash_defined)
3002 return elf_i386_allocate_dynrelocs (h, inf);
3005 /* Find any dynamic relocs that apply to read-only sections. */
3008 elf_i386_readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
3010 struct elf_i386_link_hash_entry *eh;
3011 struct elf_dyn_relocs *p;
3013 /* Skip local IFUNC symbols. */
3014 if (h->forced_local && h->type == STT_GNU_IFUNC)
3017 eh = (struct elf_i386_link_hash_entry *) h;
3018 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3020 asection *s = p->sec->output_section;
3022 if (s != NULL && (s->flags & SEC_READONLY) != 0)
3024 struct bfd_link_info *info = (struct bfd_link_info *) inf;
3026 info->flags |= DF_TEXTREL;
3028 if ((info->warn_shared_textrel && bfd_link_pic (info))
3029 || info->error_textrel)
3030 info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
3031 p->sec->owner, h->root.root.string,
3034 /* Not an error, just cut short the traversal. */
3041 /* Convert load via the GOT slot to load immediate. */
3044 elf_i386_convert_load (bfd *abfd, asection *sec,
3045 struct bfd_link_info *link_info)
3047 struct elf_i386_link_hash_table *htab;
3048 Elf_Internal_Shdr *symtab_hdr;
3049 Elf_Internal_Rela *internal_relocs;
3050 Elf_Internal_Rela *irel, *irelend;
3052 bfd_boolean changed;
3053 bfd_signed_vma *local_got_refcounts;
3055 /* Don't even try to convert non-ELF outputs. */
3056 if (!is_elf_hash_table (link_info->hash))
3059 /* Nothing to do if there is no need or no output. */
3060 if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
3061 || sec->need_convert_load == 0
3062 || bfd_is_abs_section (sec->output_section))
3065 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3067 /* Load the relocations for this section. */
3068 internal_relocs = (_bfd_elf_link_read_relocs
3069 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
3070 link_info->keep_memory));
3071 if (internal_relocs == NULL)
3075 htab = elf_i386_hash_table (link_info);
3076 local_got_refcounts = elf_local_got_refcounts (abfd);
3078 /* Get the section contents. */
3079 if (elf_section_data (sec)->this_hdr.contents != NULL)
3080 contents = elf_section_data (sec)->this_hdr.contents;
3083 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
3087 irelend = internal_relocs + sec->reloc_count;
3088 for (irel = internal_relocs; irel < irelend; irel++)
3090 unsigned int r_type = ELF32_R_TYPE (irel->r_info);
3091 unsigned int r_symndx;
3092 struct elf_link_hash_entry *h;
3093 bfd_boolean converted;
3095 /* Don't convert R_386_GOT32 since we can't tell if it is applied
3096 to "mov $foo@GOT, %reg" which isn't a load via GOT. */
3097 if (r_type != R_386_GOT32X)
3100 r_symndx = ELF32_R_SYM (irel->r_info);
3101 if (r_symndx < symtab_hdr->sh_info)
3102 h = elf_i386_get_local_sym_hash (htab, sec->owner,
3103 (const Elf_Internal_Rela *) irel,
3107 h = elf_sym_hashes (abfd)[r_symndx - symtab_hdr->sh_info];
3108 while (h->root.type == bfd_link_hash_indirect
3109 || h->root.type == bfd_link_hash_warning)
3110 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3113 /* STT_GNU_IFUNC must keep GOT32 relocations. */
3114 if (h != NULL && h->type == STT_GNU_IFUNC)
3118 if (!elf_i386_convert_load_reloc (abfd, symtab_hdr, contents,
3119 irel, h, &converted, link_info))
3124 changed = converted;
3127 if (h->got.refcount > 0)
3128 h->got.refcount -= 1;
3132 if (local_got_refcounts != NULL
3133 && local_got_refcounts[r_symndx] > 0)
3134 local_got_refcounts[r_symndx] -= 1;
3139 if (contents != NULL
3140 && elf_section_data (sec)->this_hdr.contents != contents)
3142 if (!changed && !link_info->keep_memory)
3146 /* Cache the section contents for elf_link_input_bfd. */
3147 elf_section_data (sec)->this_hdr.contents = contents;
3151 if (elf_section_data (sec)->relocs != internal_relocs)
3154 free (internal_relocs);
3156 elf_section_data (sec)->relocs = internal_relocs;
3162 if (contents != NULL
3163 && elf_section_data (sec)->this_hdr.contents != contents)
3165 if (internal_relocs != NULL
3166 && elf_section_data (sec)->relocs != internal_relocs)
3167 free (internal_relocs);
3171 /* Set the sizes of the dynamic sections. */
3174 elf_i386_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
3176 struct elf_i386_link_hash_table *htab;
3182 htab = elf_i386_hash_table (info);
3185 dynobj = htab->elf.dynobj;
3189 /* Set up .got offsets for local syms, and space for local dynamic
3191 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3193 bfd_signed_vma *local_got;
3194 bfd_signed_vma *end_local_got;
3195 char *local_tls_type;
3196 bfd_vma *local_tlsdesc_gotent;
3197 bfd_size_type locsymcount;
3198 Elf_Internal_Shdr *symtab_hdr;
3201 if (! is_i386_elf (ibfd))
3204 for (s = ibfd->sections; s != NULL; s = s->next)
3206 struct elf_dyn_relocs *p;
3208 if (!elf_i386_convert_load (ibfd, s, info))
3211 for (p = ((struct elf_dyn_relocs *)
3212 elf_section_data (s)->local_dynrel);
3216 if (!bfd_is_abs_section (p->sec)
3217 && bfd_is_abs_section (p->sec->output_section))
3219 /* Input section has been discarded, either because
3220 it is a copy of a linkonce section or due to
3221 linker script /DISCARD/, so we'll be discarding
3224 else if (get_elf_i386_backend_data (output_bfd)->is_vxworks
3225 && strcmp (p->sec->output_section->name,
3228 /* Relocations in vxworks .tls_vars sections are
3229 handled specially by the loader. */
3231 else if (p->count != 0)
3233 srel = elf_section_data (p->sec)->sreloc;
3234 srel->size += p->count * sizeof (Elf32_External_Rel);
3235 if ((p->sec->output_section->flags & SEC_READONLY) != 0
3236 && (info->flags & DF_TEXTREL) == 0)
3238 info->flags |= DF_TEXTREL;
3239 if ((info->warn_shared_textrel && bfd_link_pic (info))
3240 || info->error_textrel)
3241 info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3242 p->sec->owner, p->sec);
3248 local_got = elf_local_got_refcounts (ibfd);
3252 symtab_hdr = &elf_symtab_hdr (ibfd);
3253 locsymcount = symtab_hdr->sh_info;
3254 end_local_got = local_got + locsymcount;
3255 local_tls_type = elf_i386_local_got_tls_type (ibfd);
3256 local_tlsdesc_gotent = elf_i386_local_tlsdesc_gotent (ibfd);
3258 srel = htab->elf.srelgot;
3259 for (; local_got < end_local_got;
3260 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
3262 *local_tlsdesc_gotent = (bfd_vma) -1;
3265 if (GOT_TLS_GDESC_P (*local_tls_type))
3267 *local_tlsdesc_gotent = htab->elf.sgotplt->size
3268 - elf_i386_compute_jump_table_size (htab);
3269 htab->elf.sgotplt->size += 8;
3270 *local_got = (bfd_vma) -2;
3272 if (! GOT_TLS_GDESC_P (*local_tls_type)
3273 || GOT_TLS_GD_P (*local_tls_type))
3275 *local_got = s->size;
3277 if (GOT_TLS_GD_P (*local_tls_type)
3278 || *local_tls_type == GOT_TLS_IE_BOTH)
3281 if (bfd_link_pic (info)
3282 || GOT_TLS_GD_ANY_P (*local_tls_type)
3283 || (*local_tls_type & GOT_TLS_IE))
3285 if (*local_tls_type == GOT_TLS_IE_BOTH)
3286 srel->size += 2 * sizeof (Elf32_External_Rel);
3287 else if (GOT_TLS_GD_P (*local_tls_type)
3288 || ! GOT_TLS_GDESC_P (*local_tls_type))
3289 srel->size += sizeof (Elf32_External_Rel);
3290 if (GOT_TLS_GDESC_P (*local_tls_type))
3291 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
3295 *local_got = (bfd_vma) -1;
3299 if (htab->tls_ldm_got.refcount > 0)
3301 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
3303 htab->tls_ldm_got.offset = htab->elf.sgot->size;
3304 htab->elf.sgot->size += 8;
3305 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
3308 htab->tls_ldm_got.offset = -1;
3310 /* Allocate global sym .plt and .got entries, and space for global
3311 sym dynamic relocs. */
3312 elf_link_hash_traverse (&htab->elf, elf_i386_allocate_dynrelocs, info);
3314 /* Allocate .plt and .got entries, and space for local symbols. */
3315 htab_traverse (htab->loc_hash_table,
3316 elf_i386_allocate_local_dynrelocs,
3319 /* For every jump slot reserved in the sgotplt, reloc_count is
3320 incremented. However, when we reserve space for TLS descriptors,
3321 it's not incremented, so in order to compute the space reserved
3322 for them, it suffices to multiply the reloc count by the jump
3325 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3326 so that R_386_IRELATIVE entries come last. */
3327 if (htab->elf.srelplt)
3329 htab->next_tls_desc_index = htab->elf.srelplt->reloc_count;
3330 htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4;
3331 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
3333 else if (htab->elf.irelplt)
3334 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
3337 if (htab->elf.sgotplt)
3339 /* Don't allocate .got.plt section if there are no GOT nor PLT
3340 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
3341 if ((htab->elf.hgot == NULL
3342 || !htab->elf.hgot->ref_regular_nonweak)
3343 && (htab->elf.sgotplt->size
3344 == get_elf_backend_data (output_bfd)->got_header_size)
3345 && (htab->elf.splt == NULL
3346 || htab->elf.splt->size == 0)
3347 && (htab->elf.sgot == NULL
3348 || htab->elf.sgot->size == 0)
3349 && (htab->elf.iplt == NULL
3350 || htab->elf.iplt->size == 0)
3351 && (htab->elf.igotplt == NULL
3352 || htab->elf.igotplt->size == 0))
3353 htab->elf.sgotplt->size = 0;
3357 if (htab->plt_eh_frame != NULL
3358 && htab->elf.splt != NULL
3359 && htab->elf.splt->size != 0
3360 && !bfd_is_abs_section (htab->elf.splt->output_section)
3361 && _bfd_elf_eh_frame_present (info))
3362 htab->plt_eh_frame->size = sizeof (elf_i386_eh_frame_plt);
3364 /* We now have determined the sizes of the various dynamic sections.
3365 Allocate memory for them. */
3367 for (s = dynobj->sections; s != NULL; s = s->next)
3369 bfd_boolean strip_section = TRUE;
3371 if ((s->flags & SEC_LINKER_CREATED) == 0)
3374 if (s == htab->elf.splt
3375 || s == htab->elf.sgot)
3377 /* Strip this section if we don't need it; see the
3379 /* We'd like to strip these sections if they aren't needed, but if
3380 we've exported dynamic symbols from them we must leave them.
3381 It's too late to tell BFD to get rid of the symbols. */
3383 if (htab->elf.hplt != NULL)
3384 strip_section = FALSE;
3386 else if (s == htab->elf.sgotplt
3387 || s == htab->elf.iplt
3388 || s == htab->elf.igotplt
3389 || s == htab->plt_got
3390 || s == htab->plt_eh_frame
3391 || s == htab->sdynbss)
3393 /* Strip these too. */
3395 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rel"))
3398 && s != htab->elf.srelplt
3399 && s != htab->srelplt2)
3402 /* We use the reloc_count field as a counter if we need
3403 to copy relocs into the output file. */
3408 /* It's not one of our sections, so don't allocate space. */
3414 /* If we don't need this section, strip it from the
3415 output file. This is mostly to handle .rel.bss and
3416 .rel.plt. We must create both sections in
3417 create_dynamic_sections, because they must be created
3418 before the linker maps input sections to output
3419 sections. The linker does that before
3420 adjust_dynamic_symbol is called, and it is that
3421 function which decides whether anything needs to go
3422 into these sections. */
3424 s->flags |= SEC_EXCLUDE;
3428 if ((s->flags & SEC_HAS_CONTENTS) == 0)
3431 /* Allocate memory for the section contents. We use bfd_zalloc
3432 here in case unused entries are not reclaimed before the
3433 section's contents are written out. This should not happen,
3434 but this way if it does, we get a R_386_NONE reloc instead
3436 s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
3437 if (s->contents == NULL)
3441 if (htab->plt_eh_frame != NULL
3442 && htab->plt_eh_frame->contents != NULL)
3444 memcpy (htab->plt_eh_frame->contents, elf_i386_eh_frame_plt,
3445 sizeof (elf_i386_eh_frame_plt));
3446 bfd_put_32 (dynobj, htab->elf.splt->size,
3447 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
3450 if (htab->elf.dynamic_sections_created)
3452 /* Add some entries to the .dynamic section. We fill in the
3453 values later, in elf_i386_finish_dynamic_sections, but we
3454 must add the entries now so that we get the correct size for
3455 the .dynamic section. The DT_DEBUG entry is filled in by the
3456 dynamic linker and used by the debugger. */
3457 #define add_dynamic_entry(TAG, VAL) \
3458 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3460 if (bfd_link_executable (info))
3462 if (!add_dynamic_entry (DT_DEBUG, 0))
3466 if (htab->elf.splt->size != 0)
3468 /* DT_PLTGOT is used by prelink even if there is no PLT
3470 if (!add_dynamic_entry (DT_PLTGOT, 0))
3473 if (htab->elf.srelplt->size != 0)
3475 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3476 || !add_dynamic_entry (DT_PLTREL, DT_REL)
3477 || !add_dynamic_entry (DT_JMPREL, 0))
3484 if (!add_dynamic_entry (DT_REL, 0)
3485 || !add_dynamic_entry (DT_RELSZ, 0)
3486 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
3489 /* If any dynamic relocs apply to a read-only section,
3490 then we need a DT_TEXTREL entry. */
3491 if ((info->flags & DF_TEXTREL) == 0)
3492 elf_link_hash_traverse (&htab->elf,
3493 elf_i386_readonly_dynrelocs, info);
3495 if ((info->flags & DF_TEXTREL) != 0)
3497 if (htab->readonly_dynrelocs_against_ifunc)
3499 info->callbacks->einfo
3500 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3501 bfd_set_error (bfd_error_bad_value);
3505 if (!add_dynamic_entry (DT_TEXTREL, 0))
3509 if (get_elf_i386_backend_data (output_bfd)->is_vxworks
3510 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
3513 #undef add_dynamic_entry
3519 elf_i386_always_size_sections (bfd *output_bfd,
3520 struct bfd_link_info *info)
3522 asection *tls_sec = elf_hash_table (info)->tls_sec;
3526 struct elf_link_hash_entry *tlsbase;
3528 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
3529 "_TLS_MODULE_BASE_",
3530 FALSE, FALSE, FALSE);
3532 if (tlsbase && tlsbase->type == STT_TLS)
3534 struct elf_i386_link_hash_table *htab;
3535 struct bfd_link_hash_entry *bh = NULL;
3536 const struct elf_backend_data *bed
3537 = get_elf_backend_data (output_bfd);
3539 htab = elf_i386_hash_table (info);
3543 if (!(_bfd_generic_link_add_one_symbol
3544 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
3545 tls_sec, 0, NULL, FALSE,
3546 bed->collect, &bh)))
3549 htab->tls_module_base = bh;
3551 tlsbase = (struct elf_link_hash_entry *)bh;
3552 tlsbase->def_regular = 1;
3553 tlsbase->other = STV_HIDDEN;
3554 tlsbase->root.linker_def = 1;
3555 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
3562 /* Set the correct type for an x86 ELF section. We do this by the
3563 section name, which is a hack, but ought to work. */
3566 elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
3567 Elf_Internal_Shdr *hdr,
3572 name = bfd_get_section_name (abfd, sec);
3574 /* This is an ugly, but unfortunately necessary hack that is
3575 needed when producing EFI binaries on x86. It tells
3576 elf.c:elf_fake_sections() not to consider ".reloc" as a section
3577 containing ELF relocation info. We need this hack in order to
3578 be able to generate ELF binaries that can be translated into
3579 EFI applications (which are essentially COFF objects). Those
3580 files contain a COFF ".reloc" section inside an ELFNN object,
3581 which would normally cause BFD to segfault because it would
3582 attempt to interpret this section as containing relocation
3583 entries for section "oc". With this hack enabled, ".reloc"
3584 will be treated as a normal data section, which will avoid the
3585 segfault. However, you won't be able to create an ELFNN binary
3586 with a section named "oc" that needs relocations, but that's
3587 the kind of ugly side-effects you get when detecting section
3588 types based on their names... In practice, this limitation is
3589 unlikely to bite. */
3590 if (strcmp (name, ".reloc") == 0)
3591 hdr->sh_type = SHT_PROGBITS;
3596 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3597 executables. Rather than setting it to the beginning of the TLS
3598 section, we have to set it to the end. This function may be called
3599 multiple times, it is idempotent. */
3602 elf_i386_set_tls_module_base (struct bfd_link_info *info)
3604 struct elf_i386_link_hash_table *htab;
3605 struct bfd_link_hash_entry *base;
3607 if (!bfd_link_executable (info))
3610 htab = elf_i386_hash_table (info);
3614 base = htab->tls_module_base;
3618 base->u.def.value = htab->elf.tls_size;
3621 /* Return the base VMA address which should be subtracted from real addresses
3622 when resolving @dtpoff relocation.
3623 This is PT_TLS segment p_vaddr. */
3626 elf_i386_dtpoff_base (struct bfd_link_info *info)
3628 /* If tls_sec is NULL, we should have signalled an error already. */
3629 if (elf_hash_table (info)->tls_sec == NULL)
3631 return elf_hash_table (info)->tls_sec->vma;
3634 /* Return the relocation value for @tpoff relocation
3635 if STT_TLS virtual address is ADDRESS. */
3638 elf_i386_tpoff (struct bfd_link_info *info, bfd_vma address)
3640 struct elf_link_hash_table *htab = elf_hash_table (info);
3641 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3642 bfd_vma static_tls_size;
3644 /* If tls_sec is NULL, we should have signalled an error already. */
3645 if (htab->tls_sec == NULL)
3648 /* Consider special static TLS alignment requirements. */
3649 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3650 return static_tls_size + htab->tls_sec->vma - address;
3653 /* Relocate an i386 ELF section. */
3656 elf_i386_relocate_section (bfd *output_bfd,
3657 struct bfd_link_info *info,
3659 asection *input_section,
3661 Elf_Internal_Rela *relocs,
3662 Elf_Internal_Sym *local_syms,
3663 asection **local_sections)
3665 struct elf_i386_link_hash_table *htab;
3666 Elf_Internal_Shdr *symtab_hdr;
3667 struct elf_link_hash_entry **sym_hashes;
3668 bfd_vma *local_got_offsets;
3669 bfd_vma *local_tlsdesc_gotents;
3670 Elf_Internal_Rela *rel;
3671 Elf_Internal_Rela *wrel;
3672 Elf_Internal_Rela *relend;
3673 bfd_boolean is_vxworks_tls;
3674 unsigned plt_entry_size;
3676 BFD_ASSERT (is_i386_elf (input_bfd));
3678 /* Skip if check_relocs failed. */
3679 if (input_section->check_relocs_failed)
3682 htab = elf_i386_hash_table (info);
3685 symtab_hdr = &elf_symtab_hdr (input_bfd);
3686 sym_hashes = elf_sym_hashes (input_bfd);
3687 local_got_offsets = elf_local_got_offsets (input_bfd);
3688 local_tlsdesc_gotents = elf_i386_local_tlsdesc_gotent (input_bfd);
3689 /* We have to handle relocations in vxworks .tls_vars sections
3690 specially, because the dynamic loader is 'weird'. */
3691 is_vxworks_tls = (get_elf_i386_backend_data (output_bfd)->is_vxworks
3692 && bfd_link_pic (info)
3693 && !strcmp (input_section->output_section->name,
3696 elf_i386_set_tls_module_base (info);
3698 plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
3700 rel = wrel = relocs;
3701 relend = relocs + input_section->reloc_count;
3702 for (; rel < relend; wrel++, rel++)
3704 unsigned int r_type;
3705 reloc_howto_type *howto;
3706 unsigned long r_symndx;
3707 struct elf_link_hash_entry *h;
3708 struct elf_i386_link_hash_entry *eh;
3709 Elf_Internal_Sym *sym;
3711 bfd_vma off, offplt, plt_offset;
3713 bfd_boolean unresolved_reloc;
3714 bfd_reloc_status_type r;
3718 asection *resolved_plt;
3719 bfd_boolean resolved_to_zero;
3721 r_type = ELF32_R_TYPE (rel->r_info);
3722 if (r_type == R_386_GNU_VTINHERIT
3723 || r_type == R_386_GNU_VTENTRY)
3730 if ((indx = r_type) >= R_386_standard
3731 && ((indx = r_type - R_386_ext_offset) - R_386_standard
3732 >= R_386_ext - R_386_standard)
3733 && ((indx = r_type - R_386_tls_offset) - R_386_ext
3734 >= R_386_ext2 - R_386_ext))
3736 (*_bfd_error_handler)
3737 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3738 input_bfd, input_section, r_type);
3739 bfd_set_error (bfd_error_bad_value);
3742 howto = elf_howto_table + indx;
3744 r_symndx = ELF32_R_SYM (rel->r_info);
3748 unresolved_reloc = FALSE;
3749 if (r_symndx < symtab_hdr->sh_info)
3751 sym = local_syms + r_symndx;
3752 sec = local_sections[r_symndx];
3753 relocation = (sec->output_section->vma
3754 + sec->output_offset
3756 st_size = sym->st_size;
3758 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
3759 && ((sec->flags & SEC_MERGE) != 0
3760 || (bfd_link_relocatable (info)
3761 && sec->output_offset != 0)))
3764 bfd_byte *where = contents + rel->r_offset;
3766 switch (howto->size)
3769 addend = bfd_get_8 (input_bfd, where);
3770 if (howto->pc_relative)
3772 addend = (addend ^ 0x80) - 0x80;
3777 addend = bfd_get_16 (input_bfd, where);
3778 if (howto->pc_relative)
3780 addend = (addend ^ 0x8000) - 0x8000;
3785 addend = bfd_get_32 (input_bfd, where);
3786 if (howto->pc_relative)
3788 addend = (addend ^ 0x80000000) - 0x80000000;
3796 if (bfd_link_relocatable (info))
3797 addend += sec->output_offset;
3800 asection *msec = sec;
3801 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
3803 addend -= relocation;
3804 addend += msec->output_section->vma + msec->output_offset;
3807 switch (howto->size)
3810 /* FIXME: overflow checks. */
3811 if (howto->pc_relative)
3813 bfd_put_8 (input_bfd, addend, where);
3816 if (howto->pc_relative)
3818 bfd_put_16 (input_bfd, addend, where);
3821 if (howto->pc_relative)
3823 bfd_put_32 (input_bfd, addend, where);
3827 else if (!bfd_link_relocatable (info)
3828 && ELF32_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3830 /* Relocate against local STT_GNU_IFUNC symbol. */
3831 h = elf_i386_get_local_sym_hash (htab, input_bfd, rel,
3836 /* Set STT_GNU_IFUNC symbol value. */
3837 h->root.u.def.value = sym->st_value;
3838 h->root.u.def.section = sec;
3843 bfd_boolean warned ATTRIBUTE_UNUSED;
3844 bfd_boolean ignored ATTRIBUTE_UNUSED;
3846 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3847 r_symndx, symtab_hdr, sym_hashes,
3849 unresolved_reloc, warned, ignored);
3853 if (sec != NULL && discarded_section (sec))
3855 _bfd_clear_contents (howto, input_bfd, input_section,
3856 contents + rel->r_offset);
3857 wrel->r_offset = rel->r_offset;
3861 /* For ld -r, remove relocations in debug sections against
3862 sections defined in discarded sections. Not done for
3863 eh_frame editing code expects to be present. */
3864 if (bfd_link_relocatable (info)
3865 && (input_section->flags & SEC_DEBUGGING))
3871 if (bfd_link_relocatable (info))
3878 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3879 it here if it is defined in a non-shared object. */
3881 && h->type == STT_GNU_IFUNC
3884 asection *plt, *gotplt, *base_got;
3888 if ((input_section->flags & SEC_ALLOC) == 0)
3890 /* Dynamic relocs are not propagated for SEC_DEBUGGING
3891 sections because such sections are not SEC_ALLOC and
3892 thus ld.so will not process them. */
3893 if ((input_section->flags & SEC_DEBUGGING) != 0)
3897 else if (h->plt.offset == (bfd_vma) -1)
3900 /* STT_GNU_IFUNC symbol must go through PLT. */
3901 if (htab->elf.splt != NULL)
3903 plt = htab->elf.splt;
3904 gotplt = htab->elf.sgotplt;
3908 plt = htab->elf.iplt;
3909 gotplt = htab->elf.igotplt;
3912 relocation = (plt->output_section->vma
3913 + plt->output_offset + h->plt.offset);
3918 if (h->root.root.string)
3919 name = h->root.root.string;
3921 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3923 (*_bfd_error_handler)
3924 (_("%B: relocation %s against STT_GNU_IFUNC "
3925 "symbol `%s' isn't handled by %s"), input_bfd,
3926 elf_howto_table[r_type].name,
3927 name, __FUNCTION__);
3928 bfd_set_error (bfd_error_bad_value);
3932 /* Generate dynamic relcoation only when there is a
3933 non-GOT reference in a shared object. */
3934 if (bfd_link_pic (info) && h->non_got_ref)
3936 Elf_Internal_Rela outrel;
3940 /* Need a dynamic relocation to get the real function
3942 offset = _bfd_elf_section_offset (output_bfd,
3946 if (offset == (bfd_vma) -1
3947 || offset == (bfd_vma) -2)
3950 outrel.r_offset = (input_section->output_section->vma
3951 + input_section->output_offset
3954 if (h->dynindx == -1
3956 || bfd_link_executable (info))
3958 /* This symbol is resolved locally. */
3959 outrel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
3960 bfd_put_32 (output_bfd,
3961 (h->root.u.def.value
3962 + h->root.u.def.section->output_section->vma
3963 + h->root.u.def.section->output_offset),
3967 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3969 sreloc = htab->elf.irelifunc;
3970 elf_append_rel (output_bfd, sreloc, &outrel);
3972 /* If this reloc is against an external symbol, we
3973 do not want to fiddle with the addend. Otherwise,
3974 we need to include the symbol value so that it
3975 becomes an addend for the dynamic reloc. For an
3976 internal symbol, we have updated addend. */
3986 base_got = htab->elf.sgot;
3987 off = h->got.offset;
3989 if (base_got == NULL)
3992 if (off == (bfd_vma) -1)
3994 /* We can't use h->got.offset here to save state, or
3995 even just remember the offset, as finish_dynamic_symbol
3996 would use that as offset into .got. */
3998 if (htab->elf.splt != NULL)
4000 plt_index = h->plt.offset / plt_entry_size - 1;
4001 off = (plt_index + 3) * 4;
4002 base_got = htab->elf.sgotplt;
4006 plt_index = h->plt.offset / plt_entry_size;
4007 off = plt_index * 4;
4008 base_got = htab->elf.igotplt;
4011 if (h->dynindx == -1
4015 /* This references the local defitionion. We must
4016 initialize this entry in the global offset table.
4017 Since the offset must always be a multiple of 8,
4018 we use the least significant bit to record
4019 whether we have initialized it already.
4021 When doing a dynamic link, we create a .rela.got
4022 relocation entry to initialize the value. This
4023 is done in the finish_dynamic_symbol routine. */
4028 bfd_put_32 (output_bfd, relocation,
4029 base_got->contents + off);
4037 relocation = (base_got->output_section->vma
4038 + base_got->output_offset + off
4039 - gotplt->output_section->vma
4040 - gotplt->output_offset);
4042 /* Adjust for static executables. */
4043 if (htab->elf.splt == NULL)
4044 relocation += gotplt->output_offset;
4049 relocation -= (gotplt->output_section->vma
4050 + gotplt->output_offset);
4055 eh = (struct elf_i386_link_hash_entry *) h;
4056 resolved_to_zero = (eh != NULL
4057 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
4064 /* Avoid optimizing _DYNAMIC since ld.so may use its
4065 link-time address. */
4066 if (h == htab->elf.hdynamic)
4069 if (bfd_link_pic (info))
4071 /* It is OK to convert mov to lea and convert indirect
4072 branch to direct branch. It is OK to convert adc,
4073 add, and, cmp, or, sbb, sub, test, xor only when PIC
4075 unsigned int opcode, addend;
4076 addend = bfd_get_32 (input_bfd, contents + rel->r_offset);
4079 opcode = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
4080 if (opcode != 0x8b && opcode != 0xff)
4084 /* Resolve "mov GOT[(%reg)], %reg",
4085 "call/jmp *GOT[(%reg)]", "test %reg, foo@GOT[(%reg)]"
4086 and "binop foo@GOT[(%reg)], %reg". */
4088 || (h->plt.offset == (bfd_vma) -1
4089 && h->got.offset == (bfd_vma) -1)
4090 || htab->elf.sgotplt == NULL)
4093 offplt = (htab->elf.sgotplt->output_section->vma
4094 + htab->elf.sgotplt->output_offset);
4096 /* It is relative to .got.plt section. */
4097 if (h->got.offset != (bfd_vma) -1)
4098 /* Use GOT entry. Mask off the least significant bit in
4099 GOT offset which may be set by R_386_GOT32 processing
4101 relocation = (htab->elf.sgot->output_section->vma
4102 + htab->elf.sgot->output_offset
4103 + (h->got.offset & ~1) - offplt);
4105 /* Use GOTPLT entry. */
4106 relocation = (h->plt.offset / plt_entry_size - 1 + 3) * 4;
4108 if (!bfd_link_pic (info))
4110 /* If not PIC, add the .got.plt section address for
4111 baseless addressing. */
4113 modrm = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4114 if ((modrm & 0xc7) == 0x5)
4115 relocation += offplt;
4118 unresolved_reloc = FALSE;
4123 /* Relocation is to the entry for this symbol in the global
4125 if (htab->elf.sgot == NULL)
4132 off = h->got.offset;
4133 dyn = htab->elf.dynamic_sections_created;
4134 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4135 bfd_link_pic (info),
4137 || (bfd_link_pic (info)
4138 && SYMBOL_REFERENCES_LOCAL (info, h))
4139 || (ELF_ST_VISIBILITY (h->other)
4140 && h->root.type == bfd_link_hash_undefweak))
4142 /* This is actually a static link, or it is a
4143 -Bsymbolic link and the symbol is defined
4144 locally, or the symbol was forced to be local
4145 because of a version file. We must initialize
4146 this entry in the global offset table. Since the
4147 offset must always be a multiple of 4, we use the
4148 least significant bit to record whether we have
4149 initialized it already.
4151 When doing a dynamic link, we create a .rel.got
4152 relocation entry to initialize the value. This
4153 is done in the finish_dynamic_symbol routine. */
4158 bfd_put_32 (output_bfd, relocation,
4159 htab->elf.sgot->contents + off);
4164 unresolved_reloc = FALSE;
4168 if (local_got_offsets == NULL)
4171 off = local_got_offsets[r_symndx];
4173 /* The offset must always be a multiple of 4. We use
4174 the least significant bit to record whether we have
4175 already generated the necessary reloc. */
4180 bfd_put_32 (output_bfd, relocation,
4181 htab->elf.sgot->contents + off);
4183 if (bfd_link_pic (info))
4186 Elf_Internal_Rela outrel;
4188 s = htab->elf.srelgot;
4192 outrel.r_offset = (htab->elf.sgot->output_section->vma
4193 + htab->elf.sgot->output_offset
4195 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4196 elf_append_rel (output_bfd, s, &outrel);
4199 local_got_offsets[r_symndx] |= 1;
4203 if (off >= (bfd_vma) -2)
4206 relocation = (htab->elf.sgot->output_section->vma
4207 + htab->elf.sgot->output_offset + off);
4208 if ((*(contents + rel->r_offset - 1) & 0xc7) == 0x5)
4210 if (bfd_link_pic (info))
4212 /* For PIC, disallow R_386_GOT32 without a base
4213 register since we don't know what the GOT base
4218 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
4221 name = h->root.root.string;
4223 (*_bfd_error_handler)
4224 (_("%B: direct GOT relocation R_386_GOT32 against `%s' without base register can not be used when making a shared object"),
4226 bfd_set_error (bfd_error_bad_value);
4232 /* Subtract the .got.plt section address only with a base
4234 relocation -= (htab->elf.sgotplt->output_section->vma
4235 + htab->elf.sgotplt->output_offset);
4241 /* Relocation is relative to the start of the global offset
4244 /* Check to make sure it isn't a protected function or data
4245 symbol for shared library since it may not be local when
4246 used as function address or with copy relocation. We also
4247 need to make sure that a symbol is referenced locally. */
4248 if (!bfd_link_executable (info) && h)
4250 if (!h->def_regular)
4254 switch (ELF_ST_VISIBILITY (h->other))
4257 v = _("hidden symbol");
4260 v = _("internal symbol");
4263 v = _("protected symbol");
4270 (*_bfd_error_handler)
4271 (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
4272 input_bfd, v, h->root.root.string);
4273 bfd_set_error (bfd_error_bad_value);
4276 else if (!SYMBOL_REFERENCES_LOCAL (info, h)
4277 && (h->type == STT_FUNC
4278 || h->type == STT_OBJECT)
4279 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
4281 (*_bfd_error_handler)
4282 (_("%B: relocation R_386_GOTOFF against protected %s `%s' can not be used when making a shared object"),
4284 h->type == STT_FUNC ? "function" : "data",
4285 h->root.root.string);
4286 bfd_set_error (bfd_error_bad_value);
4291 /* Note that sgot is not involved in this
4292 calculation. We always want the start of .got.plt. If we
4293 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4294 permitted by the ABI, we might have to change this
4296 relocation -= htab->elf.sgotplt->output_section->vma
4297 + htab->elf.sgotplt->output_offset;
4301 /* Use global offset table as symbol value. */
4302 relocation = htab->elf.sgotplt->output_section->vma
4303 + htab->elf.sgotplt->output_offset;
4304 unresolved_reloc = FALSE;
4308 /* Relocation is to the entry for this symbol in the
4309 procedure linkage table. */
4311 /* Resolve a PLT32 reloc against a local symbol directly,
4312 without using the procedure linkage table. */
4316 if ((h->plt.offset == (bfd_vma) -1
4317 && eh->plt_got.offset == (bfd_vma) -1)
4318 || htab->elf.splt == NULL)
4320 /* We didn't make a PLT entry for this symbol. This
4321 happens when statically linking PIC code, or when
4322 using -Bsymbolic. */
4326 if (h->plt.offset != (bfd_vma) -1)
4328 resolved_plt = htab->elf.splt;
4329 plt_offset = h->plt.offset;
4333 resolved_plt = htab->plt_got;
4334 plt_offset = eh->plt_got.offset;
4337 relocation = (resolved_plt->output_section->vma
4338 + resolved_plt->output_offset
4340 unresolved_reloc = FALSE;
4344 /* Set to symbol size. */
4345 relocation = st_size;
4350 if ((input_section->flags & SEC_ALLOC) == 0
4354 /* Copy dynamic function pointer relocations. Don't generate
4355 dynamic relocations against resolved undefined weak symbols
4356 in PIE, except for R_386_PC32. */
4357 if ((bfd_link_pic (info)
4359 || ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4360 && (!resolved_to_zero
4361 || r_type == R_386_PC32))
4362 || h->root.type != bfd_link_hash_undefweak))
4363 && ((r_type != R_386_PC32 && r_type != R_386_SIZE32)
4364 || !SYMBOL_CALLS_LOCAL (info, h)))
4365 || (ELIMINATE_COPY_RELOCS
4366 && !bfd_link_pic (info)
4370 || eh->func_pointer_refcount > 0
4371 || (h->root.type == bfd_link_hash_undefweak
4372 && !resolved_to_zero))
4373 && ((h->def_dynamic && !h->def_regular)
4374 /* Undefined weak symbol is bound locally when
4376 || h->root.type == bfd_link_hash_undefweak)))
4378 Elf_Internal_Rela outrel;
4379 bfd_boolean skip, relocate;
4382 /* When generating a shared object, these relocations
4383 are copied into the output file to be resolved at run
4390 _bfd_elf_section_offset (output_bfd, info, input_section,
4392 if (outrel.r_offset == (bfd_vma) -1)
4394 else if (outrel.r_offset == (bfd_vma) -2)
4395 skip = TRUE, relocate = TRUE;
4396 outrel.r_offset += (input_section->output_section->vma
4397 + input_section->output_offset);
4400 memset (&outrel, 0, sizeof outrel);
4403 && (r_type == R_386_PC32
4404 || !(bfd_link_executable (info)
4405 || SYMBOLIC_BIND (info, h))
4406 || !h->def_regular))
4407 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4410 /* This symbol is local, or marked to become local. */
4412 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4415 sreloc = elf_section_data (input_section)->sreloc;
4417 if (sreloc == NULL || sreloc->contents == NULL)
4419 r = bfd_reloc_notsupported;
4420 goto check_relocation_error;
4423 elf_append_rel (output_bfd, sreloc, &outrel);
4425 /* If this reloc is against an external symbol, we do
4426 not want to fiddle with the addend. Otherwise, we
4427 need to include the symbol value so that it becomes
4428 an addend for the dynamic reloc. */
4435 if (!bfd_link_executable (info))
4437 Elf_Internal_Rela outrel;
4440 outrel.r_offset = rel->r_offset
4441 + input_section->output_section->vma
4442 + input_section->output_offset;
4443 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4444 sreloc = elf_section_data (input_section)->sreloc;
4447 elf_append_rel (output_bfd, sreloc, &outrel);
4452 case R_386_TLS_GOTDESC:
4453 case R_386_TLS_DESC_CALL:
4454 case R_386_TLS_IE_32:
4455 case R_386_TLS_GOTIE:
4456 tls_type = GOT_UNKNOWN;
4457 if (h == NULL && local_got_offsets)
4458 tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
4460 tls_type = elf_i386_hash_entry(h)->tls_type;
4461 if (tls_type == GOT_TLS_IE)
4462 tls_type = GOT_TLS_IE_NEG;
4464 if (! elf_i386_tls_transition (info, input_bfd,
4465 input_section, contents,
4466 symtab_hdr, sym_hashes,
4467 &r_type, tls_type, rel,
4468 relend, h, r_symndx, TRUE))
4471 if (r_type == R_386_TLS_LE_32)
4473 BFD_ASSERT (! unresolved_reloc);
4474 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
4479 /* GD->LE transition. */
4480 type = *(contents + rel->r_offset - 2);
4484 leal foo@tlsgd(,%ebx,1), %eax
4485 call ___tls_get_addr@PLT
4488 subl $foo@tpoff, %eax
4489 (6 byte form of subl). */
4490 roff = rel->r_offset + 5;
4495 leal foo@tlsgd(%ebx), %eax
4496 call ___tls_get_addr@PLT
4499 leal foo@tlsgd(%reg), %eax
4500 call *___tls_get_addr@GOT(%reg)
4501 which may be converted to
4502 addr32 call ___tls_get_addr
4504 movl %gs:0, %eax; subl $foo@tpoff, %eax
4505 (6 byte form of subl). */
4506 roff = rel->r_offset + 6;
4508 memcpy (contents + roff - 8,
4509 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
4510 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
4512 /* Skip R_386_PC32, R_386_PLT32 and R_386_GOT32X. */
4517 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4519 /* GDesc -> LE transition.
4520 It's originally something like:
4521 leal x@tlsdesc(%ebx), %eax
4525 Registers other than %eax may be set up here. */
4530 roff = rel->r_offset;
4531 val = bfd_get_8 (input_bfd, contents + roff - 1);
4533 /* Now modify the instruction as appropriate. */
4534 /* aoliva FIXME: remove the above and xor the byte
4536 bfd_put_8 (output_bfd, val ^ 0x86,
4537 contents + roff - 1);
4538 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
4542 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4544 /* GDesc -> LE transition.
4552 roff = rel->r_offset;
4553 bfd_put_8 (output_bfd, 0x66, contents + roff);
4554 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4557 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
4561 /* IE->LE transition:
4562 Originally it can be one of:
4570 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4573 /* movl foo, %eax. */
4574 bfd_put_8 (output_bfd, 0xb8,
4575 contents + rel->r_offset - 1);
4581 type = bfd_get_8 (input_bfd,
4582 contents + rel->r_offset - 2);
4587 bfd_put_8 (output_bfd, 0xc7,
4588 contents + rel->r_offset - 2);
4589 bfd_put_8 (output_bfd,
4590 0xc0 | ((val >> 3) & 7),
4591 contents + rel->r_offset - 1);
4595 bfd_put_8 (output_bfd, 0x81,
4596 contents + rel->r_offset - 2);
4597 bfd_put_8 (output_bfd,
4598 0xc0 | ((val >> 3) & 7),
4599 contents + rel->r_offset - 1);
4606 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
4607 contents + rel->r_offset);
4612 unsigned int val, type;
4614 /* {IE_32,GOTIE}->LE transition:
4615 Originally it can be one of:
4616 subl foo(%reg1), %reg2
4617 movl foo(%reg1), %reg2
4618 addl foo(%reg1), %reg2
4621 movl $foo, %reg2 (6 byte form)
4622 addl $foo, %reg2. */
4623 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
4624 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4628 bfd_put_8 (output_bfd, 0xc7,
4629 contents + rel->r_offset - 2);
4630 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4631 contents + rel->r_offset - 1);
4633 else if (type == 0x2b)
4636 bfd_put_8 (output_bfd, 0x81,
4637 contents + rel->r_offset - 2);
4638 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
4639 contents + rel->r_offset - 1);
4641 else if (type == 0x03)
4644 bfd_put_8 (output_bfd, 0x81,
4645 contents + rel->r_offset - 2);
4646 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4647 contents + rel->r_offset - 1);
4651 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
4652 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
4653 contents + rel->r_offset);
4655 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
4656 contents + rel->r_offset);
4661 if (htab->elf.sgot == NULL)
4666 off = h->got.offset;
4667 offplt = elf_i386_hash_entry (h)->tlsdesc_got;
4671 if (local_got_offsets == NULL)
4674 off = local_got_offsets[r_symndx];
4675 offplt = local_tlsdesc_gotents[r_symndx];
4682 Elf_Internal_Rela outrel;
4686 if (htab->elf.srelgot == NULL)
4689 indx = h && h->dynindx != -1 ? h->dynindx : 0;
4691 if (GOT_TLS_GDESC_P (tls_type))
4694 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
4695 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
4696 <= htab->elf.sgotplt->size);
4697 outrel.r_offset = (htab->elf.sgotplt->output_section->vma
4698 + htab->elf.sgotplt->output_offset
4700 + htab->sgotplt_jump_table_size);
4701 sreloc = htab->elf.srelplt;
4702 loc = sreloc->contents;
4703 loc += (htab->next_tls_desc_index++
4704 * sizeof (Elf32_External_Rel));
4705 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
4706 <= sreloc->contents + sreloc->size);
4707 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4710 BFD_ASSERT (! unresolved_reloc);
4711 bfd_put_32 (output_bfd,
4712 relocation - elf_i386_dtpoff_base (info),
4713 htab->elf.sgotplt->contents + offplt
4714 + htab->sgotplt_jump_table_size + 4);
4718 bfd_put_32 (output_bfd, 0,
4719 htab->elf.sgotplt->contents + offplt
4720 + htab->sgotplt_jump_table_size + 4);
4724 sreloc = htab->elf.srelgot;
4726 outrel.r_offset = (htab->elf.sgot->output_section->vma
4727 + htab->elf.sgot->output_offset + off);
4729 if (GOT_TLS_GD_P (tls_type))
4730 dr_type = R_386_TLS_DTPMOD32;
4731 else if (GOT_TLS_GDESC_P (tls_type))
4733 else if (tls_type == GOT_TLS_IE_POS)
4734 dr_type = R_386_TLS_TPOFF;
4736 dr_type = R_386_TLS_TPOFF32;
4738 if (dr_type == R_386_TLS_TPOFF && indx == 0)
4739 bfd_put_32 (output_bfd,
4740 relocation - elf_i386_dtpoff_base (info),
4741 htab->elf.sgot->contents + off);
4742 else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
4743 bfd_put_32 (output_bfd,
4744 elf_i386_dtpoff_base (info) - relocation,
4745 htab->elf.sgot->contents + off);
4746 else if (dr_type != R_386_TLS_DESC)
4747 bfd_put_32 (output_bfd, 0,
4748 htab->elf.sgot->contents + off);
4749 outrel.r_info = ELF32_R_INFO (indx, dr_type);
4751 elf_append_rel (output_bfd, sreloc, &outrel);
4753 if (GOT_TLS_GD_P (tls_type))
4757 BFD_ASSERT (! unresolved_reloc);
4758 bfd_put_32 (output_bfd,
4759 relocation - elf_i386_dtpoff_base (info),
4760 htab->elf.sgot->contents + off + 4);
4764 bfd_put_32 (output_bfd, 0,
4765 htab->elf.sgot->contents + off + 4);
4766 outrel.r_info = ELF32_R_INFO (indx,
4767 R_386_TLS_DTPOFF32);
4768 outrel.r_offset += 4;
4769 elf_append_rel (output_bfd, sreloc, &outrel);
4772 else if (tls_type == GOT_TLS_IE_BOTH)
4774 bfd_put_32 (output_bfd,
4776 ? relocation - elf_i386_dtpoff_base (info)
4778 htab->elf.sgot->contents + off + 4);
4779 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4780 outrel.r_offset += 4;
4781 elf_append_rel (output_bfd, sreloc, &outrel);
4788 local_got_offsets[r_symndx] |= 1;
4791 if (off >= (bfd_vma) -2
4792 && ! GOT_TLS_GDESC_P (tls_type))
4794 if (r_type == R_386_TLS_GOTDESC
4795 || r_type == R_386_TLS_DESC_CALL)
4797 relocation = htab->sgotplt_jump_table_size + offplt;
4798 unresolved_reloc = FALSE;
4800 else if (r_type == ELF32_R_TYPE (rel->r_info))
4802 bfd_vma g_o_t = htab->elf.sgotplt->output_section->vma
4803 + htab->elf.sgotplt->output_offset;
4804 relocation = htab->elf.sgot->output_section->vma
4805 + htab->elf.sgot->output_offset + off - g_o_t;
4806 if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
4807 && tls_type == GOT_TLS_IE_BOTH)
4809 if (r_type == R_386_TLS_IE)
4810 relocation += g_o_t;
4811 unresolved_reloc = FALSE;
4813 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
4815 unsigned int val, type;
4818 /* GD->IE transition. */
4819 type = *(contents + rel->r_offset - 2);
4820 val = *(contents + rel->r_offset - 1);
4824 leal foo@tlsgd(,%ebx,1), %eax
4825 call ___tls_get_addr@PLT
4828 subl $foo@gottpoff(%ebx), %eax. */
4830 roff = rel->r_offset - 3;
4835 leal foo@tlsgd(%ebx), %eax
4836 call ___tls_get_addr@PLT
4839 leal foo@tlsgd(%reg), %eax
4840 call *___tls_get_addr@GOT(%reg)
4841 which may be converted to
4842 addr32 call ___tls_get_addr
4845 subl $foo@gottpoff(%reg), %eax. */
4846 roff = rel->r_offset - 2;
4848 memcpy (contents + roff,
4849 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
4850 contents[roff + 7] = 0x80 | (val & 7);
4851 /* If foo is used only with foo@gotntpoff(%reg) and
4852 foo@indntpoff, but not with foo@gottpoff(%reg), change
4853 subl $foo@gottpoff(%reg), %eax
4855 addl $foo@gotntpoff(%reg), %eax. */
4856 if (tls_type == GOT_TLS_IE_POS)
4857 contents[roff + 6] = 0x03;
4858 bfd_put_32 (output_bfd,
4859 htab->elf.sgot->output_section->vma
4860 + htab->elf.sgot->output_offset + off
4861 - htab->elf.sgotplt->output_section->vma
4862 - htab->elf.sgotplt->output_offset,
4863 contents + roff + 8);
4864 /* Skip R_386_PLT32 and R_386_GOT32X. */
4869 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4871 /* GDesc -> IE transition.
4872 It's originally something like:
4873 leal x@tlsdesc(%ebx), %eax
4876 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
4878 movl x@gottpoff(%ebx), %eax # before negl %eax
4880 Registers other than %eax may be set up here. */
4884 /* First, make sure it's a leal adding ebx to a 32-bit
4885 offset into any register, although it's probably
4886 almost always going to be eax. */
4887 roff = rel->r_offset;
4889 /* Now modify the instruction as appropriate. */
4890 /* To turn a leal into a movl in the form we use it, it
4891 suffices to change the first byte from 0x8d to 0x8b.
4892 aoliva FIXME: should we decide to keep the leal, all
4893 we have to do is remove the statement below, and
4894 adjust the relaxation of R_386_TLS_DESC_CALL. */
4895 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4897 if (tls_type == GOT_TLS_IE_BOTH)
4900 bfd_put_32 (output_bfd,
4901 htab->elf.sgot->output_section->vma
4902 + htab->elf.sgot->output_offset + off
4903 - htab->elf.sgotplt->output_section->vma
4904 - htab->elf.sgotplt->output_offset,
4908 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4910 /* GDesc -> IE transition.
4918 depending on how we transformed the TLS_GOTDESC above.
4923 roff = rel->r_offset;
4925 /* Now modify the instruction as appropriate. */
4926 if (tls_type != GOT_TLS_IE_NEG)
4929 bfd_put_8 (output_bfd, 0x66, contents + roff);
4930 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4935 bfd_put_8 (output_bfd, 0xf7, contents + roff);
4936 bfd_put_8 (output_bfd, 0xd8, contents + roff + 1);
4946 if (! elf_i386_tls_transition (info, input_bfd,
4947 input_section, contents,
4948 symtab_hdr, sym_hashes,
4949 &r_type, GOT_UNKNOWN, rel,
4950 relend, h, r_symndx, TRUE))
4953 if (r_type != R_386_TLS_LDM)
4955 /* LD->LE transition. Change
4956 leal foo@tlsldm(%ebx) %eax
4957 call ___tls_get_addr@PLT
4961 leal 0(%esi,1), %esi
4963 leal foo@tlsldm(%reg) %eax
4964 call *___tls_get_addr@GOT(%reg)
4965 which may be converted to
4966 addr32 call ___tls_get_addr
4969 leal 0(%esi), %esi */
4970 BFD_ASSERT (r_type == R_386_TLS_LE_32);
4971 if (*(contents + rel->r_offset + 4) == 0xff
4972 || *(contents + rel->r_offset + 4) == 0x67)
4973 memcpy (contents + rel->r_offset - 2,
4974 "\x65\xa1\0\0\0\0\x8d\xb6\0\0\0", 12);
4976 memcpy (contents + rel->r_offset - 2,
4977 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
4978 /* Skip R_386_PC32/R_386_PLT32. */
4984 if (htab->elf.sgot == NULL)
4987 off = htab->tls_ldm_got.offset;
4992 Elf_Internal_Rela outrel;
4994 if (htab->elf.srelgot == NULL)
4997 outrel.r_offset = (htab->elf.sgot->output_section->vma
4998 + htab->elf.sgot->output_offset + off);
5000 bfd_put_32 (output_bfd, 0,
5001 htab->elf.sgot->contents + off);
5002 bfd_put_32 (output_bfd, 0,
5003 htab->elf.sgot->contents + off + 4);
5004 outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
5005 elf_append_rel (output_bfd, htab->elf.srelgot, &outrel);
5006 htab->tls_ldm_got.offset |= 1;
5008 relocation = htab->elf.sgot->output_section->vma
5009 + htab->elf.sgot->output_offset + off
5010 - htab->elf.sgotplt->output_section->vma
5011 - htab->elf.sgotplt->output_offset;
5012 unresolved_reloc = FALSE;
5015 case R_386_TLS_LDO_32:
5016 if (!bfd_link_executable (info)
5017 || (input_section->flags & SEC_CODE) == 0)
5018 relocation -= elf_i386_dtpoff_base (info);
5020 /* When converting LDO to LE, we must negate. */
5021 relocation = -elf_i386_tpoff (info, relocation);
5024 case R_386_TLS_LE_32:
5026 if (!bfd_link_executable (info))
5028 Elf_Internal_Rela outrel;
5031 outrel.r_offset = rel->r_offset
5032 + input_section->output_section->vma
5033 + input_section->output_offset;
5034 if (h != NULL && h->dynindx != -1)
5038 if (r_type == R_386_TLS_LE_32)
5039 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
5041 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
5042 sreloc = elf_section_data (input_section)->sreloc;
5045 elf_append_rel (output_bfd, sreloc, &outrel);
5048 else if (r_type == R_386_TLS_LE_32)
5049 relocation = elf_i386_dtpoff_base (info) - relocation;
5051 relocation -= elf_i386_dtpoff_base (info);
5053 else if (r_type == R_386_TLS_LE_32)
5054 relocation = elf_i386_tpoff (info, relocation);
5056 relocation = -elf_i386_tpoff (info, relocation);
5063 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5064 because such sections are not SEC_ALLOC and thus ld.so will
5065 not process them. */
5066 if (unresolved_reloc
5067 && !((input_section->flags & SEC_DEBUGGING) != 0
5069 && _bfd_elf_section_offset (output_bfd, info, input_section,
5070 rel->r_offset) != (bfd_vma) -1)
5072 (*_bfd_error_handler)
5073 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5076 (long) rel->r_offset,
5078 h->root.root.string);
5083 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5084 contents, rel->r_offset,
5087 check_relocation_error:
5088 if (r != bfd_reloc_ok)
5093 name = h->root.root.string;
5096 name = bfd_elf_string_from_elf_section (input_bfd,
5097 symtab_hdr->sh_link,
5102 name = bfd_section_name (input_bfd, sec);
5105 if (r == bfd_reloc_overflow)
5106 (*info->callbacks->reloc_overflow)
5107 (info, (h ? &h->root : NULL), name, howto->name,
5108 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
5111 (*_bfd_error_handler)
5112 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5113 input_bfd, input_section,
5114 (long) rel->r_offset, name, (int) r);
5125 Elf_Internal_Shdr *rel_hdr;
5126 size_t deleted = rel - wrel;
5128 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
5129 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
5130 if (rel_hdr->sh_size == 0)
5132 /* It is too late to remove an empty reloc section. Leave
5134 ??? What is wrong with an empty section??? */
5135 rel_hdr->sh_size = rel_hdr->sh_entsize;
5138 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
5139 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
5140 input_section->reloc_count -= deleted;
5146 /* Finish up dynamic symbol handling. We set the contents of various
5147 dynamic sections here. */
5150 elf_i386_finish_dynamic_symbol (bfd *output_bfd,
5151 struct bfd_link_info *info,
5152 struct elf_link_hash_entry *h,
5153 Elf_Internal_Sym *sym)
5155 struct elf_i386_link_hash_table *htab;
5156 unsigned plt_entry_size;
5157 const struct elf_i386_backend_data *abed;
5158 struct elf_i386_link_hash_entry *eh;
5159 bfd_boolean local_undefweak;
5161 htab = elf_i386_hash_table (info);
5165 abed = get_elf_i386_backend_data (output_bfd);
5166 plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
5168 eh = (struct elf_i386_link_hash_entry *) h;
5170 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5171 resolved undefined weak symbols in executable so that their
5172 references have value 0 at run-time. */
5173 local_undefweak = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
5177 if (h->plt.offset != (bfd_vma) -1)
5181 Elf_Internal_Rela rel;
5183 asection *plt, *gotplt, *relplt;
5185 /* When building a static executable, use .iplt, .igot.plt and
5186 .rel.iplt sections for STT_GNU_IFUNC symbols. */
5187 if (htab->elf.splt != NULL)
5189 plt = htab->elf.splt;
5190 gotplt = htab->elf.sgotplt;
5191 relplt = htab->elf.srelplt;
5195 plt = htab->elf.iplt;
5196 gotplt = htab->elf.igotplt;
5197 relplt = htab->elf.irelplt;
5200 /* This symbol has an entry in the procedure linkage table. Set
5203 if ((h->dynindx == -1
5205 && !((h->forced_local || bfd_link_executable (info))
5207 && h->type == STT_GNU_IFUNC))
5213 /* Get the index in the procedure linkage table which
5214 corresponds to this symbol. This is the index of this symbol
5215 in all the symbols for which we are making plt entries. The
5216 first entry in the procedure linkage table is reserved.
5218 Get the offset into the .got table of the entry that
5219 corresponds to this function. Each .got entry is 4 bytes.
5220 The first three are reserved.
5222 For static executables, we don't reserve anything. */
5224 if (plt == htab->elf.splt)
5226 got_offset = h->plt.offset / plt_entry_size - 1;
5227 got_offset = (got_offset + 3) * 4;
5231 got_offset = h->plt.offset / plt_entry_size;
5232 got_offset = got_offset * 4;
5235 /* Fill in the entry in the procedure linkage table. */
5236 if (! bfd_link_pic (info))
5238 memcpy (plt->contents + h->plt.offset, abed->plt->plt_entry,
5239 abed->plt->plt_entry_size);
5240 bfd_put_32 (output_bfd,
5241 (gotplt->output_section->vma
5242 + gotplt->output_offset
5244 plt->contents + h->plt.offset
5245 + abed->plt->plt_got_offset);
5247 if (abed->is_vxworks)
5249 int s, k, reloc_index;
5251 /* Create the R_386_32 relocation referencing the GOT
5252 for this PLT entry. */
5254 /* S: Current slot number (zero-based). */
5255 s = ((h->plt.offset - abed->plt->plt_entry_size)
5256 / abed->plt->plt_entry_size);
5257 /* K: Number of relocations for PLTResolve. */
5258 if (bfd_link_pic (info))
5259 k = PLTRESOLVE_RELOCS_SHLIB;
5261 k = PLTRESOLVE_RELOCS;
5262 /* Skip the PLTresolve relocations, and the relocations for
5263 the other PLT slots. */
5264 reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
5265 loc = (htab->srelplt2->contents + reloc_index
5266 * sizeof (Elf32_External_Rel));
5268 rel.r_offset = (htab->elf.splt->output_section->vma
5269 + htab->elf.splt->output_offset
5270 + h->plt.offset + 2),
5271 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
5272 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5274 /* Create the R_386_32 relocation referencing the beginning of
5275 the PLT for this GOT entry. */
5276 rel.r_offset = (htab->elf.sgotplt->output_section->vma
5277 + htab->elf.sgotplt->output_offset
5279 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
5280 bfd_elf32_swap_reloc_out (output_bfd, &rel,
5281 loc + sizeof (Elf32_External_Rel));
5286 memcpy (plt->contents + h->plt.offset, abed->plt->pic_plt_entry,
5287 abed->plt->plt_entry_size);
5288 bfd_put_32 (output_bfd, got_offset,
5289 plt->contents + h->plt.offset
5290 + abed->plt->plt_got_offset);
5293 /* Fill in the entry in the global offset table. Leave the entry
5294 as zero for undefined weak symbol in PIE. No PLT relocation
5295 against undefined weak symbol in PIE. */
5296 if (!local_undefweak)
5298 bfd_put_32 (output_bfd,
5299 (plt->output_section->vma
5300 + plt->output_offset
5302 + abed->plt->plt_lazy_offset),
5303 gotplt->contents + got_offset);
5305 /* Fill in the entry in the .rel.plt section. */
5306 rel.r_offset = (gotplt->output_section->vma
5307 + gotplt->output_offset
5309 if (h->dynindx == -1
5310 || ((bfd_link_executable (info)
5311 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
5313 && h->type == STT_GNU_IFUNC))
5315 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5316 R_386_IRELATIVE instead of R_386_JUMP_SLOT. Store addend
5317 in the .got.plt section. */
5318 bfd_put_32 (output_bfd,
5319 (h->root.u.def.value
5320 + h->root.u.def.section->output_section->vma
5321 + h->root.u.def.section->output_offset),
5322 gotplt->contents + got_offset);
5323 rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
5324 /* R_386_IRELATIVE comes last. */
5325 plt_index = htab->next_irelative_index--;
5329 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
5330 plt_index = htab->next_jump_slot_index++;
5333 loc = relplt->contents + plt_index * sizeof (Elf32_External_Rel);
5334 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5336 /* Don't fill PLT entry for static executables. */
5337 if (plt == htab->elf.splt)
5339 bfd_put_32 (output_bfd,
5340 plt_index * sizeof (Elf32_External_Rel),
5341 plt->contents + h->plt.offset
5342 + abed->plt->plt_reloc_offset);
5343 bfd_put_32 (output_bfd, - (h->plt.offset
5344 + abed->plt->plt_plt_offset + 4),
5345 plt->contents + h->plt.offset
5346 + abed->plt->plt_plt_offset);
5350 else if (eh->plt_got.offset != (bfd_vma) -1)
5352 bfd_vma got_offset, plt_offset;
5353 asection *plt, *got, *gotplt;
5354 const bfd_byte *got_plt_entry;
5356 /* Offset of displacement of the indirect jump. */
5357 bfd_vma plt_got_offset = 2;
5359 /* Set the entry in the GOT procedure linkage table. */
5360 plt = htab->plt_got;
5361 got = htab->elf.sgot;
5362 gotplt = htab->elf.sgotplt;
5363 got_offset = h->got.offset;
5365 if (got_offset == (bfd_vma) -1
5371 /* Fill in the entry in the GOT procedure linkage table. */
5372 if (! bfd_link_pic (info))
5374 got_plt_entry = elf_i386_got_plt_entry;
5375 got_offset += got->output_section->vma + got->output_offset;
5379 got_plt_entry = elf_i386_pic_got_plt_entry;
5380 got_offset += (got->output_section->vma
5381 + got->output_offset
5382 - gotplt->output_section->vma
5383 - gotplt->output_offset);
5386 plt_offset = eh->plt_got.offset;
5387 memcpy (plt->contents + plt_offset, got_plt_entry,
5388 sizeof (elf_i386_got_plt_entry));
5389 bfd_put_32 (output_bfd, got_offset,
5390 plt->contents + plt_offset + plt_got_offset);
5393 if (!local_undefweak
5395 && (h->plt.offset != (bfd_vma) -1
5396 || eh->plt_got.offset != (bfd_vma) -1))
5398 /* Mark the symbol as undefined, rather than as defined in
5399 the .plt section. Leave the value if there were any
5400 relocations where pointer equality matters (this is a clue
5401 for the dynamic linker, to make function pointer
5402 comparisons work between an application and shared
5403 library), otherwise set it to zero. If a function is only
5404 called from a binary, there is no need to slow down
5405 shared libraries because of that. */
5406 sym->st_shndx = SHN_UNDEF;
5407 if (!h->pointer_equality_needed)
5411 /* Don't generate dynamic GOT relocation against undefined weak
5412 symbol in executable. */
5413 if (h->got.offset != (bfd_vma) -1
5414 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h)->tls_type)
5415 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0
5416 && !local_undefweak)
5418 Elf_Internal_Rela rel;
5420 /* This symbol has an entry in the global offset table. Set it
5423 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
5426 rel.r_offset = (htab->elf.sgot->output_section->vma
5427 + htab->elf.sgot->output_offset
5428 + (h->got.offset & ~(bfd_vma) 1));
5430 /* If this is a static link, or it is a -Bsymbolic link and the
5431 symbol is defined locally or was forced to be local because
5432 of a version file, we just want to emit a RELATIVE reloc.
5433 The entry in the global offset table will already have been
5434 initialized in the relocate_section function. */
5436 && h->type == STT_GNU_IFUNC)
5438 if (bfd_link_pic (info))
5440 /* Generate R_386_GLOB_DAT. */
5447 if (!h->pointer_equality_needed)
5450 /* For non-shared object, we can't use .got.plt, which
5451 contains the real function addres if we need pointer
5452 equality. We load the GOT entry with the PLT entry. */
5453 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
5454 bfd_put_32 (output_bfd,
5455 (plt->output_section->vma
5456 + plt->output_offset + h->plt.offset),
5457 htab->elf.sgot->contents + h->got.offset);
5461 else if (bfd_link_pic (info)
5462 && SYMBOL_REFERENCES_LOCAL (info, h))
5464 BFD_ASSERT((h->got.offset & 1) != 0);
5465 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
5469 BFD_ASSERT((h->got.offset & 1) == 0);
5471 bfd_put_32 (output_bfd, (bfd_vma) 0,
5472 htab->elf.sgot->contents + h->got.offset);
5473 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
5476 elf_append_rel (output_bfd, htab->elf.srelgot, &rel);
5481 Elf_Internal_Rela rel;
5483 /* This symbol needs a copy reloc. Set it up. */
5485 if (h->dynindx == -1
5486 || (h->root.type != bfd_link_hash_defined
5487 && h->root.type != bfd_link_hash_defweak)
5488 || htab->srelbss == NULL)
5491 rel.r_offset = (h->root.u.def.value
5492 + h->root.u.def.section->output_section->vma
5493 + h->root.u.def.section->output_offset);
5494 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
5495 elf_append_rel (output_bfd, htab->srelbss, &rel);
5501 /* Finish up local dynamic symbol handling. We set the contents of
5502 various dynamic sections here. */
5505 elf_i386_finish_local_dynamic_symbol (void **slot, void *inf)
5507 struct elf_link_hash_entry *h
5508 = (struct elf_link_hash_entry *) *slot;
5509 struct bfd_link_info *info
5510 = (struct bfd_link_info *) inf;
5512 return elf_i386_finish_dynamic_symbol (info->output_bfd, info,
5516 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5517 here since undefined weak symbol may not be dynamic and may not be
5518 called for elf_i386_finish_dynamic_symbol. */
5521 elf_i386_pie_finish_undefweak_symbol (struct bfd_hash_entry *bh,
5524 struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
5525 struct bfd_link_info *info = (struct bfd_link_info *) inf;
5527 if (h->root.type != bfd_link_hash_undefweak
5528 || h->dynindx != -1)
5531 return elf_i386_finish_dynamic_symbol (info->output_bfd,
5535 /* Used to decide how to sort relocs in an optimal manner for the
5536 dynamic linker, before writing them out. */
5538 static enum elf_reloc_type_class
5539 elf_i386_reloc_type_class (const struct bfd_link_info *info,
5540 const asection *rel_sec ATTRIBUTE_UNUSED,
5541 const Elf_Internal_Rela *rela)
5543 bfd *abfd = info->output_bfd;
5544 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5545 struct elf_link_hash_table *htab = elf_hash_table (info);
5547 if (htab->dynsym != NULL
5548 && htab->dynsym->contents != NULL)
5550 /* Check relocation against STT_GNU_IFUNC symbol if there are
5552 unsigned long r_symndx = ELF32_R_SYM (rela->r_info);
5553 Elf_Internal_Sym sym;
5554 if (!bed->s->swap_symbol_in (abfd,
5555 (htab->dynsym->contents
5556 + r_symndx * sizeof (Elf32_External_Sym)),
5560 if (ELF32_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
5561 return reloc_class_ifunc;
5564 switch (ELF32_R_TYPE (rela->r_info))
5566 case R_386_RELATIVE:
5567 return reloc_class_relative;
5568 case R_386_JUMP_SLOT:
5569 return reloc_class_plt;
5571 return reloc_class_copy;
5573 return reloc_class_normal;
5577 /* Finish up the dynamic sections. */
5580 elf_i386_finish_dynamic_sections (bfd *output_bfd,
5581 struct bfd_link_info *info)
5583 struct elf_i386_link_hash_table *htab;
5586 const struct elf_i386_backend_data *abed;
5588 htab = elf_i386_hash_table (info);
5592 dynobj = htab->elf.dynobj;
5593 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
5594 abed = get_elf_i386_backend_data (output_bfd);
5596 if (htab->elf.dynamic_sections_created)
5598 Elf32_External_Dyn *dyncon, *dynconend;
5600 if (sdyn == NULL || htab->elf.sgot == NULL)
5603 dyncon = (Elf32_External_Dyn *) sdyn->contents;
5604 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5605 for (; dyncon < dynconend; dyncon++)
5607 Elf_Internal_Dyn dyn;
5610 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5615 if (abed->is_vxworks
5616 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
5621 s = htab->elf.sgotplt;
5622 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5626 s = htab->elf.srelplt;
5627 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5631 s = htab->elf.srelplt;
5632 dyn.d_un.d_val = s->size;
5636 /* My reading of the SVR4 ABI indicates that the
5637 procedure linkage table relocs (DT_JMPREL) should be
5638 included in the overall relocs (DT_REL). This is
5639 what Solaris does. However, UnixWare can not handle
5640 that case. Therefore, we override the DT_RELSZ entry
5641 here to make it not include the JMPREL relocs. */
5642 s = htab->elf.srelplt;
5645 dyn.d_un.d_val -= s->size;
5649 /* We may not be using the standard ELF linker script.
5650 If .rel.plt is the first .rel section, we adjust
5651 DT_REL to not include it. */
5652 s = htab->elf.srelplt;
5655 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
5657 dyn.d_un.d_ptr += s->size;
5661 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5664 /* Fill in the first entry in the procedure linkage table. */
5665 if (htab->elf.splt && htab->elf.splt->size > 0)
5667 if (bfd_link_pic (info))
5669 memcpy (htab->elf.splt->contents, abed->plt->pic_plt0_entry,
5670 abed->plt->plt0_entry_size);
5671 memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
5672 abed->plt0_pad_byte,
5673 abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
5677 memcpy (htab->elf.splt->contents, abed->plt->plt0_entry,
5678 abed->plt->plt0_entry_size);
5679 memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
5680 abed->plt0_pad_byte,
5681 abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
5682 bfd_put_32 (output_bfd,
5683 (htab->elf.sgotplt->output_section->vma
5684 + htab->elf.sgotplt->output_offset
5686 htab->elf.splt->contents
5687 + abed->plt->plt0_got1_offset);
5688 bfd_put_32 (output_bfd,
5689 (htab->elf.sgotplt->output_section->vma
5690 + htab->elf.sgotplt->output_offset
5692 htab->elf.splt->contents
5693 + abed->plt->plt0_got2_offset);
5695 if (abed->is_vxworks)
5697 Elf_Internal_Rela rel;
5699 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
5700 On IA32 we use REL relocations so the addend goes in
5701 the PLT directly. */
5702 rel.r_offset = (htab->elf.splt->output_section->vma
5703 + htab->elf.splt->output_offset
5704 + abed->plt->plt0_got1_offset);
5705 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
5706 bfd_elf32_swap_reloc_out (output_bfd, &rel,
5707 htab->srelplt2->contents);
5708 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
5709 rel.r_offset = (htab->elf.splt->output_section->vma
5710 + htab->elf.splt->output_offset
5711 + abed->plt->plt0_got2_offset);
5712 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
5713 bfd_elf32_swap_reloc_out (output_bfd, &rel,
5714 htab->srelplt2->contents +
5715 sizeof (Elf32_External_Rel));
5719 /* UnixWare sets the entsize of .plt to 4, although that doesn't
5720 really seem like the right value. */
5721 elf_section_data (htab->elf.splt->output_section)
5722 ->this_hdr.sh_entsize = 4;
5724 /* Correct the .rel.plt.unloaded relocations. */
5725 if (abed->is_vxworks && !bfd_link_pic (info))
5727 int num_plts = (htab->elf.splt->size
5728 / abed->plt->plt_entry_size) - 1;
5731 p = htab->srelplt2->contents;
5732 if (bfd_link_pic (info))
5733 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
5735 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
5737 for (; num_plts; num_plts--)
5739 Elf_Internal_Rela rel;
5740 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
5741 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
5742 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
5743 p += sizeof (Elf32_External_Rel);
5745 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
5746 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
5747 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
5748 p += sizeof (Elf32_External_Rel);
5754 if (htab->elf.sgotplt)
5756 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
5758 (*_bfd_error_handler)
5759 (_("discarded output section: `%A'"), htab->elf.sgotplt);
5763 /* Fill in the first three entries in the global offset table. */
5764 if (htab->elf.sgotplt->size > 0)
5766 bfd_put_32 (output_bfd,
5768 : sdyn->output_section->vma + sdyn->output_offset),
5769 htab->elf.sgotplt->contents);
5770 bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 4);
5771 bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 8);
5774 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize = 4;
5777 /* Adjust .eh_frame for .plt section. */
5778 if (htab->plt_eh_frame != NULL
5779 && htab->plt_eh_frame->contents != NULL)
5781 if (htab->elf.splt != NULL
5782 && htab->elf.splt->size != 0
5783 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
5784 && htab->elf.splt->output_section != NULL
5785 && htab->plt_eh_frame->output_section != NULL)
5787 bfd_vma plt_start = htab->elf.splt->output_section->vma;
5788 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
5789 + htab->plt_eh_frame->output_offset
5790 + PLT_FDE_START_OFFSET;
5791 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
5792 htab->plt_eh_frame->contents
5793 + PLT_FDE_START_OFFSET);
5795 if (htab->plt_eh_frame->sec_info_type
5796 == SEC_INFO_TYPE_EH_FRAME)
5798 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
5800 htab->plt_eh_frame->contents))
5805 if (htab->elf.sgot && htab->elf.sgot->size > 0)
5806 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 4;
5808 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5809 htab_traverse (htab->loc_hash_table,
5810 elf_i386_finish_local_dynamic_symbol,
5813 /* Fill PLT entries for undefined weak symbols in PIE. */
5814 if (bfd_link_pie (info))
5815 bfd_hash_traverse (&info->hash->table,
5816 elf_i386_pie_finish_undefweak_symbol,
5822 /* Return an array of PLT entry symbol values. */
5825 elf_i386_get_plt_sym_val (bfd *abfd, asymbol **dynsyms, asection *plt,
5828 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
5831 bfd_vma *plt_sym_val;
5833 bfd_byte *plt_contents;
5834 const struct elf_i386_backend_data *bed
5835 = get_elf_i386_backend_data (abfd);
5836 Elf_Internal_Shdr *hdr;
5838 /* Get the .plt section contents. */
5839 plt_contents = (bfd_byte *) bfd_malloc (plt->size);
5840 if (plt_contents == NULL)
5842 if (!bfd_get_section_contents (abfd, (asection *) plt,
5843 plt_contents, 0, plt->size))
5846 free (plt_contents);
5850 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
5851 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
5854 hdr = &elf_section_data (relplt)->this_hdr;
5855 count = relplt->size / hdr->sh_entsize;
5857 plt_sym_val = (bfd_vma *) bfd_malloc (sizeof (bfd_vma) * count);
5858 if (plt_sym_val == NULL)
5861 for (i = 0; i < count; i++)
5862 plt_sym_val[i] = -1;
5864 plt_offset = bed->plt->plt_entry_size;
5865 p = relplt->relocation;
5866 for (i = 0; i < count; i++, p++)
5870 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
5871 if (p->howto == NULL)
5874 if (p->howto->type != R_386_JUMP_SLOT
5875 && p->howto->type != R_386_IRELATIVE)
5878 reloc_index = H_GET_32 (abfd, (plt_contents + plt_offset
5879 + bed->plt->plt_reloc_offset));
5880 reloc_index /= sizeof (Elf32_External_Rel);
5881 if (reloc_index < count)
5882 plt_sym_val[reloc_index] = plt->vma + plt_offset;
5884 plt_offset += bed->plt->plt_entry_size;
5886 /* PR binutils/18437: Skip extra relocations in the .rel.plt
5888 if (plt_offset >= plt->size)
5892 free (plt_contents);
5897 /* Similar to _bfd_elf_get_synthetic_symtab. */
5900 elf_i386_get_synthetic_symtab (bfd *abfd,
5907 asection *plt = bfd_get_section_by_name (abfd, ".plt");
5908 return _bfd_elf_ifunc_get_synthetic_symtab (abfd, symcount, syms,
5909 dynsymcount, dynsyms, ret,
5911 elf_i386_get_plt_sym_val);
5914 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5917 elf_i386_hash_symbol (struct elf_link_hash_entry *h)
5919 if (h->plt.offset != (bfd_vma) -1
5921 && !h->pointer_equality_needed)
5924 return _bfd_elf_hash_symbol (h);
5927 #define TARGET_LITTLE_SYM i386_elf32_vec
5928 #define TARGET_LITTLE_NAME "elf32-i386"
5929 #define ELF_ARCH bfd_arch_i386
5930 #define ELF_TARGET_ID I386_ELF_DATA
5931 #define ELF_MACHINE_CODE EM_386
5932 #define ELF_MAXPAGESIZE 0x1000
5934 #define elf_backend_can_gc_sections 1
5935 #define elf_backend_can_refcount 1
5936 #define elf_backend_want_got_plt 1
5937 #define elf_backend_plt_readonly 1
5938 #define elf_backend_want_plt_sym 0
5939 #define elf_backend_got_header_size 12
5940 #define elf_backend_plt_alignment 4
5941 #define elf_backend_extern_protected_data 1
5942 #define elf_backend_caches_rawsize 1
5944 /* Support RELA for objdump of prelink objects. */
5945 #define elf_info_to_howto elf_i386_info_to_howto_rel
5946 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
5948 #define bfd_elf32_mkobject elf_i386_mkobject
5950 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
5951 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
5952 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
5953 #define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
5954 #define bfd_elf32_get_synthetic_symtab elf_i386_get_synthetic_symtab
5956 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
5957 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
5958 #define elf_backend_check_relocs elf_i386_check_relocs
5959 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
5960 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
5961 #define elf_backend_fake_sections elf_i386_fake_sections
5962 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
5963 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
5964 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
5965 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
5966 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
5967 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
5968 #define elf_backend_relocate_section elf_i386_relocate_section
5969 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
5970 #define elf_backend_always_size_sections elf_i386_always_size_sections
5971 #define elf_backend_omit_section_dynsym \
5972 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5973 #define elf_backend_hash_symbol elf_i386_hash_symbol
5974 #define elf_backend_fixup_symbol elf_i386_fixup_symbol
5976 #include "elf32-target.h"
5978 /* FreeBSD support. */
5980 #undef TARGET_LITTLE_SYM
5981 #define TARGET_LITTLE_SYM i386_elf32_fbsd_vec
5982 #undef TARGET_LITTLE_NAME
5983 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
5985 #define ELF_OSABI ELFOSABI_FREEBSD
5987 /* The kernel recognizes executables as valid only if they carry a
5988 "FreeBSD" label in the ELF header. So we put this label on all
5989 executables and (for simplicity) also all other object files. */
5992 elf_i386_fbsd_post_process_headers (bfd *abfd, struct bfd_link_info *info)
5994 _bfd_elf_post_process_headers (abfd, info);
5996 #ifdef OLD_FREEBSD_ABI_LABEL
5998 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
5999 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
6000 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
6005 #undef elf_backend_post_process_headers
6006 #define elf_backend_post_process_headers elf_i386_fbsd_post_process_headers
6008 #define elf32_bed elf32_i386_fbsd_bed
6010 #undef elf_backend_add_symbol_hook
6012 #include "elf32-target.h"
6016 #undef TARGET_LITTLE_SYM
6017 #define TARGET_LITTLE_SYM i386_elf32_sol2_vec
6018 #undef TARGET_LITTLE_NAME
6019 #define TARGET_LITTLE_NAME "elf32-i386-sol2"
6021 #undef elf_backend_post_process_headers
6023 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6024 objects won't be recognized. */
6028 #define elf32_bed elf32_i386_sol2_bed
6030 /* The 32-bit static TLS arena size is rounded to the nearest 8-byte
6032 #undef elf_backend_static_tls_alignment
6033 #define elf_backend_static_tls_alignment 8
6035 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6037 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6039 #undef elf_backend_want_plt_sym
6040 #define elf_backend_want_plt_sym 1
6042 #undef elf_backend_strtab_flags
6043 #define elf_backend_strtab_flags SHF_STRINGS
6045 /* Called to set the sh_flags, sh_link and sh_info fields of OSECTION which
6046 has a type >= SHT_LOOS. Returns TRUE if these fields were initialised
6047 FALSE otherwise. ISECTION is the best guess matching section from the
6048 input bfd IBFD, but it might be NULL. */
6051 elf32_i386_copy_solaris_special_section_fields (const bfd *ibfd ATTRIBUTE_UNUSED,
6052 bfd *obfd ATTRIBUTE_UNUSED,
6053 const Elf_Internal_Shdr *isection ATTRIBUTE_UNUSED,
6054 Elf_Internal_Shdr *osection ATTRIBUTE_UNUSED)
6056 /* PR 19938: FIXME: Need to add code for setting the sh_info
6057 and sh_link fields of Solaris specific section types. */
6060 /* Based upon Oracle Solaris 11.3 Linkers and Libraries Guide, Ch. 13,
6061 Object File Format, Table 13-9 ELF sh_link and sh_info Interpretation:
6063 http://docs.oracle.com/cd/E53394_01/html/E54813/chapter6-94076.html#scrolltoc
6065 The following values should be set:
6068 -----------------------------------------------------------------------------
6069 SHT_SUNW_ancillary The section header index of 0
6070 [0x6fffffee] the associated string table.
6072 SHT_SUNW_capinfo The section header index of For a dynamic object, the
6073 [0x6ffffff0] the associated symbol table. section header index of
6075 SHT_SUNW_capchain table,
6078 SHT_SUNW_symsort The section header index of 0
6079 [0x6ffffff1] the associated symbol table.
6081 SHT_SUNW_tlssort The section header index of 0
6082 [0x6ffffff2] the associated symbol table.
6084 SHT_SUNW_LDYNSYM The section header index of One greater than the
6085 [0x6ffffff3] the associated string table. symbol table index of the
6086 This index is the same string last local symbol,
6087 table used by the SHT_DYNSYM STB_LOCAL. Since
6088 section. SHT_SUNW_LDYNSYM only
6089 contains local symbols,
6090 sh_info is equivalent to
6091 the number of symbols in
6094 SHT_SUNW_cap If symbol capabilities exist, If any capabilities refer
6095 [0x6ffffff5] the section header index of to named strings, the
6096 the associated section header index of
6097 SHT_SUNW_capinfo table, the associated string
6098 otherwise 0. table, otherwise 0.
6100 SHT_SUNW_move The section header index of 0
6101 [0x6ffffffa] the associated symbol table.
6106 SHT_SUNW_syminfo The section header index of The section header index
6107 [0x6ffffffc] the associated symbol table. of the associated
6110 SHT_SUNW_verdef The section header index of The number of version
6111 [0x6ffffffd] the associated string table. definitions within the
6114 SHT_SUNW_verneed The section header index of The number of version
6115 [0x6ffffffe] the associated string table. dependencies within the
6118 SHT_SUNW_versym The section header index of 0
6119 [0x6fffffff] the associated symbol table. */
6122 #undef elf_backend_copy_special_section_fields
6123 #define elf_backend_copy_special_section_fields elf32_i386_copy_solaris_special_section_fields
6125 #include "elf32-target.h"
6127 /* Intel MCU support. */
6130 elf32_iamcu_elf_object_p (bfd *abfd)
6132 /* Set the right machine number for an IAMCU elf32 file. */
6133 bfd_default_set_arch_mach (abfd, bfd_arch_iamcu, bfd_mach_i386_iamcu);
6137 #undef TARGET_LITTLE_SYM
6138 #define TARGET_LITTLE_SYM iamcu_elf32_vec
6139 #undef TARGET_LITTLE_NAME
6140 #define TARGET_LITTLE_NAME "elf32-iamcu"
6142 #define ELF_ARCH bfd_arch_iamcu
6144 #undef ELF_MACHINE_CODE
6145 #define ELF_MACHINE_CODE EM_IAMCU
6150 #define elf32_bed elf32_iamcu_bed
6152 #undef elf_backend_object_p
6153 #define elf_backend_object_p elf32_iamcu_elf_object_p
6155 #undef elf_backend_static_tls_alignment
6157 #undef elf_backend_want_plt_sym
6158 #define elf_backend_want_plt_sym 0
6160 #undef elf_backend_strtab_flags
6161 #undef elf_backend_copy_special_section_fields
6163 #include "elf32-target.h"
6165 /* Restore defaults. */
6167 #define ELF_ARCH bfd_arch_i386
6168 #undef ELF_MACHINE_CODE
6169 #define ELF_MACHINE_CODE EM_386
6171 /* Native Client support. */
6173 #undef TARGET_LITTLE_SYM
6174 #define TARGET_LITTLE_SYM i386_elf32_nacl_vec
6175 #undef TARGET_LITTLE_NAME
6176 #define TARGET_LITTLE_NAME "elf32-i386-nacl"
6178 #define elf32_bed elf32_i386_nacl_bed
6180 #undef ELF_MAXPAGESIZE
6181 #define ELF_MAXPAGESIZE 0x10000
6183 /* Restore defaults. */
6185 #undef elf_backend_want_plt_sym
6186 #define elf_backend_want_plt_sym 0
6187 #undef elf_backend_post_process_headers
6188 #undef elf_backend_static_tls_alignment
6190 /* NaCl uses substantially different PLT entries for the same effects. */
6192 #undef elf_backend_plt_alignment
6193 #define elf_backend_plt_alignment 5
6194 #define NACL_PLT_ENTRY_SIZE 64
6195 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6197 static const bfd_byte elf_i386_nacl_plt0_entry[] =
6199 0xff, 0x35, /* pushl contents of address */
6200 0, 0, 0, 0, /* replaced with address of .got + 4. */
6201 0x8b, 0x0d, /* movl contents of address, %ecx */
6202 0, 0, 0, 0, /* replaced with address of .got + 8. */
6203 0x83, 0xe1, NACLMASK, /* andl $NACLMASK, %ecx */
6204 0xff, 0xe1 /* jmp *%ecx */
6207 static const bfd_byte elf_i386_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
6209 0x8b, 0x0d, /* movl contents of address, %ecx */
6210 0, 0, 0, 0, /* replaced with GOT slot address. */
6211 0x83, 0xe1, NACLMASK, /* andl $NACLMASK, %ecx */
6212 0xff, 0xe1, /* jmp *%ecx */
6214 /* Pad to the next 32-byte boundary with nop instructions. */
6216 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6217 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6219 /* Lazy GOT entries point here (32-byte aligned). */
6220 0x68, /* pushl immediate */
6221 0, 0, 0, 0, /* replaced with reloc offset. */
6222 0xe9, /* jmp relative */
6223 0, 0, 0, 0, /* replaced with offset to .plt. */
6225 /* Pad to the next 32-byte boundary with nop instructions. */
6226 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6227 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6231 static const bfd_byte
6232 elf_i386_nacl_pic_plt0_entry[sizeof (elf_i386_nacl_plt0_entry)] =
6234 0xff, 0x73, 0x04, /* pushl 4(%ebx) */
6235 0x8b, 0x4b, 0x08, /* mov 0x8(%ebx), %ecx */
6236 0x83, 0xe1, 0xe0, /* and $NACLMASK, %ecx */
6237 0xff, 0xe1, /* jmp *%ecx */
6239 /* This is expected to be the same size as elf_i386_nacl_plt0_entry,
6240 so pad to that size with nop instructions. */
6241 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
6244 static const bfd_byte elf_i386_nacl_pic_plt_entry[NACL_PLT_ENTRY_SIZE] =
6246 0x8b, 0x8b, /* movl offset(%ebx), %ecx */
6247 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
6248 0x83, 0xe1, 0xe0, /* andl $NACLMASK, %ecx */
6249 0xff, 0xe1, /* jmp *%ecx */
6251 /* Pad to the next 32-byte boundary with nop instructions. */
6253 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6254 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6256 /* Lazy GOT entries point here (32-byte aligned). */
6257 0x68, /* pushl immediate */
6258 0, 0, 0, 0, /* replaced with offset into relocation table. */
6259 0xe9, /* jmp relative */
6260 0, 0, 0, 0, /* replaced with offset to start of .plt. */
6262 /* Pad to the next 32-byte boundary with nop instructions. */
6263 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6264 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6268 static const bfd_byte elf_i386_nacl_eh_frame_plt[] =
6270 #if (PLT_CIE_LENGTH != 20 \
6271 || PLT_FDE_LENGTH != 36 \
6272 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6273 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6274 # error "Need elf_i386_backend_data parameters for eh_frame_plt offsets!"
6276 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
6277 0, 0, 0, 0, /* CIE ID */
6278 1, /* CIE version */
6279 'z', 'R', 0, /* Augmentation string */
6280 1, /* Code alignment factor */
6281 0x7c, /* Data alignment factor: -4 */
6282 8, /* Return address column */
6283 1, /* Augmentation size */
6284 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
6285 DW_CFA_def_cfa, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
6286 DW_CFA_offset + 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
6287 DW_CFA_nop, DW_CFA_nop,
6289 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
6290 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
6291 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
6292 0, 0, 0, 0, /* .plt size goes here */
6293 0, /* Augmentation size */
6294 DW_CFA_def_cfa_offset, 8, /* DW_CFA_def_cfa_offset: 8 */
6295 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6296 DW_CFA_def_cfa_offset, 12, /* DW_CFA_def_cfa_offset: 12 */
6297 DW_CFA_advance_loc + 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6298 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
6299 13, /* Block length */
6300 DW_OP_breg4, 4, /* DW_OP_breg4 (esp): 4 */
6301 DW_OP_breg8, 0, /* DW_OP_breg8 (eip): 0 */
6302 DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
6303 DW_OP_lit2, DW_OP_shl, DW_OP_plus,
6304 DW_CFA_nop, DW_CFA_nop
6307 static const struct elf_i386_plt_layout elf_i386_nacl_plt =
6309 elf_i386_nacl_plt0_entry, /* plt0_entry */
6310 sizeof (elf_i386_nacl_plt0_entry), /* plt0_entry_size */
6311 2, /* plt0_got1_offset */
6312 8, /* plt0_got2_offset */
6313 elf_i386_nacl_plt_entry, /* plt_entry */
6314 NACL_PLT_ENTRY_SIZE, /* plt_entry_size */
6315 2, /* plt_got_offset */
6316 33, /* plt_reloc_offset */
6317 38, /* plt_plt_offset */
6318 32, /* plt_lazy_offset */
6319 elf_i386_nacl_pic_plt0_entry, /* pic_plt0_entry */
6320 elf_i386_nacl_pic_plt_entry, /* pic_plt_entry */
6321 elf_i386_nacl_eh_frame_plt, /* eh_frame_plt */
6322 sizeof (elf_i386_nacl_eh_frame_plt),/* eh_frame_plt_size */
6325 static const struct elf_i386_backend_data elf_i386_nacl_arch_bed =
6327 &elf_i386_nacl_plt, /* plt */
6328 0x90, /* plt0_pad_byte: nop insn */
6333 elf32_i386_nacl_elf_object_p (bfd *abfd)
6335 /* Set the right machine number for a NaCl i386 ELF32 file. */
6336 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_i386_i386_nacl);
6340 #undef elf_backend_arch_data
6341 #define elf_backend_arch_data &elf_i386_nacl_arch_bed
6343 #undef elf_backend_object_p
6344 #define elf_backend_object_p elf32_i386_nacl_elf_object_p
6345 #undef elf_backend_modify_segment_map
6346 #define elf_backend_modify_segment_map nacl_modify_segment_map
6347 #undef elf_backend_modify_program_headers
6348 #define elf_backend_modify_program_headers nacl_modify_program_headers
6349 #undef elf_backend_final_write_processing
6350 #define elf_backend_final_write_processing nacl_final_write_processing
6352 #include "elf32-target.h"
6354 /* Restore defaults. */
6355 #undef elf_backend_object_p
6356 #undef elf_backend_modify_segment_map
6357 #undef elf_backend_modify_program_headers
6358 #undef elf_backend_final_write_processing
6360 /* VxWorks support. */
6362 #undef TARGET_LITTLE_SYM
6363 #define TARGET_LITTLE_SYM i386_elf32_vxworks_vec
6364 #undef TARGET_LITTLE_NAME
6365 #define TARGET_LITTLE_NAME "elf32-i386-vxworks"
6367 #undef elf_backend_plt_alignment
6368 #define elf_backend_plt_alignment 4
6370 static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed =
6372 &elf_i386_plt, /* plt */
6373 0x90, /* plt0_pad_byte */
6377 #undef elf_backend_arch_data
6378 #define elf_backend_arch_data &elf_i386_vxworks_arch_bed
6380 #undef elf_backend_relocs_compatible
6381 #undef elf_backend_add_symbol_hook
6382 #define elf_backend_add_symbol_hook \
6383 elf_vxworks_add_symbol_hook
6384 #undef elf_backend_link_output_symbol_hook
6385 #define elf_backend_link_output_symbol_hook \
6386 elf_vxworks_link_output_symbol_hook
6387 #undef elf_backend_emit_relocs
6388 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
6389 #undef elf_backend_final_write_processing
6390 #define elf_backend_final_write_processing \
6391 elf_vxworks_final_write_processing
6392 #undef elf_backend_static_tls_alignment
6394 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
6396 #undef elf_backend_want_plt_sym
6397 #define elf_backend_want_plt_sym 1
6400 #define elf32_bed elf32_i386_vxworks_bed
6402 #include "elf32-target.h"