1 /* Intel 80386/80486-specific support for 32-bit ELF
2 Copyright (C) 1993-2016 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
27 #include "elf-vxworks.h"
28 #include "bfd_stdint.h"
32 #include "opcode/i386.h"
34 /* 386 uses REL relocations instead of RELA. */
39 static reloc_howto_type elf_howto_table[]=
41 HOWTO(R_386_NONE, 0, 3, 0, FALSE, 0, complain_overflow_dont,
42 bfd_elf_generic_reloc, "R_386_NONE",
43 TRUE, 0x00000000, 0x00000000, FALSE),
44 HOWTO(R_386_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
45 bfd_elf_generic_reloc, "R_386_32",
46 TRUE, 0xffffffff, 0xffffffff, FALSE),
47 HOWTO(R_386_PC32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
48 bfd_elf_generic_reloc, "R_386_PC32",
49 TRUE, 0xffffffff, 0xffffffff, TRUE),
50 HOWTO(R_386_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
51 bfd_elf_generic_reloc, "R_386_GOT32",
52 TRUE, 0xffffffff, 0xffffffff, FALSE),
53 HOWTO(R_386_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
54 bfd_elf_generic_reloc, "R_386_PLT32",
55 TRUE, 0xffffffff, 0xffffffff, TRUE),
56 HOWTO(R_386_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
57 bfd_elf_generic_reloc, "R_386_COPY",
58 TRUE, 0xffffffff, 0xffffffff, FALSE),
59 HOWTO(R_386_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
60 bfd_elf_generic_reloc, "R_386_GLOB_DAT",
61 TRUE, 0xffffffff, 0xffffffff, FALSE),
62 HOWTO(R_386_JUMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
63 bfd_elf_generic_reloc, "R_386_JUMP_SLOT",
64 TRUE, 0xffffffff, 0xffffffff, FALSE),
65 HOWTO(R_386_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
66 bfd_elf_generic_reloc, "R_386_RELATIVE",
67 TRUE, 0xffffffff, 0xffffffff, FALSE),
68 HOWTO(R_386_GOTOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
69 bfd_elf_generic_reloc, "R_386_GOTOFF",
70 TRUE, 0xffffffff, 0xffffffff, FALSE),
71 HOWTO(R_386_GOTPC, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
72 bfd_elf_generic_reloc, "R_386_GOTPC",
73 TRUE, 0xffffffff, 0xffffffff, TRUE),
75 /* We have a gap in the reloc numbers here.
76 R_386_standard counts the number up to this point, and
77 R_386_ext_offset is the value to subtract from a reloc type of
78 R_386_16 thru R_386_PC8 to form an index into this table. */
79 #define R_386_standard (R_386_GOTPC + 1)
80 #define R_386_ext_offset (R_386_TLS_TPOFF - R_386_standard)
82 /* These relocs are a GNU extension. */
83 HOWTO(R_386_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
84 bfd_elf_generic_reloc, "R_386_TLS_TPOFF",
85 TRUE, 0xffffffff, 0xffffffff, FALSE),
86 HOWTO(R_386_TLS_IE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
87 bfd_elf_generic_reloc, "R_386_TLS_IE",
88 TRUE, 0xffffffff, 0xffffffff, FALSE),
89 HOWTO(R_386_TLS_GOTIE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
90 bfd_elf_generic_reloc, "R_386_TLS_GOTIE",
91 TRUE, 0xffffffff, 0xffffffff, FALSE),
92 HOWTO(R_386_TLS_LE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
93 bfd_elf_generic_reloc, "R_386_TLS_LE",
94 TRUE, 0xffffffff, 0xffffffff, FALSE),
95 HOWTO(R_386_TLS_GD, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
96 bfd_elf_generic_reloc, "R_386_TLS_GD",
97 TRUE, 0xffffffff, 0xffffffff, FALSE),
98 HOWTO(R_386_TLS_LDM, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
99 bfd_elf_generic_reloc, "R_386_TLS_LDM",
100 TRUE, 0xffffffff, 0xffffffff, FALSE),
101 HOWTO(R_386_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
102 bfd_elf_generic_reloc, "R_386_16",
103 TRUE, 0xffff, 0xffff, FALSE),
104 HOWTO(R_386_PC16, 0, 1, 16, TRUE, 0, complain_overflow_bitfield,
105 bfd_elf_generic_reloc, "R_386_PC16",
106 TRUE, 0xffff, 0xffff, TRUE),
107 HOWTO(R_386_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
108 bfd_elf_generic_reloc, "R_386_8",
109 TRUE, 0xff, 0xff, FALSE),
110 HOWTO(R_386_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
111 bfd_elf_generic_reloc, "R_386_PC8",
112 TRUE, 0xff, 0xff, TRUE),
114 #define R_386_ext (R_386_PC8 + 1 - R_386_ext_offset)
115 #define R_386_tls_offset (R_386_TLS_LDO_32 - R_386_ext)
116 /* These are common with Solaris TLS implementation. */
117 HOWTO(R_386_TLS_LDO_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
118 bfd_elf_generic_reloc, "R_386_TLS_LDO_32",
119 TRUE, 0xffffffff, 0xffffffff, FALSE),
120 HOWTO(R_386_TLS_IE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
121 bfd_elf_generic_reloc, "R_386_TLS_IE_32",
122 TRUE, 0xffffffff, 0xffffffff, FALSE),
123 HOWTO(R_386_TLS_LE_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
124 bfd_elf_generic_reloc, "R_386_TLS_LE_32",
125 TRUE, 0xffffffff, 0xffffffff, FALSE),
126 HOWTO(R_386_TLS_DTPMOD32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
127 bfd_elf_generic_reloc, "R_386_TLS_DTPMOD32",
128 TRUE, 0xffffffff, 0xffffffff, FALSE),
129 HOWTO(R_386_TLS_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
130 bfd_elf_generic_reloc, "R_386_TLS_DTPOFF32",
131 TRUE, 0xffffffff, 0xffffffff, FALSE),
132 HOWTO(R_386_TLS_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
133 bfd_elf_generic_reloc, "R_386_TLS_TPOFF32",
134 TRUE, 0xffffffff, 0xffffffff, FALSE),
135 HOWTO(R_386_SIZE32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
136 bfd_elf_generic_reloc, "R_386_SIZE32",
137 TRUE, 0xffffffff, 0xffffffff, FALSE),
138 HOWTO(R_386_TLS_GOTDESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
139 bfd_elf_generic_reloc, "R_386_TLS_GOTDESC",
140 TRUE, 0xffffffff, 0xffffffff, FALSE),
141 HOWTO(R_386_TLS_DESC_CALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
142 bfd_elf_generic_reloc, "R_386_TLS_DESC_CALL",
144 HOWTO(R_386_TLS_DESC, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
145 bfd_elf_generic_reloc, "R_386_TLS_DESC",
146 TRUE, 0xffffffff, 0xffffffff, FALSE),
147 HOWTO(R_386_IRELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
148 bfd_elf_generic_reloc, "R_386_IRELATIVE",
149 TRUE, 0xffffffff, 0xffffffff, FALSE),
150 HOWTO(R_386_GOT32X, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
151 bfd_elf_generic_reloc, "R_386_GOT32X",
152 TRUE, 0xffffffff, 0xffffffff, FALSE),
155 #define R_386_ext2 (R_386_GOT32X + 1 - R_386_tls_offset)
156 #define R_386_vt_offset (R_386_GNU_VTINHERIT - R_386_ext2)
158 /* GNU extension to record C++ vtable hierarchy. */
159 HOWTO (R_386_GNU_VTINHERIT, /* type */
161 2, /* size (0 = byte, 1 = short, 2 = long) */
163 FALSE, /* pc_relative */
165 complain_overflow_dont, /* complain_on_overflow */
166 NULL, /* special_function */
167 "R_386_GNU_VTINHERIT", /* name */
168 FALSE, /* partial_inplace */
171 FALSE), /* pcrel_offset */
173 /* GNU extension to record C++ vtable member usage. */
174 HOWTO (R_386_GNU_VTENTRY, /* type */
176 2, /* size (0 = byte, 1 = short, 2 = long) */
178 FALSE, /* pc_relative */
180 complain_overflow_dont, /* complain_on_overflow */
181 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
182 "R_386_GNU_VTENTRY", /* name */
183 FALSE, /* partial_inplace */
186 FALSE) /* pcrel_offset */
188 #define R_386_vt (R_386_GNU_VTENTRY + 1 - R_386_vt_offset)
192 #ifdef DEBUG_GEN_RELOC
194 fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str)
199 static reloc_howto_type *
200 elf_i386_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
201 bfd_reloc_code_real_type code)
206 TRACE ("BFD_RELOC_NONE");
207 return &elf_howto_table[R_386_NONE];
210 TRACE ("BFD_RELOC_32");
211 return &elf_howto_table[R_386_32];
214 TRACE ("BFD_RELOC_CTOR");
215 return &elf_howto_table[R_386_32];
217 case BFD_RELOC_32_PCREL:
218 TRACE ("BFD_RELOC_PC32");
219 return &elf_howto_table[R_386_PC32];
221 case BFD_RELOC_386_GOT32:
222 TRACE ("BFD_RELOC_386_GOT32");
223 return &elf_howto_table[R_386_GOT32];
225 case BFD_RELOC_386_PLT32:
226 TRACE ("BFD_RELOC_386_PLT32");
227 return &elf_howto_table[R_386_PLT32];
229 case BFD_RELOC_386_COPY:
230 TRACE ("BFD_RELOC_386_COPY");
231 return &elf_howto_table[R_386_COPY];
233 case BFD_RELOC_386_GLOB_DAT:
234 TRACE ("BFD_RELOC_386_GLOB_DAT");
235 return &elf_howto_table[R_386_GLOB_DAT];
237 case BFD_RELOC_386_JUMP_SLOT:
238 TRACE ("BFD_RELOC_386_JUMP_SLOT");
239 return &elf_howto_table[R_386_JUMP_SLOT];
241 case BFD_RELOC_386_RELATIVE:
242 TRACE ("BFD_RELOC_386_RELATIVE");
243 return &elf_howto_table[R_386_RELATIVE];
245 case BFD_RELOC_386_GOTOFF:
246 TRACE ("BFD_RELOC_386_GOTOFF");
247 return &elf_howto_table[R_386_GOTOFF];
249 case BFD_RELOC_386_GOTPC:
250 TRACE ("BFD_RELOC_386_GOTPC");
251 return &elf_howto_table[R_386_GOTPC];
253 /* These relocs are a GNU extension. */
254 case BFD_RELOC_386_TLS_TPOFF:
255 TRACE ("BFD_RELOC_386_TLS_TPOFF");
256 return &elf_howto_table[R_386_TLS_TPOFF - R_386_ext_offset];
258 case BFD_RELOC_386_TLS_IE:
259 TRACE ("BFD_RELOC_386_TLS_IE");
260 return &elf_howto_table[R_386_TLS_IE - R_386_ext_offset];
262 case BFD_RELOC_386_TLS_GOTIE:
263 TRACE ("BFD_RELOC_386_TLS_GOTIE");
264 return &elf_howto_table[R_386_TLS_GOTIE - R_386_ext_offset];
266 case BFD_RELOC_386_TLS_LE:
267 TRACE ("BFD_RELOC_386_TLS_LE");
268 return &elf_howto_table[R_386_TLS_LE - R_386_ext_offset];
270 case BFD_RELOC_386_TLS_GD:
271 TRACE ("BFD_RELOC_386_TLS_GD");
272 return &elf_howto_table[R_386_TLS_GD - R_386_ext_offset];
274 case BFD_RELOC_386_TLS_LDM:
275 TRACE ("BFD_RELOC_386_TLS_LDM");
276 return &elf_howto_table[R_386_TLS_LDM - R_386_ext_offset];
279 TRACE ("BFD_RELOC_16");
280 return &elf_howto_table[R_386_16 - R_386_ext_offset];
282 case BFD_RELOC_16_PCREL:
283 TRACE ("BFD_RELOC_16_PCREL");
284 return &elf_howto_table[R_386_PC16 - R_386_ext_offset];
287 TRACE ("BFD_RELOC_8");
288 return &elf_howto_table[R_386_8 - R_386_ext_offset];
290 case BFD_RELOC_8_PCREL:
291 TRACE ("BFD_RELOC_8_PCREL");
292 return &elf_howto_table[R_386_PC8 - R_386_ext_offset];
294 /* Common with Sun TLS implementation. */
295 case BFD_RELOC_386_TLS_LDO_32:
296 TRACE ("BFD_RELOC_386_TLS_LDO_32");
297 return &elf_howto_table[R_386_TLS_LDO_32 - R_386_tls_offset];
299 case BFD_RELOC_386_TLS_IE_32:
300 TRACE ("BFD_RELOC_386_TLS_IE_32");
301 return &elf_howto_table[R_386_TLS_IE_32 - R_386_tls_offset];
303 case BFD_RELOC_386_TLS_LE_32:
304 TRACE ("BFD_RELOC_386_TLS_LE_32");
305 return &elf_howto_table[R_386_TLS_LE_32 - R_386_tls_offset];
307 case BFD_RELOC_386_TLS_DTPMOD32:
308 TRACE ("BFD_RELOC_386_TLS_DTPMOD32");
309 return &elf_howto_table[R_386_TLS_DTPMOD32 - R_386_tls_offset];
311 case BFD_RELOC_386_TLS_DTPOFF32:
312 TRACE ("BFD_RELOC_386_TLS_DTPOFF32");
313 return &elf_howto_table[R_386_TLS_DTPOFF32 - R_386_tls_offset];
315 case BFD_RELOC_386_TLS_TPOFF32:
316 TRACE ("BFD_RELOC_386_TLS_TPOFF32");
317 return &elf_howto_table[R_386_TLS_TPOFF32 - R_386_tls_offset];
319 case BFD_RELOC_SIZE32:
320 TRACE ("BFD_RELOC_SIZE32");
321 return &elf_howto_table[R_386_SIZE32 - R_386_tls_offset];
323 case BFD_RELOC_386_TLS_GOTDESC:
324 TRACE ("BFD_RELOC_386_TLS_GOTDESC");
325 return &elf_howto_table[R_386_TLS_GOTDESC - R_386_tls_offset];
327 case BFD_RELOC_386_TLS_DESC_CALL:
328 TRACE ("BFD_RELOC_386_TLS_DESC_CALL");
329 return &elf_howto_table[R_386_TLS_DESC_CALL - R_386_tls_offset];
331 case BFD_RELOC_386_TLS_DESC:
332 TRACE ("BFD_RELOC_386_TLS_DESC");
333 return &elf_howto_table[R_386_TLS_DESC - R_386_tls_offset];
335 case BFD_RELOC_386_IRELATIVE:
336 TRACE ("BFD_RELOC_386_IRELATIVE");
337 return &elf_howto_table[R_386_IRELATIVE - R_386_tls_offset];
339 case BFD_RELOC_386_GOT32X:
340 TRACE ("BFD_RELOC_386_GOT32X");
341 return &elf_howto_table[R_386_GOT32X - R_386_tls_offset];
343 case BFD_RELOC_VTABLE_INHERIT:
344 TRACE ("BFD_RELOC_VTABLE_INHERIT");
345 return &elf_howto_table[R_386_GNU_VTINHERIT - R_386_vt_offset];
347 case BFD_RELOC_VTABLE_ENTRY:
348 TRACE ("BFD_RELOC_VTABLE_ENTRY");
349 return &elf_howto_table[R_386_GNU_VTENTRY - R_386_vt_offset];
359 static reloc_howto_type *
360 elf_i386_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
365 for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
366 if (elf_howto_table[i].name != NULL
367 && strcasecmp (elf_howto_table[i].name, r_name) == 0)
368 return &elf_howto_table[i];
373 static reloc_howto_type *
374 elf_i386_rtype_to_howto (bfd *abfd, unsigned r_type)
378 if ((indx = r_type) >= R_386_standard
379 && ((indx = r_type - R_386_ext_offset) - R_386_standard
380 >= R_386_ext - R_386_standard)
381 && ((indx = r_type - R_386_tls_offset) - R_386_ext
382 >= R_386_ext2 - R_386_ext)
383 && ((indx = r_type - R_386_vt_offset) - R_386_ext2
384 >= R_386_vt - R_386_ext2))
386 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
390 /* PR 17512: file: 0f67f69d. */
391 if (elf_howto_table [indx].type != r_type)
393 return &elf_howto_table[indx];
397 elf_i386_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
399 Elf_Internal_Rela *dst)
401 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
402 cache_ptr->howto = elf_i386_rtype_to_howto (abfd, r_type);
405 /* Return whether a symbol name implies a local label. The UnixWare
406 2.1 cc generates temporary symbols that start with .X, so we
407 recognize them here. FIXME: do other SVR4 compilers also use .X?.
408 If so, we should move the .X recognition into
409 _bfd_elf_is_local_label_name. */
412 elf_i386_is_local_label_name (bfd *abfd, const char *name)
414 if (name[0] == '.' && name[1] == 'X')
417 return _bfd_elf_is_local_label_name (abfd, name);
420 /* Support for core dump NOTE sections. */
423 elf_i386_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
428 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
430 int pr_version = bfd_get_32 (abfd, note->descdata);
436 elf_tdata (abfd)->core->signal = bfd_get_32 (abfd, note->descdata + 20);
439 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
443 size = bfd_get_32 (abfd, note->descdata + 8);
447 switch (note->descsz)
452 case 144: /* Linux/i386 */
454 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
457 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
467 /* Make a ".reg/999" section. */
468 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
469 size, note->descpos + offset);
473 elf_i386_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
475 if (note->namesz == 8 && strcmp (note->namedata, "FreeBSD") == 0)
477 int pr_version = bfd_get_32 (abfd, note->descdata);
482 elf_tdata (abfd)->core->program
483 = _bfd_elfcore_strndup (abfd, note->descdata + 8, 17);
484 elf_tdata (abfd)->core->command
485 = _bfd_elfcore_strndup (abfd, note->descdata + 25, 81);
489 switch (note->descsz)
494 case 124: /* Linux/i386 elf_prpsinfo. */
495 elf_tdata (abfd)->core->pid
496 = bfd_get_32 (abfd, note->descdata + 12);
497 elf_tdata (abfd)->core->program
498 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
499 elf_tdata (abfd)->core->command
500 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
504 /* Note that for some reason, a spurious space is tacked
505 onto the end of the args in some (at least one anyway)
506 implementations, so strip it off if it exists. */
508 char *command = elf_tdata (abfd)->core->command;
509 int n = strlen (command);
511 if (0 < n && command[n - 1] == ' ')
512 command[n - 1] = '\0';
518 /* Functions for the i386 ELF linker.
520 In order to gain some understanding of code in this file without
521 knowing all the intricate details of the linker, note the
524 Functions named elf_i386_* are called by external routines, other
525 functions are only called locally. elf_i386_* functions appear
526 in this file more or less in the order in which they are called
527 from external routines. eg. elf_i386_check_relocs is called
528 early in the link process, elf_i386_finish_dynamic_sections is
529 one of the last functions. */
532 /* The name of the dynamic interpreter. This is put in the .interp
535 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
537 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
538 copying dynamic variables from a shared lib into an app's dynbss
539 section, and instead use a dynamic relocation to point into the
541 #define ELIMINATE_COPY_RELOCS 1
543 /* The size in bytes of an entry in the procedure linkage table. */
545 #define PLT_ENTRY_SIZE 16
547 /* The first entry in an absolute procedure linkage table looks like
548 this. See the SVR4 ABI i386 supplement to see how this works.
549 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
551 static const bfd_byte elf_i386_plt0_entry[12] =
553 0xff, 0x35, /* pushl contents of address */
554 0, 0, 0, 0, /* replaced with address of .got + 4. */
555 0xff, 0x25, /* jmp indirect */
556 0, 0, 0, 0 /* replaced with address of .got + 8. */
559 /* Subsequent entries in an absolute procedure linkage table look like
562 static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] =
564 0xff, 0x25, /* jmp indirect */
565 0, 0, 0, 0, /* replaced with address of this symbol in .got. */
566 0x68, /* pushl immediate */
567 0, 0, 0, 0, /* replaced with offset into relocation table. */
568 0xe9, /* jmp relative */
569 0, 0, 0, 0 /* replaced with offset to start of .plt. */
572 /* The first entry in a PIC procedure linkage table look like this.
573 Will be padded to PLT_ENTRY_SIZE with htab->plt0_pad_byte. */
575 static const bfd_byte elf_i386_pic_plt0_entry[12] =
577 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */
578 0xff, 0xa3, 8, 0, 0, 0 /* jmp *8(%ebx) */
581 /* Subsequent entries in a PIC procedure linkage table look like this. */
583 static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] =
585 0xff, 0xa3, /* jmp *offset(%ebx) */
586 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
587 0x68, /* pushl immediate */
588 0, 0, 0, 0, /* replaced with offset into relocation table. */
589 0xe9, /* jmp relative */
590 0, 0, 0, 0 /* replaced with offset to start of .plt. */
593 /* Entries in the GOT procedure linkage table look like this. */
595 static const bfd_byte elf_i386_got_plt_entry[8] =
597 0xff, 0x25, /* jmp indirect */
598 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
599 0x66, 0x90 /* xchg %ax,%ax */
602 /* Entries in the PIC GOT procedure linkage table look like this. */
604 static const bfd_byte elf_i386_pic_got_plt_entry[8] =
606 0xff, 0xa3, /* jmp *offset(%ebx) */
607 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
608 0x66, 0x90 /* xchg %ax,%ax */
611 /* .eh_frame covering the .plt section. */
613 static const bfd_byte elf_i386_eh_frame_plt[] =
615 #define PLT_CIE_LENGTH 20
616 #define PLT_FDE_LENGTH 36
617 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
618 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
619 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
620 0, 0, 0, 0, /* CIE ID */
622 'z', 'R', 0, /* Augmentation string */
623 1, /* Code alignment factor */
624 0x7c, /* Data alignment factor */
625 8, /* Return address column */
626 1, /* Augmentation size */
627 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
628 DW_CFA_def_cfa, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
629 DW_CFA_offset + 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
630 DW_CFA_nop, DW_CFA_nop,
632 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
633 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
634 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
635 0, 0, 0, 0, /* .plt size goes here */
636 0, /* Augmentation size */
637 DW_CFA_def_cfa_offset, 8, /* DW_CFA_def_cfa_offset: 8 */
638 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
639 DW_CFA_def_cfa_offset, 12, /* DW_CFA_def_cfa_offset: 12 */
640 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
641 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
642 11, /* Block length */
643 DW_OP_breg4, 4, /* DW_OP_breg4 (esp): 4 */
644 DW_OP_breg8, 0, /* DW_OP_breg8 (eip): 0 */
645 DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
646 DW_OP_lit2, DW_OP_shl, DW_OP_plus,
647 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
650 struct elf_i386_plt_layout
652 /* The first entry in an absolute procedure linkage table looks like this. */
653 const bfd_byte *plt0_entry;
654 unsigned int plt0_entry_size;
656 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
657 unsigned int plt0_got1_offset;
658 unsigned int plt0_got2_offset;
660 /* Later entries in an absolute procedure linkage table look like this. */
661 const bfd_byte *plt_entry;
662 unsigned int plt_entry_size;
664 /* Offsets into plt_entry that are to be replaced with... */
665 unsigned int plt_got_offset; /* ... address of this symbol in .got. */
666 unsigned int plt_reloc_offset; /* ... offset into relocation table. */
667 unsigned int plt_plt_offset; /* ... offset to start of .plt. */
669 /* Offset into plt_entry where the initial value of the GOT entry points. */
670 unsigned int plt_lazy_offset;
672 /* The first entry in a PIC procedure linkage table looks like this. */
673 const bfd_byte *pic_plt0_entry;
675 /* Subsequent entries in a PIC procedure linkage table look like this. */
676 const bfd_byte *pic_plt_entry;
678 /* .eh_frame covering the .plt section. */
679 const bfd_byte *eh_frame_plt;
680 unsigned int eh_frame_plt_size;
683 #define GET_PLT_ENTRY_SIZE(abfd) \
684 get_elf_i386_backend_data (abfd)->plt->plt_entry_size
686 /* These are the standard parameters. */
687 static const struct elf_i386_plt_layout elf_i386_plt =
689 elf_i386_plt0_entry, /* plt0_entry */
690 sizeof (elf_i386_plt0_entry), /* plt0_entry_size */
691 2, /* plt0_got1_offset */
692 8, /* plt0_got2_offset */
693 elf_i386_plt_entry, /* plt_entry */
694 PLT_ENTRY_SIZE, /* plt_entry_size */
695 2, /* plt_got_offset */
696 7, /* plt_reloc_offset */
697 12, /* plt_plt_offset */
698 6, /* plt_lazy_offset */
699 elf_i386_pic_plt0_entry, /* pic_plt0_entry */
700 elf_i386_pic_plt_entry, /* pic_plt_entry */
701 elf_i386_eh_frame_plt, /* eh_frame_plt */
702 sizeof (elf_i386_eh_frame_plt), /* eh_frame_plt_size */
706 /* On VxWorks, the .rel.plt.unloaded section has absolute relocations
707 for the PLTResolve stub and then for each PLT entry. */
708 #define PLTRESOLVE_RELOCS_SHLIB 0
709 #define PLTRESOLVE_RELOCS 2
710 #define PLT_NON_JUMP_SLOT_RELOCS 2
712 /* Architecture-specific backend data for i386. */
714 struct elf_i386_backend_data
716 /* Parameters describing PLT generation. */
717 const struct elf_i386_plt_layout *plt;
719 /* Value used to fill the unused bytes of the first PLT entry. */
720 bfd_byte plt0_pad_byte;
722 /* True if the target system is VxWorks. */
726 #define get_elf_i386_backend_data(abfd) \
727 ((const struct elf_i386_backend_data *) \
728 get_elf_backend_data (abfd)->arch_data)
730 /* These are the standard parameters. */
731 static const struct elf_i386_backend_data elf_i386_arch_bed =
733 &elf_i386_plt, /* plt */
734 0, /* plt0_pad_byte */
738 #define elf_backend_arch_data &elf_i386_arch_bed
740 /* Is a undefined weak symbol which is resolved to 0. Reference to an
741 undefined weak symbol is resolved to 0 when building executable if
743 1. Has non-GOT/non-PLT relocations in text section. Or
744 2. Has no GOT/PLT relocation.
746 #define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, GOT_RELOC, EH) \
747 ((EH)->elf.root.type == bfd_link_hash_undefweak \
748 && bfd_link_executable (INFO) \
749 && (elf_i386_hash_table (INFO)->interp == NULL \
751 || (EH)->has_non_got_reloc \
752 || !(INFO)->dynamic_undefined_weak))
754 /* i386 ELF linker hash entry. */
756 struct elf_i386_link_hash_entry
758 struct elf_link_hash_entry elf;
760 /* Track dynamic relocs copied for this symbol. */
761 struct elf_dyn_relocs *dyn_relocs;
763 #define GOT_UNKNOWN 0
767 #define GOT_TLS_IE_POS 5
768 #define GOT_TLS_IE_NEG 6
769 #define GOT_TLS_IE_BOTH 7
770 #define GOT_TLS_GDESC 8
771 #define GOT_TLS_GD_BOTH_P(type) \
772 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
773 #define GOT_TLS_GD_P(type) \
774 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
775 #define GOT_TLS_GDESC_P(type) \
776 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
777 #define GOT_TLS_GD_ANY_P(type) \
778 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
779 unsigned char tls_type;
781 /* Symbol is referenced by R_386_GOTOFF relocation. */
782 unsigned int gotoff_ref : 1;
784 /* Symbol has GOT or PLT relocations. */
785 unsigned int has_got_reloc : 1;
787 /* Symbol has non-GOT/non-PLT relocations in text sections. */
788 unsigned int has_non_got_reloc : 1;
790 /* Reference count of C/C++ function pointer relocations in read-write
791 section which can be resolved at run-time. */
792 bfd_signed_vma func_pointer_refcount;
794 /* Information about the GOT PLT entry. Filled when there are both
795 GOT and PLT relocations against the same function. */
796 union gotplt_union plt_got;
798 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
799 starting at the end of the jump table. */
803 #define elf_i386_hash_entry(ent) ((struct elf_i386_link_hash_entry *)(ent))
805 struct elf_i386_obj_tdata
807 struct elf_obj_tdata root;
809 /* tls_type for each local got entry. */
810 char *local_got_tls_type;
812 /* GOTPLT entries for TLS descriptors. */
813 bfd_vma *local_tlsdesc_gotent;
816 #define elf_i386_tdata(abfd) \
817 ((struct elf_i386_obj_tdata *) (abfd)->tdata.any)
819 #define elf_i386_local_got_tls_type(abfd) \
820 (elf_i386_tdata (abfd)->local_got_tls_type)
822 #define elf_i386_local_tlsdesc_gotent(abfd) \
823 (elf_i386_tdata (abfd)->local_tlsdesc_gotent)
825 #define is_i386_elf(bfd) \
826 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
827 && elf_tdata (bfd) != NULL \
828 && elf_object_id (bfd) == I386_ELF_DATA)
831 elf_i386_mkobject (bfd *abfd)
833 return bfd_elf_allocate_object (abfd, sizeof (struct elf_i386_obj_tdata),
837 /* i386 ELF linker hash table. */
839 struct elf_i386_link_hash_table
841 struct elf_link_hash_table elf;
843 /* Short-cuts to get to dynamic linker sections. */
847 asection *plt_eh_frame;
852 bfd_signed_vma refcount;
856 /* The amount of space used by the reserved portion of the sgotplt
857 section, plus whatever space is used by the jump slots. */
858 bfd_vma sgotplt_jump_table_size;
860 /* Small local sym cache. */
861 struct sym_cache sym_cache;
863 /* _TLS_MODULE_BASE_ symbol. */
864 struct bfd_link_hash_entry *tls_module_base;
866 /* Used by local STT_GNU_IFUNC symbols. */
867 htab_t loc_hash_table;
868 void * loc_hash_memory;
870 /* The (unloaded but important) .rel.plt.unloaded section on VxWorks. */
873 /* The index of the next unused R_386_TLS_DESC slot in .rel.plt. */
874 bfd_vma next_tls_desc_index;
876 /* The index of the next unused R_386_JUMP_SLOT slot in .rel.plt. */
877 bfd_vma next_jump_slot_index;
879 /* The index of the next unused R_386_IRELATIVE slot in .rel.plt. */
880 bfd_vma next_irelative_index;
882 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
883 to read-only sections. */
884 bfd_boolean readonly_dynrelocs_against_ifunc;
887 /* Get the i386 ELF linker hash table from a link_info structure. */
889 #define elf_i386_hash_table(p) \
890 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
891 == I386_ELF_DATA ? ((struct elf_i386_link_hash_table *) ((p)->hash)) : NULL)
893 #define elf_i386_compute_jump_table_size(htab) \
894 ((htab)->elf.srelplt->reloc_count * 4)
896 /* Create an entry in an i386 ELF linker hash table. */
898 static struct bfd_hash_entry *
899 elf_i386_link_hash_newfunc (struct bfd_hash_entry *entry,
900 struct bfd_hash_table *table,
903 /* Allocate the structure if it has not already been allocated by a
907 entry = (struct bfd_hash_entry *)
908 bfd_hash_allocate (table, sizeof (struct elf_i386_link_hash_entry));
913 /* Call the allocation method of the superclass. */
914 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
917 struct elf_i386_link_hash_entry *eh;
919 eh = (struct elf_i386_link_hash_entry *) entry;
920 eh->dyn_relocs = NULL;
921 eh->tls_type = GOT_UNKNOWN;
923 eh->has_got_reloc = 0;
924 eh->has_non_got_reloc = 0;
925 eh->func_pointer_refcount = 0;
926 eh->plt_got.offset = (bfd_vma) -1;
927 eh->tlsdesc_got = (bfd_vma) -1;
933 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
934 for local symbol so that we can handle local STT_GNU_IFUNC symbols
935 as global symbol. We reuse indx and dynstr_index for local symbol
936 hash since they aren't used by global symbols in this backend. */
939 elf_i386_local_htab_hash (const void *ptr)
941 struct elf_link_hash_entry *h
942 = (struct elf_link_hash_entry *) ptr;
943 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
946 /* Compare local hash entries. */
949 elf_i386_local_htab_eq (const void *ptr1, const void *ptr2)
951 struct elf_link_hash_entry *h1
952 = (struct elf_link_hash_entry *) ptr1;
953 struct elf_link_hash_entry *h2
954 = (struct elf_link_hash_entry *) ptr2;
956 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
959 /* Find and/or create a hash entry for local symbol. */
961 static struct elf_link_hash_entry *
962 elf_i386_get_local_sym_hash (struct elf_i386_link_hash_table *htab,
963 bfd *abfd, const Elf_Internal_Rela *rel,
966 struct elf_i386_link_hash_entry e, *ret;
967 asection *sec = abfd->sections;
968 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
969 ELF32_R_SYM (rel->r_info));
972 e.elf.indx = sec->id;
973 e.elf.dynstr_index = ELF32_R_SYM (rel->r_info);
974 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
975 create ? INSERT : NO_INSERT);
982 ret = (struct elf_i386_link_hash_entry *) *slot;
986 ret = (struct elf_i386_link_hash_entry *)
987 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
988 sizeof (struct elf_i386_link_hash_entry));
991 memset (ret, 0, sizeof (*ret));
992 ret->elf.indx = sec->id;
993 ret->elf.dynstr_index = ELF32_R_SYM (rel->r_info);
994 ret->elf.dynindx = -1;
995 ret->func_pointer_refcount = 0;
996 ret->plt_got.offset = (bfd_vma) -1;
1002 /* Destroy an i386 ELF linker hash table. */
1005 elf_i386_link_hash_table_free (bfd *obfd)
1007 struct elf_i386_link_hash_table *htab
1008 = (struct elf_i386_link_hash_table *) obfd->link.hash;
1010 if (htab->loc_hash_table)
1011 htab_delete (htab->loc_hash_table);
1012 if (htab->loc_hash_memory)
1013 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
1014 _bfd_elf_link_hash_table_free (obfd);
1017 /* Create an i386 ELF linker hash table. */
1019 static struct bfd_link_hash_table *
1020 elf_i386_link_hash_table_create (bfd *abfd)
1022 struct elf_i386_link_hash_table *ret;
1023 bfd_size_type amt = sizeof (struct elf_i386_link_hash_table);
1025 ret = (struct elf_i386_link_hash_table *) bfd_zmalloc (amt);
1029 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
1030 elf_i386_link_hash_newfunc,
1031 sizeof (struct elf_i386_link_hash_entry),
1038 ret->loc_hash_table = htab_try_create (1024,
1039 elf_i386_local_htab_hash,
1040 elf_i386_local_htab_eq,
1042 ret->loc_hash_memory = objalloc_create ();
1043 if (!ret->loc_hash_table || !ret->loc_hash_memory)
1045 elf_i386_link_hash_table_free (abfd);
1048 ret->elf.root.hash_table_free = elf_i386_link_hash_table_free;
1050 return &ret->elf.root;
1053 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
1054 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
1058 elf_i386_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
1060 struct elf_i386_link_hash_table *htab;
1062 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1065 htab = elf_i386_hash_table (info);
1069 /* Set the contents of the .interp section to the interpreter. */
1070 if (bfd_link_executable (info) && !info->nointerp)
1072 asection *s = bfd_get_linker_section (dynobj, ".interp");
1075 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1076 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1080 htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
1084 if (bfd_link_executable (info))
1086 /* Always allow copy relocs for building executables. */
1087 asection *s = bfd_get_linker_section (dynobj, ".rel.bss");
1090 const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
1091 s = bfd_make_section_anyway_with_flags (dynobj,
1093 (bed->dynamic_sec_flags
1096 || ! bfd_set_section_alignment (dynobj, s,
1097 bed->s->log_file_align))
1103 if (get_elf_i386_backend_data (dynobj)->is_vxworks
1104 && !elf_vxworks_create_dynamic_sections (dynobj, info,
1108 if (!info->no_ld_generated_unwind_info
1109 && htab->plt_eh_frame == NULL
1110 && htab->elf.splt != NULL)
1112 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
1113 | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1114 | SEC_LINKER_CREATED);
1116 = bfd_make_section_anyway_with_flags (dynobj, ".eh_frame", flags);
1117 if (htab->plt_eh_frame == NULL
1118 || !bfd_set_section_alignment (dynobj, htab->plt_eh_frame, 2))
1125 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1128 elf_i386_copy_indirect_symbol (struct bfd_link_info *info,
1129 struct elf_link_hash_entry *dir,
1130 struct elf_link_hash_entry *ind)
1132 struct elf_i386_link_hash_entry *edir, *eind;
1134 edir = (struct elf_i386_link_hash_entry *) dir;
1135 eind = (struct elf_i386_link_hash_entry *) ind;
1137 if (eind->dyn_relocs != NULL)
1139 if (edir->dyn_relocs != NULL)
1141 struct elf_dyn_relocs **pp;
1142 struct elf_dyn_relocs *p;
1144 /* Add reloc counts against the indirect sym to the direct sym
1145 list. Merge any entries against the same section. */
1146 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1148 struct elf_dyn_relocs *q;
1150 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1151 if (q->sec == p->sec)
1153 q->pc_count += p->pc_count;
1154 q->count += p->count;
1161 *pp = edir->dyn_relocs;
1164 edir->dyn_relocs = eind->dyn_relocs;
1165 eind->dyn_relocs = NULL;
1168 if (ind->root.type == bfd_link_hash_indirect
1169 && dir->got.refcount <= 0)
1171 edir->tls_type = eind->tls_type;
1172 eind->tls_type = GOT_UNKNOWN;
1175 /* Copy gotoff_ref so that elf_i386_adjust_dynamic_symbol will
1176 generate a R_386_COPY reloc. */
1177 edir->gotoff_ref |= eind->gotoff_ref;
1179 edir->has_got_reloc |= eind->has_got_reloc;
1180 edir->has_non_got_reloc |= eind->has_non_got_reloc;
1182 if (ELIMINATE_COPY_RELOCS
1183 && ind->root.type != bfd_link_hash_indirect
1184 && dir->dynamic_adjusted)
1186 /* If called to transfer flags for a weakdef during processing
1187 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1188 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1189 dir->ref_dynamic |= ind->ref_dynamic;
1190 dir->ref_regular |= ind->ref_regular;
1191 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1192 dir->needs_plt |= ind->needs_plt;
1193 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1197 if (eind->func_pointer_refcount > 0)
1199 edir->func_pointer_refcount += eind->func_pointer_refcount;
1200 eind->func_pointer_refcount = 0;
1203 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1207 /* Return TRUE if the TLS access code sequence support transition
1211 elf_i386_check_tls_transition (bfd *abfd, asection *sec,
1213 Elf_Internal_Shdr *symtab_hdr,
1214 struct elf_link_hash_entry **sym_hashes,
1215 unsigned int r_type,
1216 const Elf_Internal_Rela *rel,
1217 const Elf_Internal_Rela *relend)
1219 unsigned int val, type;
1220 unsigned long r_symndx;
1221 struct elf_link_hash_entry *h;
1224 /* Get the section contents. */
1225 if (contents == NULL)
1227 if (elf_section_data (sec)->this_hdr.contents != NULL)
1228 contents = elf_section_data (sec)->this_hdr.contents;
1231 /* FIXME: How to better handle error condition? */
1232 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1235 /* Cache the section contents for elf_link_input_bfd. */
1236 elf_section_data (sec)->this_hdr.contents = contents;
1240 offset = rel->r_offset;
1245 if (offset < 2 || (rel + 1) >= relend)
1248 type = bfd_get_8 (abfd, contents + offset - 2);
1249 if (r_type == R_386_TLS_GD)
1251 /* Check transition from GD access model. Only
1252 leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr
1253 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop
1254 can transit to different access model. */
1255 if ((offset + 10) > sec->size ||
1256 (type != 0x8d && type != 0x04))
1259 val = bfd_get_8 (abfd, contents + offset - 1);
1262 /* leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr */
1266 if (bfd_get_8 (abfd, contents + offset - 3) != 0x8d)
1269 if ((val & 0xc7) != 0x05 || val == (4 << 3))
1274 /* leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop */
1275 if ((val & 0xf8) != 0x80 || (val & 7) == 4)
1278 if (bfd_get_8 (abfd, contents + offset + 9) != 0x90)
1284 /* Check transition from LD access model. Only
1285 leal foo@tlsgd(%reg), %eax; call ___tls_get_addr
1286 can transit to different access model. */
1287 if (type != 0x8d || (offset + 9) > sec->size)
1290 val = bfd_get_8 (abfd, contents + offset - 1);
1291 if ((val & 0xf8) != 0x80 || (val & 7) == 4)
1295 if (bfd_get_8 (abfd, contents + offset + 4) != 0xe8)
1298 r_symndx = ELF32_R_SYM (rel[1].r_info);
1299 if (r_symndx < symtab_hdr->sh_info)
1302 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1303 /* Use strncmp to check ___tls_get_addr since ___tls_get_addr
1304 may be versioned. */
1306 && h->root.root.string != NULL
1307 && (ELF32_R_TYPE (rel[1].r_info) == R_386_PC32
1308 || ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32)
1309 && (strncmp (h->root.root.string, "___tls_get_addr",
1313 /* Check transition from IE access model:
1314 movl foo@indntpoff(%rip), %eax
1315 movl foo@indntpoff(%rip), %reg
1316 addl foo@indntpoff(%rip), %reg
1319 if (offset < 1 || (offset + 4) > sec->size)
1322 /* Check "movl foo@tpoff(%rip), %eax" first. */
1323 val = bfd_get_8 (abfd, contents + offset - 1);
1330 /* Check movl|addl foo@tpoff(%rip), %reg. */
1331 type = bfd_get_8 (abfd, contents + offset - 2);
1332 return ((type == 0x8b || type == 0x03)
1333 && (val & 0xc7) == 0x05);
1335 case R_386_TLS_GOTIE:
1336 case R_386_TLS_IE_32:
1337 /* Check transition from {IE_32,GOTIE} access model:
1338 subl foo@{tpoff,gontoff}(%reg1), %reg2
1339 movl foo@{tpoff,gontoff}(%reg1), %reg2
1340 addl foo@{tpoff,gontoff}(%reg1), %reg2
1343 if (offset < 2 || (offset + 4) > sec->size)
1346 val = bfd_get_8 (abfd, contents + offset - 1);
1347 if ((val & 0xc0) != 0x80 || (val & 7) == 4)
1350 type = bfd_get_8 (abfd, contents + offset - 2);
1351 return type == 0x8b || type == 0x2b || type == 0x03;
1353 case R_386_TLS_GOTDESC:
1354 /* Check transition from GDesc access model:
1355 leal x@tlsdesc(%ebx), %eax
1357 Make sure it's a leal adding ebx to a 32-bit offset
1358 into any register, although it's probably almost always
1361 if (offset < 2 || (offset + 4) > sec->size)
1364 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1367 val = bfd_get_8 (abfd, contents + offset - 1);
1368 return (val & 0xc7) == 0x83;
1370 case R_386_TLS_DESC_CALL:
1371 /* Check transition from GDesc access model:
1372 call *x@tlsdesc(%rax)
1374 if (offset + 2 <= sec->size)
1376 /* Make sure that it's a call *x@tlsdesc(%rax). */
1377 static const unsigned char call[] = { 0xff, 0x10 };
1378 return memcmp (contents + offset, call, 2) == 0;
1388 /* Return TRUE if the TLS access transition is OK or no transition
1389 will be performed. Update R_TYPE if there is a transition. */
1392 elf_i386_tls_transition (struct bfd_link_info *info, bfd *abfd,
1393 asection *sec, bfd_byte *contents,
1394 Elf_Internal_Shdr *symtab_hdr,
1395 struct elf_link_hash_entry **sym_hashes,
1396 unsigned int *r_type, int tls_type,
1397 const Elf_Internal_Rela *rel,
1398 const Elf_Internal_Rela *relend,
1399 struct elf_link_hash_entry *h,
1400 unsigned long r_symndx)
1402 unsigned int from_type = *r_type;
1403 unsigned int to_type = from_type;
1404 bfd_boolean check = TRUE;
1406 /* Skip TLS transition for functions. */
1408 && (h->type == STT_FUNC
1409 || h->type == STT_GNU_IFUNC))
1415 case R_386_TLS_GOTDESC:
1416 case R_386_TLS_DESC_CALL:
1417 case R_386_TLS_IE_32:
1419 case R_386_TLS_GOTIE:
1420 if (bfd_link_executable (info))
1423 to_type = R_386_TLS_LE_32;
1424 else if (from_type != R_386_TLS_IE
1425 && from_type != R_386_TLS_GOTIE)
1426 to_type = R_386_TLS_IE_32;
1429 /* When we are called from elf_i386_relocate_section, CONTENTS
1430 isn't NULL and there may be additional transitions based on
1432 if (contents != NULL)
1434 unsigned int new_to_type = to_type;
1436 if (bfd_link_executable (info)
1439 && (tls_type & GOT_TLS_IE))
1440 new_to_type = R_386_TLS_LE_32;
1442 if (to_type == R_386_TLS_GD
1443 || to_type == R_386_TLS_GOTDESC
1444 || to_type == R_386_TLS_DESC_CALL)
1446 if (tls_type == GOT_TLS_IE_POS)
1447 new_to_type = R_386_TLS_GOTIE;
1448 else if (tls_type & GOT_TLS_IE)
1449 new_to_type = R_386_TLS_IE_32;
1452 /* We checked the transition before when we were called from
1453 elf_i386_check_relocs. We only want to check the new
1454 transition which hasn't been checked before. */
1455 check = new_to_type != to_type && from_type == to_type;
1456 to_type = new_to_type;
1462 if (bfd_link_executable (info))
1463 to_type = R_386_TLS_LE_32;
1470 /* Return TRUE if there is no transition. */
1471 if (from_type == to_type)
1474 /* Check if the transition can be performed. */
1476 && ! elf_i386_check_tls_transition (abfd, sec, contents,
1477 symtab_hdr, sym_hashes,
1478 from_type, rel, relend))
1480 reloc_howto_type *from, *to;
1483 from = elf_i386_rtype_to_howto (abfd, from_type);
1484 to = elf_i386_rtype_to_howto (abfd, to_type);
1487 name = h->root.root.string;
1490 struct elf_i386_link_hash_table *htab;
1492 htab = elf_i386_hash_table (info);
1497 Elf_Internal_Sym *isym;
1499 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1501 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1505 (*_bfd_error_handler)
1506 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1507 "in section `%A' failed"),
1508 abfd, sec, from->name, to->name, name,
1509 (unsigned long) rel->r_offset);
1510 bfd_set_error (bfd_error_bad_value);
1518 /* Rename some of the generic section flags to better document how they
1520 #define need_convert_load sec_flg0
1521 #define check_relocs_failed sec_flg1
1523 /* Look through the relocs for a section during the first phase, and
1524 calculate needed space in the global offset table, procedure linkage
1525 table, and dynamic reloc sections. */
1528 elf_i386_check_relocs (bfd *abfd,
1529 struct bfd_link_info *info,
1531 const Elf_Internal_Rela *relocs)
1533 struct elf_i386_link_hash_table *htab;
1534 Elf_Internal_Shdr *symtab_hdr;
1535 struct elf_link_hash_entry **sym_hashes;
1536 const Elf_Internal_Rela *rel;
1537 const Elf_Internal_Rela *rel_end;
1539 bfd_boolean use_plt_got;
1541 if (bfd_link_relocatable (info))
1544 BFD_ASSERT (is_i386_elf (abfd));
1546 htab = elf_i386_hash_table (info);
1549 sec->check_relocs_failed = 1;
1553 use_plt_got = (!get_elf_i386_backend_data (abfd)->is_vxworks
1554 && (get_elf_i386_backend_data (abfd)
1555 == &elf_i386_arch_bed));
1557 symtab_hdr = &elf_symtab_hdr (abfd);
1558 sym_hashes = elf_sym_hashes (abfd);
1562 rel_end = relocs + sec->reloc_count;
1563 for (rel = relocs; rel < rel_end; rel++)
1565 unsigned int r_type;
1566 unsigned long r_symndx;
1567 struct elf_link_hash_entry *h;
1568 struct elf_i386_link_hash_entry *eh;
1569 Elf_Internal_Sym *isym;
1571 bfd_boolean size_reloc;
1573 r_symndx = ELF32_R_SYM (rel->r_info);
1574 r_type = ELF32_R_TYPE (rel->r_info);
1576 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1578 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1584 if (r_symndx < symtab_hdr->sh_info)
1586 /* A local symbol. */
1587 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1592 /* Check relocation against local STT_GNU_IFUNC symbol. */
1593 if (ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1595 h = elf_i386_get_local_sym_hash (htab, abfd, rel, TRUE);
1599 /* Fake a STT_GNU_IFUNC symbol. */
1600 h->type = STT_GNU_IFUNC;
1603 h->forced_local = 1;
1604 h->root.type = bfd_link_hash_defined;
1612 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1613 while (h->root.type == bfd_link_hash_indirect
1614 || h->root.type == bfd_link_hash_warning)
1615 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1618 eh = (struct elf_i386_link_hash_entry *) h;
1633 if (htab->elf.dynobj == NULL)
1634 htab->elf.dynobj = abfd;
1635 /* Create the ifunc sections for static executables. */
1636 if (h->type == STT_GNU_IFUNC
1637 && !_bfd_elf_create_ifunc_sections (htab->elf.dynobj,
1643 /* It is referenced by a non-shared object. */
1645 h->root.non_ir_ref = 1;
1647 if (h->type == STT_GNU_IFUNC)
1648 elf_tdata (info->output_bfd)->has_gnu_symbols
1649 |= elf_gnu_symbol_ifunc;
1652 if (! elf_i386_tls_transition (info, abfd, sec, NULL,
1653 symtab_hdr, sym_hashes,
1654 &r_type, GOT_UNKNOWN,
1655 rel, rel_end, h, r_symndx))
1661 htab->tls_ldm_got.refcount += 1;
1665 /* This symbol requires a procedure linkage table entry. We
1666 actually build the entry in adjust_dynamic_symbol,
1667 because this might be a case of linking PIC code which is
1668 never referenced by a dynamic object, in which case we
1669 don't need to generate a procedure linkage table entry
1672 /* If this is a local symbol, we resolve it directly without
1673 creating a procedure linkage table entry. */
1677 eh->has_got_reloc = 1;
1679 h->plt.refcount += 1;
1686 case R_386_TLS_IE_32:
1688 case R_386_TLS_GOTIE:
1689 if (!bfd_link_executable (info))
1690 info->flags |= DF_STATIC_TLS;
1696 case R_386_TLS_GOTDESC:
1697 case R_386_TLS_DESC_CALL:
1698 /* This symbol requires a global offset table entry. */
1700 int tls_type, old_tls_type;
1707 tls_type = GOT_NORMAL;
1709 case R_386_TLS_GD: tls_type = GOT_TLS_GD; break;
1710 case R_386_TLS_GOTDESC:
1711 case R_386_TLS_DESC_CALL:
1712 tls_type = GOT_TLS_GDESC; break;
1713 case R_386_TLS_IE_32:
1714 if (ELF32_R_TYPE (rel->r_info) == r_type)
1715 tls_type = GOT_TLS_IE_NEG;
1717 /* If this is a GD->IE transition, we may use either of
1718 R_386_TLS_TPOFF and R_386_TLS_TPOFF32. */
1719 tls_type = GOT_TLS_IE;
1722 case R_386_TLS_GOTIE:
1723 tls_type = GOT_TLS_IE_POS; break;
1728 h->got.refcount += 1;
1729 old_tls_type = elf_i386_hash_entry(h)->tls_type;
1733 bfd_signed_vma *local_got_refcounts;
1735 /* This is a global offset table entry for a local symbol. */
1736 local_got_refcounts = elf_local_got_refcounts (abfd);
1737 if (local_got_refcounts == NULL)
1741 size = symtab_hdr->sh_info;
1742 size *= (sizeof (bfd_signed_vma)
1743 + sizeof (bfd_vma) + sizeof(char));
1744 local_got_refcounts = (bfd_signed_vma *)
1745 bfd_zalloc (abfd, size);
1746 if (local_got_refcounts == NULL)
1748 elf_local_got_refcounts (abfd) = local_got_refcounts;
1749 elf_i386_local_tlsdesc_gotent (abfd)
1750 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
1751 elf_i386_local_got_tls_type (abfd)
1752 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
1754 local_got_refcounts[r_symndx] += 1;
1755 old_tls_type = elf_i386_local_got_tls_type (abfd) [r_symndx];
1758 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1759 tls_type |= old_tls_type;
1760 /* If a TLS symbol is accessed using IE at least once,
1761 there is no point to use dynamic model for it. */
1762 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1763 && (! GOT_TLS_GD_ANY_P (old_tls_type)
1764 || (tls_type & GOT_TLS_IE) == 0))
1766 if ((old_tls_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (tls_type))
1767 tls_type = old_tls_type;
1768 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1769 && GOT_TLS_GD_ANY_P (tls_type))
1770 tls_type |= old_tls_type;
1774 name = h->root.root.string;
1776 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1778 (*_bfd_error_handler)
1779 (_("%B: `%s' accessed both as normal and "
1780 "thread local symbol"),
1782 bfd_set_error (bfd_error_bad_value);
1787 if (old_tls_type != tls_type)
1790 elf_i386_hash_entry (h)->tls_type = tls_type;
1792 elf_i386_local_got_tls_type (abfd) [r_symndx] = tls_type;
1800 if (htab->elf.sgot == NULL)
1802 if (htab->elf.dynobj == NULL)
1803 htab->elf.dynobj = abfd;
1804 if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
1807 if (r_type != R_386_TLS_IE)
1810 eh->has_got_reloc = 1;
1815 case R_386_TLS_LE_32:
1818 eh->has_got_reloc = 1;
1819 if (bfd_link_executable (info))
1821 info->flags |= DF_STATIC_TLS;
1826 if (eh != NULL && (sec->flags & SEC_CODE) != 0)
1827 eh->has_non_got_reloc = 1;
1829 /* STT_GNU_IFUNC symbol must go through PLT even if it is
1830 locally defined and undefined symbol may turn out to be
1831 a STT_GNU_IFUNC symbol later. */
1833 && (bfd_link_executable (info)
1834 || ((h->type == STT_GNU_IFUNC
1835 || h->root.type == bfd_link_hash_undefweak
1836 || h->root.type == bfd_link_hash_undefined)
1837 && SYMBOLIC_BIND (info, h))))
1839 /* If this reloc is in a read-only section, we might
1840 need a copy reloc. We can't check reliably at this
1841 stage whether the section is read-only, as input
1842 sections have not yet been mapped to output sections.
1843 Tentatively set the flag for now, and correct in
1844 adjust_dynamic_symbol. */
1847 /* We may need a .plt entry if the function this reloc
1848 refers to is in a shared lib. */
1849 h->plt.refcount += 1;
1850 if (r_type == R_386_PC32)
1852 /* Since something like ".long foo - ." may be used
1853 as pointer, make sure that PLT is used if foo is
1854 a function defined in a shared library. */
1855 if ((sec->flags & SEC_CODE) == 0)
1856 h->pointer_equality_needed = 1;
1860 h->pointer_equality_needed = 1;
1861 /* R_386_32 can be resolved at run-time. */
1862 if (r_type == R_386_32
1863 && (sec->flags & SEC_READONLY) == 0)
1864 eh->func_pointer_refcount += 1;
1870 /* If we are creating a shared library, and this is a reloc
1871 against a global symbol, or a non PC relative reloc
1872 against a local symbol, then we need to copy the reloc
1873 into the shared library. However, if we are linking with
1874 -Bsymbolic, we do not need to copy a reloc against a
1875 global symbol which is defined in an object we are
1876 including in the link (i.e., DEF_REGULAR is set). At
1877 this point we have not seen all the input files, so it is
1878 possible that DEF_REGULAR is not set now but will be set
1879 later (it is never cleared). In case of a weak definition,
1880 DEF_REGULAR may be cleared later by a strong definition in
1881 a shared library. We account for that possibility below by
1882 storing information in the relocs_copied field of the hash
1883 table entry. A similar situation occurs when creating
1884 shared libraries and symbol visibility changes render the
1887 If on the other hand, we are creating an executable, we
1888 may need to keep relocations for symbols satisfied by a
1889 dynamic library if we manage to avoid copy relocs for the
1891 if ((bfd_link_pic (info)
1892 && (sec->flags & SEC_ALLOC) != 0
1893 && (r_type != R_386_PC32
1895 && (! (bfd_link_pie (info)
1896 || SYMBOLIC_BIND (info, h))
1897 || h->root.type == bfd_link_hash_defweak
1898 || !h->def_regular))))
1899 || (ELIMINATE_COPY_RELOCS
1900 && !bfd_link_pic (info)
1901 && (sec->flags & SEC_ALLOC) != 0
1903 && (h->root.type == bfd_link_hash_defweak
1904 || !h->def_regular)))
1906 struct elf_dyn_relocs *p;
1907 struct elf_dyn_relocs **head;
1909 /* We must copy these reloc types into the output file.
1910 Create a reloc section in dynobj and make room for
1914 if (htab->elf.dynobj == NULL)
1915 htab->elf.dynobj = abfd;
1917 sreloc = _bfd_elf_make_dynamic_reloc_section
1918 (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ FALSE);
1924 /* If this is a global symbol, we count the number of
1925 relocations we need for this symbol. */
1928 head = &eh->dyn_relocs;
1932 /* Track dynamic relocs needed for local syms too.
1933 We really need local syms available to do this
1938 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1943 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1947 vpp = &elf_section_data (s)->local_dynrel;
1948 head = (struct elf_dyn_relocs **)vpp;
1952 if (p == NULL || p->sec != sec)
1954 bfd_size_type amt = sizeof *p;
1955 p = (struct elf_dyn_relocs *) bfd_alloc (htab->elf.dynobj,
1967 /* Count size relocation as PC-relative relocation. */
1968 if (r_type == R_386_PC32 || size_reloc)
1973 /* This relocation describes the C++ object vtable hierarchy.
1974 Reconstruct it for later use during GC. */
1975 case R_386_GNU_VTINHERIT:
1976 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1980 /* This relocation describes which C++ vtable entries are actually
1981 used. Record for later use during GC. */
1982 case R_386_GNU_VTENTRY:
1983 BFD_ASSERT (h != NULL);
1985 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
1995 && h->plt.refcount > 0
1996 && (((info->flags & DF_BIND_NOW) && !h->pointer_equality_needed)
1997 || h->got.refcount > 0)
1998 && htab->plt_got == NULL)
2000 /* Create the GOT procedure linkage table. */
2001 unsigned int plt_got_align;
2002 const struct elf_backend_data *bed;
2004 bed = get_elf_backend_data (info->output_bfd);
2005 BFD_ASSERT (sizeof (elf_i386_got_plt_entry) == 8
2006 && (sizeof (elf_i386_got_plt_entry)
2007 == sizeof (elf_i386_pic_got_plt_entry)));
2010 if (htab->elf.dynobj == NULL)
2011 htab->elf.dynobj = abfd;
2013 = bfd_make_section_anyway_with_flags (htab->elf.dynobj,
2015 (bed->dynamic_sec_flags
2020 if (htab->plt_got == NULL
2021 || !bfd_set_section_alignment (htab->elf.dynobj,
2027 if ((r_type == R_386_GOT32 || r_type == R_386_GOT32X)
2028 && (h == NULL || h->type != STT_GNU_IFUNC))
2029 sec->need_convert_load = 1;
2035 sec->check_relocs_failed = 1;
2039 /* Return the section that should be marked against GC for a given
2043 elf_i386_gc_mark_hook (asection *sec,
2044 struct bfd_link_info *info,
2045 Elf_Internal_Rela *rel,
2046 struct elf_link_hash_entry *h,
2047 Elf_Internal_Sym *sym)
2050 switch (ELF32_R_TYPE (rel->r_info))
2052 case R_386_GNU_VTINHERIT:
2053 case R_386_GNU_VTENTRY:
2057 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2060 /* Remove undefined weak symbol from the dynamic symbol table if it
2061 is resolved to 0. */
2064 elf_i386_fixup_symbol (struct bfd_link_info *info,
2065 struct elf_link_hash_entry *h)
2067 if (h->dynindx != -1
2068 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
2069 elf_i386_hash_entry (h)->has_got_reloc,
2070 elf_i386_hash_entry (h)))
2073 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
2079 /* Adjust a symbol defined by a dynamic object and referenced by a
2080 regular object. The current definition is in some section of the
2081 dynamic object, but we're not including those sections. We have to
2082 change the definition to something the rest of the link can
2086 elf_i386_adjust_dynamic_symbol (struct bfd_link_info *info,
2087 struct elf_link_hash_entry *h)
2089 struct elf_i386_link_hash_table *htab;
2091 struct elf_i386_link_hash_entry *eh;
2092 struct elf_dyn_relocs *p;
2094 /* STT_GNU_IFUNC symbol must go through PLT. */
2095 if (h->type == STT_GNU_IFUNC)
2097 /* All local STT_GNU_IFUNC references must be treate as local
2098 calls via local PLT. */
2100 && SYMBOL_CALLS_LOCAL (info, h))
2102 bfd_size_type pc_count = 0, count = 0;
2103 struct elf_dyn_relocs **pp;
2105 eh = (struct elf_i386_link_hash_entry *) h;
2106 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2108 pc_count += p->pc_count;
2109 p->count -= p->pc_count;
2118 if (pc_count || count)
2122 if (h->plt.refcount <= 0)
2123 h->plt.refcount = 1;
2125 h->plt.refcount += 1;
2129 if (h->plt.refcount <= 0)
2131 h->plt.offset = (bfd_vma) -1;
2137 /* If this is a function, put it in the procedure linkage table. We
2138 will fill in the contents of the procedure linkage table later,
2139 when we know the address of the .got section. */
2140 if (h->type == STT_FUNC
2143 if (h->plt.refcount <= 0
2144 || SYMBOL_CALLS_LOCAL (info, h)
2145 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2146 && h->root.type == bfd_link_hash_undefweak))
2148 /* This case can occur if we saw a PLT32 reloc in an input
2149 file, but the symbol was never referred to by a dynamic
2150 object, or if all references were garbage collected. In
2151 such a case, we don't actually need to build a procedure
2152 linkage table, and we can just do a PC32 reloc instead. */
2153 h->plt.offset = (bfd_vma) -1;
2160 /* It's possible that we incorrectly decided a .plt reloc was
2161 needed for an R_386_PC32 reloc to a non-function sym in
2162 check_relocs. We can't decide accurately between function and
2163 non-function syms in check-relocs; Objects loaded later in
2164 the link may change h->type. So fix it now. */
2165 h->plt.offset = (bfd_vma) -1;
2167 /* If this is a weak symbol, and there is a real definition, the
2168 processor independent code will have arranged for us to see the
2169 real definition first, and we can just use the same value. */
2170 if (h->u.weakdef != NULL)
2172 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2173 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2174 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2175 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2176 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
2177 h->non_got_ref = h->u.weakdef->non_got_ref;
2181 /* This is a reference to a symbol defined by a dynamic object which
2182 is not a function. */
2184 /* If we are creating a shared library, we must presume that the
2185 only references to the symbol are via the global offset table.
2186 For such cases we need not do anything here; the relocations will
2187 be handled correctly by relocate_section. */
2188 if (!bfd_link_executable (info))
2191 /* If there are no references to this symbol that do not use the
2192 GOT nor R_386_GOTOFF relocation, we don't need to generate a copy
2194 eh = (struct elf_i386_link_hash_entry *) h;
2195 if (!h->non_got_ref && !eh->gotoff_ref)
2198 /* If -z nocopyreloc was given, we won't generate them either. */
2199 if (info->nocopyreloc)
2205 htab = elf_i386_hash_table (info);
2209 /* If there aren't any dynamic relocs in read-only sections nor
2210 R_386_GOTOFF relocation, then we can keep the dynamic relocs and
2211 avoid the copy reloc. This doesn't work on VxWorks, where we can
2212 not have dynamic relocations (other than copy and jump slot
2213 relocations) in an executable. */
2214 if (ELIMINATE_COPY_RELOCS
2216 && !get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
2218 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2220 s = p->sec->output_section;
2221 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2232 /* We must allocate the symbol in our .dynbss section, which will
2233 become part of the .bss section of the executable. There will be
2234 an entry for this symbol in the .dynsym section. The dynamic
2235 object will contain position independent code, so all references
2236 from the dynamic object to this symbol will go through the global
2237 offset table. The dynamic linker will use the .dynsym entry to
2238 determine the address it must put in the global offset table, so
2239 both the dynamic object and the regular object will refer to the
2240 same memory location for the variable. */
2242 /* We must generate a R_386_COPY reloc to tell the dynamic linker to
2243 copy the initial value out of the dynamic object and into the
2244 runtime process image. */
2245 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2247 htab->srelbss->size += sizeof (Elf32_External_Rel);
2253 return _bfd_elf_adjust_dynamic_copy (info, h, s);
2256 /* Allocate space in .plt, .got and associated reloc sections for
2260 elf_i386_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
2262 struct bfd_link_info *info;
2263 struct elf_i386_link_hash_table *htab;
2264 struct elf_i386_link_hash_entry *eh;
2265 struct elf_dyn_relocs *p;
2266 unsigned plt_entry_size;
2267 bfd_boolean resolved_to_zero;
2269 if (h->root.type == bfd_link_hash_indirect)
2272 eh = (struct elf_i386_link_hash_entry *) h;
2274 info = (struct bfd_link_info *) inf;
2275 htab = elf_i386_hash_table (info);
2279 plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
2281 resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
2285 /* Clear the reference count of function pointer relocations if
2286 symbol isn't a normal function. */
2287 if (h->type != STT_FUNC)
2288 eh->func_pointer_refcount = 0;
2290 /* We can't use the GOT PLT if pointer equality is needed since
2291 finish_dynamic_symbol won't clear symbol value and the dynamic
2292 linker won't update the GOT slot. We will get into an infinite
2293 loop at run-time. */
2294 if (htab->plt_got != NULL
2295 && h->type != STT_GNU_IFUNC
2296 && !h->pointer_equality_needed
2297 && h->plt.refcount > 0
2298 && h->got.refcount > 0)
2300 /* Don't use the regular PLT if there are both GOT and GOTPLT
2302 h->plt.offset = (bfd_vma) -1;
2304 /* Use the GOT PLT. */
2305 eh->plt_got.refcount = 1;
2308 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2309 here if it is defined and referenced in a non-shared object. */
2310 if (h->type == STT_GNU_IFUNC
2312 return _bfd_elf_allocate_ifunc_dyn_relocs (info, h, &eh->dyn_relocs,
2313 &htab->readonly_dynrelocs_against_ifunc,
2316 /* Don't create the PLT entry if there are only function pointer
2317 relocations which can be resolved at run-time. */
2318 else if (htab->elf.dynamic_sections_created
2319 && (h->plt.refcount > eh->func_pointer_refcount
2320 || eh->plt_got.refcount > 0))
2322 bfd_boolean use_plt_got;
2324 /* Clear the reference count of function pointer relocations
2326 eh->func_pointer_refcount = 0;
2328 if ((info->flags & DF_BIND_NOW) && !h->pointer_equality_needed)
2330 /* Don't use the regular PLT for DF_BIND_NOW. */
2331 h->plt.offset = (bfd_vma) -1;
2333 /* Use the GOT PLT. */
2334 h->got.refcount = 1;
2335 eh->plt_got.refcount = 1;
2338 use_plt_got = eh->plt_got.refcount > 0;
2340 /* Make sure this symbol is output as a dynamic symbol.
2341 Undefined weak syms won't yet be marked as dynamic. */
2342 if (h->dynindx == -1
2344 && !resolved_to_zero)
2346 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2350 if (bfd_link_pic (info)
2351 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2353 asection *s = htab->elf.splt;
2354 asection *got_s = htab->plt_got;
2356 /* If this is the first .plt entry, make room for the special
2357 first entry. The .plt section is used by prelink to undo
2358 prelinking for dynamic relocations. */
2360 s->size = plt_entry_size;
2363 eh->plt_got.offset = got_s->size;
2365 h->plt.offset = s->size;
2367 /* If this symbol is not defined in a regular file, and we are
2368 not generating a shared library, then set the symbol to this
2369 location in the .plt. This is required to make function
2370 pointers compare as equal between the normal executable and
2371 the shared library. */
2372 if (! bfd_link_pic (info)
2377 /* We need to make a call to the entry of the GOT PLT
2378 instead of regular PLT entry. */
2379 h->root.u.def.section = got_s;
2380 h->root.u.def.value = eh->plt_got.offset;
2384 h->root.u.def.section = s;
2385 h->root.u.def.value = h->plt.offset;
2389 /* Make room for this entry. */
2391 got_s->size += sizeof (elf_i386_got_plt_entry);
2394 s->size += plt_entry_size;
2396 /* We also need to make an entry in the .got.plt section,
2397 which will be placed in the .got section by the linker
2399 htab->elf.sgotplt->size += 4;
2401 /* There should be no PLT relocation against resolved
2402 undefined weak symbol in executable. */
2403 if (!resolved_to_zero)
2405 /* We also need to make an entry in the .rel.plt
2407 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2408 htab->elf.srelplt->reloc_count++;
2412 if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks
2413 && !bfd_link_pic (info))
2415 /* VxWorks has a second set of relocations for each PLT entry
2416 in executables. They go in a separate relocation section,
2417 which is processed by the kernel loader. */
2419 /* There are two relocations for the initial PLT entry: an
2420 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 4 and an
2421 R_386_32 relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
2423 if (h->plt.offset == plt_entry_size)
2424 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2426 /* There are two extra relocations for each subsequent PLT entry:
2427 an R_386_32 relocation for the GOT entry, and an R_386_32
2428 relocation for the PLT entry. */
2430 htab->srelplt2->size += (sizeof (Elf32_External_Rel) * 2);
2435 eh->plt_got.offset = (bfd_vma) -1;
2436 h->plt.offset = (bfd_vma) -1;
2442 eh->plt_got.offset = (bfd_vma) -1;
2443 h->plt.offset = (bfd_vma) -1;
2447 eh->tlsdesc_got = (bfd_vma) -1;
2449 /* If R_386_TLS_{IE_32,IE,GOTIE} symbol is now local to the binary,
2450 make it a R_386_TLS_LE_32 requiring no TLS entry. */
2451 if (h->got.refcount > 0
2452 && bfd_link_executable (info)
2454 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE))
2455 h->got.offset = (bfd_vma) -1;
2456 else if (h->got.refcount > 0)
2460 int tls_type = elf_i386_hash_entry(h)->tls_type;
2462 /* Make sure this symbol is output as a dynamic symbol.
2463 Undefined weak syms won't yet be marked as dynamic. */
2464 if (h->dynindx == -1
2466 && !resolved_to_zero)
2468 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2473 if (GOT_TLS_GDESC_P (tls_type))
2475 eh->tlsdesc_got = htab->elf.sgotplt->size
2476 - elf_i386_compute_jump_table_size (htab);
2477 htab->elf.sgotplt->size += 8;
2478 h->got.offset = (bfd_vma) -2;
2480 if (! GOT_TLS_GDESC_P (tls_type)
2481 || GOT_TLS_GD_P (tls_type))
2483 h->got.offset = s->size;
2485 /* R_386_TLS_GD needs 2 consecutive GOT slots. */
2486 if (GOT_TLS_GD_P (tls_type) || tls_type == GOT_TLS_IE_BOTH)
2489 dyn = htab->elf.dynamic_sections_created;
2490 /* R_386_TLS_IE_32 needs one dynamic relocation,
2491 R_386_TLS_IE resp. R_386_TLS_GOTIE needs one dynamic relocation,
2492 (but if both R_386_TLS_IE_32 and R_386_TLS_IE is present, we
2493 need two), R_386_TLS_GD needs one if local symbol and two if
2494 global. No dynamic relocation against resolved undefined weak
2495 symbol in executable. */
2496 if (tls_type == GOT_TLS_IE_BOTH)
2497 htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
2498 else if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
2499 || (tls_type & GOT_TLS_IE))
2500 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2501 else if (GOT_TLS_GD_P (tls_type))
2502 htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rel);
2503 else if (! GOT_TLS_GDESC_P (tls_type)
2504 && ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2505 && !resolved_to_zero)
2506 || h->root.type != bfd_link_hash_undefweak)
2507 && (bfd_link_pic (info)
2508 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
2509 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
2510 if (GOT_TLS_GDESC_P (tls_type))
2511 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
2514 h->got.offset = (bfd_vma) -1;
2516 if (eh->dyn_relocs == NULL)
2519 /* In the shared -Bsymbolic case, discard space allocated for
2520 dynamic pc-relative relocs against symbols which turn out to be
2521 defined in regular objects. For the normal shared case, discard
2522 space for pc-relative relocs that have become local due to symbol
2523 visibility changes. */
2525 if (bfd_link_pic (info))
2527 /* The only reloc that uses pc_count is R_386_PC32, which will
2528 appear on a call or on something like ".long foo - .". We
2529 want calls to protected symbols to resolve directly to the
2530 function rather than going via the plt. If people want
2531 function pointer comparisons to work as expected then they
2532 should avoid writing assembly like ".long foo - .". */
2533 if (SYMBOL_CALLS_LOCAL (info, h))
2535 struct elf_dyn_relocs **pp;
2537 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2539 p->count -= p->pc_count;
2548 if (get_elf_i386_backend_data (info->output_bfd)->is_vxworks)
2550 struct elf_dyn_relocs **pp;
2551 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2553 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
2560 /* Also discard relocs on undefined weak syms with non-default
2561 visibility or in PIE. */
2562 if (eh->dyn_relocs != NULL
2563 && h->root.type == bfd_link_hash_undefweak)
2565 /* Undefined weak symbol is never bound locally in shared
2567 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2568 || resolved_to_zero)
2572 /* Keep dynamic non-GOT/non-PLT relocation so that we
2573 can branch to 0 without PLT. */
2574 struct elf_dyn_relocs **pp;
2576 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2577 if (p->pc_count == 0)
2581 /* Remove non-R_386_PC32 relocation. */
2582 p->count = p->pc_count;
2586 if (eh->dyn_relocs != NULL)
2588 /* Make sure undefined weak symbols are output
2589 as dynamic symbols in PIEs for dynamic non-GOT
2590 non-PLT reloations. */
2591 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2596 eh->dyn_relocs = NULL;
2598 else if (h->dynindx == -1
2599 && !h->forced_local)
2601 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2606 else if (ELIMINATE_COPY_RELOCS)
2608 /* For the non-shared case, discard space for relocs against
2609 symbols which turn out to need copy relocs or are not
2610 dynamic. Keep dynamic relocations for run-time function
2611 pointer initialization. */
2613 if ((!h->non_got_ref
2614 || eh->func_pointer_refcount > 0
2615 || (h->root.type == bfd_link_hash_undefweak
2616 && !resolved_to_zero))
2619 || (htab->elf.dynamic_sections_created
2620 && (h->root.type == bfd_link_hash_undefweak
2621 || h->root.type == bfd_link_hash_undefined))))
2623 /* Make sure this symbol is output as a dynamic symbol.
2624 Undefined weak syms won't yet be marked as dynamic. */
2625 if (h->dynindx == -1
2627 && !resolved_to_zero)
2629 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2633 /* If that succeeded, we know we'll be keeping all the
2635 if (h->dynindx != -1)
2639 eh->dyn_relocs = NULL;
2640 eh->func_pointer_refcount = 0;
2645 /* Finally, allocate space. */
2646 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2650 sreloc = elf_section_data (p->sec)->sreloc;
2652 BFD_ASSERT (sreloc != NULL);
2653 sreloc->size += p->count * sizeof (Elf32_External_Rel);
2659 /* Allocate space in .plt, .got and associated reloc sections for
2660 local dynamic relocs. */
2663 elf_i386_allocate_local_dynrelocs (void **slot, void *inf)
2665 struct elf_link_hash_entry *h
2666 = (struct elf_link_hash_entry *) *slot;
2668 if (h->type != STT_GNU_IFUNC
2672 || h->root.type != bfd_link_hash_defined)
2675 return elf_i386_allocate_dynrelocs (h, inf);
2678 /* Find any dynamic relocs that apply to read-only sections. */
2681 elf_i386_readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
2683 struct elf_i386_link_hash_entry *eh;
2684 struct elf_dyn_relocs *p;
2686 /* Skip local IFUNC symbols. */
2687 if (h->forced_local && h->type == STT_GNU_IFUNC)
2690 eh = (struct elf_i386_link_hash_entry *) h;
2691 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2693 asection *s = p->sec->output_section;
2695 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2697 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2699 info->flags |= DF_TEXTREL;
2701 if ((info->warn_shared_textrel && bfd_link_pic (info))
2702 || info->error_textrel)
2703 info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
2704 p->sec->owner, h->root.root.string,
2707 /* Not an error, just cut short the traversal. */
2714 /* With the local symbol, foo, we convert
2715 mov foo@GOT[(%reg1)], %reg2
2717 lea foo[@GOTOFF(%reg1)], %reg2
2719 call/jmp *foo@GOT[(%reg)]
2721 nop call foo/jmp foo nop
2722 When PIC is false, convert
2723 test %reg1, foo@GOT[(%reg2)]
2727 binop foo@GOT[(%reg1)], %reg2
2730 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
2734 elf_i386_convert_load (bfd *abfd, asection *sec,
2735 struct bfd_link_info *link_info)
2737 Elf_Internal_Shdr *symtab_hdr;
2738 Elf_Internal_Rela *internal_relocs;
2739 Elf_Internal_Rela *irel, *irelend;
2741 struct elf_i386_link_hash_table *htab;
2742 bfd_boolean changed_contents;
2743 bfd_boolean changed_relocs;
2745 bfd_signed_vma *local_got_refcounts;
2747 /* Don't even try to convert non-ELF outputs. */
2748 if (!is_elf_hash_table (link_info->hash))
2751 /* Nothing to do if there is no need or no output. */
2752 if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
2753 || sec->need_convert_load == 0
2754 || bfd_is_abs_section (sec->output_section))
2757 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2759 /* Load the relocations for this section. */
2760 internal_relocs = (_bfd_elf_link_read_relocs
2761 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
2762 link_info->keep_memory));
2763 if (internal_relocs == NULL)
2766 htab = elf_i386_hash_table (link_info);
2767 changed_contents = FALSE;
2768 changed_relocs = FALSE;
2769 local_got_refcounts = elf_local_got_refcounts (abfd);
2771 is_pic = bfd_link_pic (link_info);
2773 /* Get the section contents. */
2774 if (elf_section_data (sec)->this_hdr.contents != NULL)
2775 contents = elf_section_data (sec)->this_hdr.contents;
2778 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
2782 irelend = internal_relocs + sec->reloc_count;
2783 for (irel = internal_relocs; irel < irelend; irel++)
2785 unsigned int r_type = ELF32_R_TYPE (irel->r_info);
2786 unsigned int r_symndx = ELF32_R_SYM (irel->r_info);
2788 struct elf_link_hash_entry *h;
2789 unsigned int opcode;
2792 bfd_boolean baseless;
2793 Elf_Internal_Sym *isym;
2794 unsigned int addend;
2797 bfd_boolean to_reloc_32;
2799 if (r_type != R_386_GOT32 && r_type != R_386_GOT32X)
2802 roff = irel->r_offset;
2806 /* Addend for R_386_GOT32 and R_386_GOT32X relocations must be 0. */
2807 addend = bfd_get_32 (abfd, contents + roff);
2811 modrm = bfd_get_8 (abfd, contents + roff - 1);
2812 baseless = (modrm & 0xc7) == 0x5;
2814 if (r_type == R_386_GOT32X && baseless && is_pic)
2816 /* For PIC, disallow R_386_GOT32X without a base register
2817 since we don't know what the GOT base is. Allow
2818 R_386_GOT32 for existing object files. */
2821 if (r_symndx < symtab_hdr->sh_info)
2823 isym = bfd_sym_from_r_symndx (&htab->sym_cache, abfd,
2825 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
2829 indx = r_symndx - symtab_hdr->sh_info;
2830 h = elf_sym_hashes (abfd)[indx];
2831 BFD_ASSERT (h != NULL);
2832 name = h->root.root.string;
2835 (*_bfd_error_handler)
2836 (_("%B: direct GOT relocation R_386_GOT32X against `%s' without base register can not be used when making a shared object"),
2841 opcode = bfd_get_8 (abfd, contents + roff - 2);
2843 /* Convert mov to lea since it has been done for a while. */
2846 /* Only convert R_386_GOT32X relocation for call, jmp or
2847 one of adc, add, and, cmp, or, sbb, sub, test, xor
2849 if (r_type != R_386_GOT32X)
2853 /* Convert to R_386_32 if PIC is false or there is no base
2855 to_reloc_32 = !is_pic || baseless;
2857 /* Try to convert R_386_GOT32 and R_386_GOT32X. Get the symbol
2858 referred to by the reloc. */
2859 if (r_symndx < symtab_hdr->sh_info)
2861 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2864 /* STT_GNU_IFUNC must keep GOT32 relocations. */
2865 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
2869 if (opcode == 0x0ff)
2870 /* Convert "call/jmp *foo@GOT[(%reg)]". */
2871 goto convert_branch;
2873 /* Convert "mov foo@GOT[(%reg1)], %reg2",
2874 "test %reg1, foo@GOT(%reg2)" and
2875 "binop foo@GOT[(%reg1)], %reg2". */
2879 indx = r_symndx - symtab_hdr->sh_info;
2880 h = elf_sym_hashes (abfd)[indx];
2881 BFD_ASSERT (h != NULL);
2883 while (h->root.type == bfd_link_hash_indirect
2884 || h->root.type == bfd_link_hash_warning)
2885 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2887 /* STT_GNU_IFUNC must keep GOT32 relocations. */
2888 if (h->type == STT_GNU_IFUNC)
2891 /* Undefined weak symbol is only bound locally in executable
2892 and its reference is resolved as 0. */
2893 if (UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info, TRUE,
2894 elf_i386_hash_entry (h)))
2898 /* No direct branch to 0 for PIC. */
2902 goto convert_branch;
2906 /* We can convert load of address 0 to R_386_32. */
2914 /* We have "call/jmp *foo@GOT[(%reg)]". */
2915 if ((h->root.type == bfd_link_hash_defined
2916 || h->root.type == bfd_link_hash_defweak)
2917 && SYMBOL_REFERENCES_LOCAL (link_info, h))
2919 /* The function is locally defined. */
2921 /* Convert R_386_GOT32X to R_386_PC32. */
2922 if (modrm == 0x15 || (modrm & 0xf8) == 0x90)
2924 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
2927 nop = link_info->call_nop_byte;
2928 if (link_info->call_nop_as_suffix)
2930 nop_offset = roff + 3;
2931 irel->r_offset -= 1;
2934 nop_offset = roff - 2;
2938 /* Convert to "jmp foo nop". */
2941 nop_offset = roff + 3;
2942 irel->r_offset -= 1;
2945 bfd_put_8 (abfd, nop, contents + nop_offset);
2946 bfd_put_8 (abfd, modrm, contents + irel->r_offset - 1);
2947 /* When converting to PC-relative relocation, we
2948 need to adjust addend by -4. */
2949 bfd_put_32 (abfd, -4, contents + irel->r_offset);
2950 irel->r_info = ELF32_R_INFO (r_symndx, R_386_PC32);
2954 if (h->got.refcount > 0)
2955 h->got.refcount -= 1;
2959 if (local_got_refcounts != NULL
2960 && local_got_refcounts[r_symndx] > 0)
2961 local_got_refcounts[r_symndx] -= 1;
2964 changed_contents = TRUE;
2965 changed_relocs = TRUE;
2970 /* We have "mov foo@GOT[(%re1g)], %reg2",
2971 "test %reg1, foo@GOT(%reg2)" and
2972 "binop foo@GOT[(%reg1)], %reg2".
2974 Avoid optimizing _DYNAMIC since ld.so may use its
2975 link-time address. */
2976 if (h == htab->elf.hdynamic)
2979 /* def_regular is set by an assignment in a linker script in
2980 bfd_elf_record_link_assignment. */
2982 || h->root.type == bfd_link_hash_defined
2983 || h->root.type == bfd_link_hash_defweak)
2984 && SYMBOL_REFERENCES_LOCAL (link_info, h))
2991 /* Convert "mov foo@GOT[(%reg1)], %reg2" to
2992 "mov $foo, %reg2" with R_386_32. */
2994 modrm = 0xc0 | (modrm & 0x38) >> 3;
2995 bfd_put_8 (abfd, modrm, contents + roff - 1);
3000 /* Convert "mov foo@GOT(%reg1), %reg2" to
3001 "lea foo@GOTOFF(%reg1), %reg2". */
3002 r_type = R_386_GOTOFF;
3008 /* Only R_386_32 is supported. */
3014 /* Convert "test %reg1, foo@GOT(%reg2)" to
3015 "test $foo, %reg1". */
3016 modrm = 0xc0 | (modrm & 0x38) >> 3;
3021 /* Convert "binop foo@GOT(%reg1), %reg2" to
3022 "binop $foo, %reg2". */
3024 | (modrm & 0x38) >> 3
3028 bfd_put_8 (abfd, modrm, contents + roff - 1);
3032 bfd_put_8 (abfd, opcode, contents + roff - 2);
3033 irel->r_info = ELF32_R_INFO (r_symndx, r_type);
3037 if (h->got.refcount > 0)
3038 h->got.refcount -= 1;
3042 if (local_got_refcounts != NULL
3043 && local_got_refcounts[r_symndx] > 0)
3044 local_got_refcounts[r_symndx] -= 1;
3047 changed_contents = TRUE;
3048 changed_relocs = TRUE;
3053 if (contents != NULL
3054 && elf_section_data (sec)->this_hdr.contents != contents)
3056 if (!changed_contents && !link_info->keep_memory)
3060 /* Cache the section contents for elf_link_input_bfd. */
3061 elf_section_data (sec)->this_hdr.contents = contents;
3065 if (elf_section_data (sec)->relocs != internal_relocs)
3067 if (!changed_relocs)
3068 free (internal_relocs);
3070 elf_section_data (sec)->relocs = internal_relocs;
3076 if (contents != NULL
3077 && elf_section_data (sec)->this_hdr.contents != contents)
3079 if (internal_relocs != NULL
3080 && elf_section_data (sec)->relocs != internal_relocs)
3081 free (internal_relocs);
3085 /* Set the sizes of the dynamic sections. */
3088 elf_i386_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
3090 struct elf_i386_link_hash_table *htab;
3096 htab = elf_i386_hash_table (info);
3099 dynobj = htab->elf.dynobj;
3103 /* Set up .got offsets for local syms, and space for local dynamic
3105 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3107 bfd_signed_vma *local_got;
3108 bfd_signed_vma *end_local_got;
3109 char *local_tls_type;
3110 bfd_vma *local_tlsdesc_gotent;
3111 bfd_size_type locsymcount;
3112 Elf_Internal_Shdr *symtab_hdr;
3115 if (! is_i386_elf (ibfd))
3118 for (s = ibfd->sections; s != NULL; s = s->next)
3120 struct elf_dyn_relocs *p;
3122 if (!elf_i386_convert_load (ibfd, s, info))
3125 for (p = ((struct elf_dyn_relocs *)
3126 elf_section_data (s)->local_dynrel);
3130 if (!bfd_is_abs_section (p->sec)
3131 && bfd_is_abs_section (p->sec->output_section))
3133 /* Input section has been discarded, either because
3134 it is a copy of a linkonce section or due to
3135 linker script /DISCARD/, so we'll be discarding
3138 else if (get_elf_i386_backend_data (output_bfd)->is_vxworks
3139 && strcmp (p->sec->output_section->name,
3142 /* Relocations in vxworks .tls_vars sections are
3143 handled specially by the loader. */
3145 else if (p->count != 0)
3147 srel = elf_section_data (p->sec)->sreloc;
3148 srel->size += p->count * sizeof (Elf32_External_Rel);
3149 if ((p->sec->output_section->flags & SEC_READONLY) != 0
3150 && (info->flags & DF_TEXTREL) == 0)
3152 info->flags |= DF_TEXTREL;
3153 if ((info->warn_shared_textrel && bfd_link_pic (info))
3154 || info->error_textrel)
3155 info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3156 p->sec->owner, p->sec);
3162 local_got = elf_local_got_refcounts (ibfd);
3166 symtab_hdr = &elf_symtab_hdr (ibfd);
3167 locsymcount = symtab_hdr->sh_info;
3168 end_local_got = local_got + locsymcount;
3169 local_tls_type = elf_i386_local_got_tls_type (ibfd);
3170 local_tlsdesc_gotent = elf_i386_local_tlsdesc_gotent (ibfd);
3172 srel = htab->elf.srelgot;
3173 for (; local_got < end_local_got;
3174 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
3176 *local_tlsdesc_gotent = (bfd_vma) -1;
3179 if (GOT_TLS_GDESC_P (*local_tls_type))
3181 *local_tlsdesc_gotent = htab->elf.sgotplt->size
3182 - elf_i386_compute_jump_table_size (htab);
3183 htab->elf.sgotplt->size += 8;
3184 *local_got = (bfd_vma) -2;
3186 if (! GOT_TLS_GDESC_P (*local_tls_type)
3187 || GOT_TLS_GD_P (*local_tls_type))
3189 *local_got = s->size;
3191 if (GOT_TLS_GD_P (*local_tls_type)
3192 || *local_tls_type == GOT_TLS_IE_BOTH)
3195 if (bfd_link_pic (info)
3196 || GOT_TLS_GD_ANY_P (*local_tls_type)
3197 || (*local_tls_type & GOT_TLS_IE))
3199 if (*local_tls_type == GOT_TLS_IE_BOTH)
3200 srel->size += 2 * sizeof (Elf32_External_Rel);
3201 else if (GOT_TLS_GD_P (*local_tls_type)
3202 || ! GOT_TLS_GDESC_P (*local_tls_type))
3203 srel->size += sizeof (Elf32_External_Rel);
3204 if (GOT_TLS_GDESC_P (*local_tls_type))
3205 htab->elf.srelplt->size += sizeof (Elf32_External_Rel);
3209 *local_got = (bfd_vma) -1;
3213 if (htab->tls_ldm_got.refcount > 0)
3215 /* Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
3217 htab->tls_ldm_got.offset = htab->elf.sgot->size;
3218 htab->elf.sgot->size += 8;
3219 htab->elf.srelgot->size += sizeof (Elf32_External_Rel);
3222 htab->tls_ldm_got.offset = -1;
3224 /* Allocate global sym .plt and .got entries, and space for global
3225 sym dynamic relocs. */
3226 elf_link_hash_traverse (&htab->elf, elf_i386_allocate_dynrelocs, info);
3228 /* Allocate .plt and .got entries, and space for local symbols. */
3229 htab_traverse (htab->loc_hash_table,
3230 elf_i386_allocate_local_dynrelocs,
3233 /* For every jump slot reserved in the sgotplt, reloc_count is
3234 incremented. However, when we reserve space for TLS descriptors,
3235 it's not incremented, so in order to compute the space reserved
3236 for them, it suffices to multiply the reloc count by the jump
3239 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3240 so that R_386_IRELATIVE entries come last. */
3241 if (htab->elf.srelplt)
3243 htab->next_tls_desc_index = htab->elf.srelplt->reloc_count;
3244 htab->sgotplt_jump_table_size = htab->next_tls_desc_index * 4;
3245 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
3247 else if (htab->elf.irelplt)
3248 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
3251 if (htab->elf.sgotplt)
3253 /* Don't allocate .got.plt section if there are no GOT nor PLT
3254 entries and there is no reference to _GLOBAL_OFFSET_TABLE_. */
3255 if ((htab->elf.hgot == NULL
3256 || !htab->elf.hgot->ref_regular_nonweak)
3257 && (htab->elf.sgotplt->size
3258 == get_elf_backend_data (output_bfd)->got_header_size)
3259 && (htab->elf.splt == NULL
3260 || htab->elf.splt->size == 0)
3261 && (htab->elf.sgot == NULL
3262 || htab->elf.sgot->size == 0)
3263 && (htab->elf.iplt == NULL
3264 || htab->elf.iplt->size == 0)
3265 && (htab->elf.igotplt == NULL
3266 || htab->elf.igotplt->size == 0))
3267 htab->elf.sgotplt->size = 0;
3271 if (htab->plt_eh_frame != NULL
3272 && htab->elf.splt != NULL
3273 && htab->elf.splt->size != 0
3274 && !bfd_is_abs_section (htab->elf.splt->output_section)
3275 && _bfd_elf_eh_frame_present (info))
3276 htab->plt_eh_frame->size = sizeof (elf_i386_eh_frame_plt);
3278 /* We now have determined the sizes of the various dynamic sections.
3279 Allocate memory for them. */
3281 for (s = dynobj->sections; s != NULL; s = s->next)
3283 bfd_boolean strip_section = TRUE;
3285 if ((s->flags & SEC_LINKER_CREATED) == 0)
3288 if (s == htab->elf.splt
3289 || s == htab->elf.sgot)
3291 /* Strip this section if we don't need it; see the
3293 /* We'd like to strip these sections if they aren't needed, but if
3294 we've exported dynamic symbols from them we must leave them.
3295 It's too late to tell BFD to get rid of the symbols. */
3297 if (htab->elf.hplt != NULL)
3298 strip_section = FALSE;
3300 else if (s == htab->elf.sgotplt
3301 || s == htab->elf.iplt
3302 || s == htab->elf.igotplt
3303 || s == htab->plt_got
3304 || s == htab->plt_eh_frame
3305 || s == htab->sdynbss)
3307 /* Strip these too. */
3309 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rel"))
3312 && s != htab->elf.srelplt
3313 && s != htab->srelplt2)
3316 /* We use the reloc_count field as a counter if we need
3317 to copy relocs into the output file. */
3322 /* It's not one of our sections, so don't allocate space. */
3328 /* If we don't need this section, strip it from the
3329 output file. This is mostly to handle .rel.bss and
3330 .rel.plt. We must create both sections in
3331 create_dynamic_sections, because they must be created
3332 before the linker maps input sections to output
3333 sections. The linker does that before
3334 adjust_dynamic_symbol is called, and it is that
3335 function which decides whether anything needs to go
3336 into these sections. */
3338 s->flags |= SEC_EXCLUDE;
3342 if ((s->flags & SEC_HAS_CONTENTS) == 0)
3345 /* Allocate memory for the section contents. We use bfd_zalloc
3346 here in case unused entries are not reclaimed before the
3347 section's contents are written out. This should not happen,
3348 but this way if it does, we get a R_386_NONE reloc instead
3350 s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
3351 if (s->contents == NULL)
3355 if (htab->plt_eh_frame != NULL
3356 && htab->plt_eh_frame->contents != NULL)
3358 memcpy (htab->plt_eh_frame->contents, elf_i386_eh_frame_plt,
3359 sizeof (elf_i386_eh_frame_plt));
3360 bfd_put_32 (dynobj, htab->elf.splt->size,
3361 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
3364 if (htab->elf.dynamic_sections_created)
3366 /* Add some entries to the .dynamic section. We fill in the
3367 values later, in elf_i386_finish_dynamic_sections, but we
3368 must add the entries now so that we get the correct size for
3369 the .dynamic section. The DT_DEBUG entry is filled in by the
3370 dynamic linker and used by the debugger. */
3371 #define add_dynamic_entry(TAG, VAL) \
3372 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3374 if (bfd_link_executable (info))
3376 if (!add_dynamic_entry (DT_DEBUG, 0))
3380 if (htab->elf.splt->size != 0)
3382 /* DT_PLTGOT is used by prelink even if there is no PLT
3384 if (!add_dynamic_entry (DT_PLTGOT, 0))
3387 if (htab->elf.srelplt->size != 0)
3389 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3390 || !add_dynamic_entry (DT_PLTREL, DT_REL)
3391 || !add_dynamic_entry (DT_JMPREL, 0))
3398 if (!add_dynamic_entry (DT_REL, 0)
3399 || !add_dynamic_entry (DT_RELSZ, 0)
3400 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
3403 /* If any dynamic relocs apply to a read-only section,
3404 then we need a DT_TEXTREL entry. */
3405 if ((info->flags & DF_TEXTREL) == 0)
3406 elf_link_hash_traverse (&htab->elf,
3407 elf_i386_readonly_dynrelocs, info);
3409 if ((info->flags & DF_TEXTREL) != 0)
3411 if (htab->readonly_dynrelocs_against_ifunc)
3413 info->callbacks->einfo
3414 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3415 bfd_set_error (bfd_error_bad_value);
3419 if (!add_dynamic_entry (DT_TEXTREL, 0))
3423 if (get_elf_i386_backend_data (output_bfd)->is_vxworks
3424 && !elf_vxworks_add_dynamic_entries (output_bfd, info))
3427 #undef add_dynamic_entry
3433 elf_i386_always_size_sections (bfd *output_bfd,
3434 struct bfd_link_info *info)
3436 asection *tls_sec = elf_hash_table (info)->tls_sec;
3440 struct elf_link_hash_entry *tlsbase;
3442 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
3443 "_TLS_MODULE_BASE_",
3444 FALSE, FALSE, FALSE);
3446 if (tlsbase && tlsbase->type == STT_TLS)
3448 struct elf_i386_link_hash_table *htab;
3449 struct bfd_link_hash_entry *bh = NULL;
3450 const struct elf_backend_data *bed
3451 = get_elf_backend_data (output_bfd);
3453 htab = elf_i386_hash_table (info);
3457 if (!(_bfd_generic_link_add_one_symbol
3458 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
3459 tls_sec, 0, NULL, FALSE,
3460 bed->collect, &bh)))
3463 htab->tls_module_base = bh;
3465 tlsbase = (struct elf_link_hash_entry *)bh;
3466 tlsbase->def_regular = 1;
3467 tlsbase->other = STV_HIDDEN;
3468 tlsbase->root.linker_def = 1;
3469 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
3476 /* Set the correct type for an x86 ELF section. We do this by the
3477 section name, which is a hack, but ought to work. */
3480 elf_i386_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
3481 Elf_Internal_Shdr *hdr,
3486 name = bfd_get_section_name (abfd, sec);
3488 /* This is an ugly, but unfortunately necessary hack that is
3489 needed when producing EFI binaries on x86. It tells
3490 elf.c:elf_fake_sections() not to consider ".reloc" as a section
3491 containing ELF relocation info. We need this hack in order to
3492 be able to generate ELF binaries that can be translated into
3493 EFI applications (which are essentially COFF objects). Those
3494 files contain a COFF ".reloc" section inside an ELFNN object,
3495 which would normally cause BFD to segfault because it would
3496 attempt to interpret this section as containing relocation
3497 entries for section "oc". With this hack enabled, ".reloc"
3498 will be treated as a normal data section, which will avoid the
3499 segfault. However, you won't be able to create an ELFNN binary
3500 with a section named "oc" that needs relocations, but that's
3501 the kind of ugly side-effects you get when detecting section
3502 types based on their names... In practice, this limitation is
3503 unlikely to bite. */
3504 if (strcmp (name, ".reloc") == 0)
3505 hdr->sh_type = SHT_PROGBITS;
3510 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3511 executables. Rather than setting it to the beginning of the TLS
3512 section, we have to set it to the end. This function may be called
3513 multiple times, it is idempotent. */
3516 elf_i386_set_tls_module_base (struct bfd_link_info *info)
3518 struct elf_i386_link_hash_table *htab;
3519 struct bfd_link_hash_entry *base;
3521 if (!bfd_link_executable (info))
3524 htab = elf_i386_hash_table (info);
3528 base = htab->tls_module_base;
3532 base->u.def.value = htab->elf.tls_size;
3535 /* Return the base VMA address which should be subtracted from real addresses
3536 when resolving @dtpoff relocation.
3537 This is PT_TLS segment p_vaddr. */
3540 elf_i386_dtpoff_base (struct bfd_link_info *info)
3542 /* If tls_sec is NULL, we should have signalled an error already. */
3543 if (elf_hash_table (info)->tls_sec == NULL)
3545 return elf_hash_table (info)->tls_sec->vma;
3548 /* Return the relocation value for @tpoff relocation
3549 if STT_TLS virtual address is ADDRESS. */
3552 elf_i386_tpoff (struct bfd_link_info *info, bfd_vma address)
3554 struct elf_link_hash_table *htab = elf_hash_table (info);
3555 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3556 bfd_vma static_tls_size;
3558 /* If tls_sec is NULL, we should have signalled an error already. */
3559 if (htab->tls_sec == NULL)
3562 /* Consider special static TLS alignment requirements. */
3563 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3564 return static_tls_size + htab->tls_sec->vma - address;
3567 /* Relocate an i386 ELF section. */
3570 elf_i386_relocate_section (bfd *output_bfd,
3571 struct bfd_link_info *info,
3573 asection *input_section,
3575 Elf_Internal_Rela *relocs,
3576 Elf_Internal_Sym *local_syms,
3577 asection **local_sections)
3579 struct elf_i386_link_hash_table *htab;
3580 Elf_Internal_Shdr *symtab_hdr;
3581 struct elf_link_hash_entry **sym_hashes;
3582 bfd_vma *local_got_offsets;
3583 bfd_vma *local_tlsdesc_gotents;
3584 Elf_Internal_Rela *rel;
3585 Elf_Internal_Rela *wrel;
3586 Elf_Internal_Rela *relend;
3587 bfd_boolean is_vxworks_tls;
3588 unsigned plt_entry_size;
3590 BFD_ASSERT (is_i386_elf (input_bfd));
3592 /* Skip if check_relocs failed. */
3593 if (input_section->check_relocs_failed)
3596 htab = elf_i386_hash_table (info);
3599 symtab_hdr = &elf_symtab_hdr (input_bfd);
3600 sym_hashes = elf_sym_hashes (input_bfd);
3601 local_got_offsets = elf_local_got_offsets (input_bfd);
3602 local_tlsdesc_gotents = elf_i386_local_tlsdesc_gotent (input_bfd);
3603 /* We have to handle relocations in vxworks .tls_vars sections
3604 specially, because the dynamic loader is 'weird'. */
3605 is_vxworks_tls = (get_elf_i386_backend_data (output_bfd)->is_vxworks
3606 && bfd_link_pic (info)
3607 && !strcmp (input_section->output_section->name,
3610 elf_i386_set_tls_module_base (info);
3612 plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
3614 rel = wrel = relocs;
3615 relend = relocs + input_section->reloc_count;
3616 for (; rel < relend; wrel++, rel++)
3618 unsigned int r_type;
3619 reloc_howto_type *howto;
3620 unsigned long r_symndx;
3621 struct elf_link_hash_entry *h;
3622 struct elf_i386_link_hash_entry *eh;
3623 Elf_Internal_Sym *sym;
3625 bfd_vma off, offplt, plt_offset;
3627 bfd_boolean unresolved_reloc;
3628 bfd_reloc_status_type r;
3632 asection *resolved_plt;
3633 bfd_boolean resolved_to_zero;
3635 r_type = ELF32_R_TYPE (rel->r_info);
3636 if (r_type == R_386_GNU_VTINHERIT
3637 || r_type == R_386_GNU_VTENTRY)
3644 if ((indx = r_type) >= R_386_standard
3645 && ((indx = r_type - R_386_ext_offset) - R_386_standard
3646 >= R_386_ext - R_386_standard)
3647 && ((indx = r_type - R_386_tls_offset) - R_386_ext
3648 >= R_386_ext2 - R_386_ext))
3650 (*_bfd_error_handler)
3651 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3652 input_bfd, input_section, r_type);
3653 bfd_set_error (bfd_error_bad_value);
3656 howto = elf_howto_table + indx;
3658 r_symndx = ELF32_R_SYM (rel->r_info);
3662 unresolved_reloc = FALSE;
3663 if (r_symndx < symtab_hdr->sh_info)
3665 sym = local_syms + r_symndx;
3666 sec = local_sections[r_symndx];
3667 relocation = (sec->output_section->vma
3668 + sec->output_offset
3670 st_size = sym->st_size;
3672 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
3673 && ((sec->flags & SEC_MERGE) != 0
3674 || (bfd_link_relocatable (info)
3675 && sec->output_offset != 0)))
3678 bfd_byte *where = contents + rel->r_offset;
3680 switch (howto->size)
3683 addend = bfd_get_8 (input_bfd, where);
3684 if (howto->pc_relative)
3686 addend = (addend ^ 0x80) - 0x80;
3691 addend = bfd_get_16 (input_bfd, where);
3692 if (howto->pc_relative)
3694 addend = (addend ^ 0x8000) - 0x8000;
3699 addend = bfd_get_32 (input_bfd, where);
3700 if (howto->pc_relative)
3702 addend = (addend ^ 0x80000000) - 0x80000000;
3710 if (bfd_link_relocatable (info))
3711 addend += sec->output_offset;
3714 asection *msec = sec;
3715 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
3717 addend -= relocation;
3718 addend += msec->output_section->vma + msec->output_offset;
3721 switch (howto->size)
3724 /* FIXME: overflow checks. */
3725 if (howto->pc_relative)
3727 bfd_put_8 (input_bfd, addend, where);
3730 if (howto->pc_relative)
3732 bfd_put_16 (input_bfd, addend, where);
3735 if (howto->pc_relative)
3737 bfd_put_32 (input_bfd, addend, where);
3741 else if (!bfd_link_relocatable (info)
3742 && ELF32_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3744 /* Relocate against local STT_GNU_IFUNC symbol. */
3745 h = elf_i386_get_local_sym_hash (htab, input_bfd, rel,
3750 /* Set STT_GNU_IFUNC symbol value. */
3751 h->root.u.def.value = sym->st_value;
3752 h->root.u.def.section = sec;
3757 bfd_boolean warned ATTRIBUTE_UNUSED;
3758 bfd_boolean ignored ATTRIBUTE_UNUSED;
3760 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3761 r_symndx, symtab_hdr, sym_hashes,
3763 unresolved_reloc, warned, ignored);
3767 if (sec != NULL && discarded_section (sec))
3769 _bfd_clear_contents (howto, input_bfd, input_section,
3770 contents + rel->r_offset);
3771 wrel->r_offset = rel->r_offset;
3775 /* For ld -r, remove relocations in debug sections against
3776 sections defined in discarded sections. Not done for
3777 eh_frame editing code expects to be present. */
3778 if (bfd_link_relocatable (info)
3779 && (input_section->flags & SEC_DEBUGGING))
3785 if (bfd_link_relocatable (info))
3792 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3793 it here if it is defined in a non-shared object. */
3795 && h->type == STT_GNU_IFUNC
3798 asection *plt, *gotplt, *base_got;
3802 if ((input_section->flags & SEC_ALLOC) == 0)
3804 /* Dynamic relocs are not propagated for SEC_DEBUGGING
3805 sections because such sections are not SEC_ALLOC and
3806 thus ld.so will not process them. */
3807 if ((input_section->flags & SEC_DEBUGGING) != 0)
3811 else if (h->plt.offset == (bfd_vma) -1)
3814 /* STT_GNU_IFUNC symbol must go through PLT. */
3815 if (htab->elf.splt != NULL)
3817 plt = htab->elf.splt;
3818 gotplt = htab->elf.sgotplt;
3822 plt = htab->elf.iplt;
3823 gotplt = htab->elf.igotplt;
3826 relocation = (plt->output_section->vma
3827 + plt->output_offset + h->plt.offset);
3832 if (h->root.root.string)
3833 name = h->root.root.string;
3835 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3837 (*_bfd_error_handler)
3838 (_("%B: relocation %s against STT_GNU_IFUNC "
3839 "symbol `%s' isn't handled by %s"), input_bfd,
3840 elf_howto_table[r_type].name,
3841 name, __FUNCTION__);
3842 bfd_set_error (bfd_error_bad_value);
3846 /* Generate dynamic relcoation only when there is a
3847 non-GOT reference in a shared object. */
3848 if (bfd_link_pic (info) && h->non_got_ref)
3850 Elf_Internal_Rela outrel;
3854 /* Need a dynamic relocation to get the real function
3856 offset = _bfd_elf_section_offset (output_bfd,
3860 if (offset == (bfd_vma) -1
3861 || offset == (bfd_vma) -2)
3864 outrel.r_offset = (input_section->output_section->vma
3865 + input_section->output_offset
3868 if (h->dynindx == -1
3870 || bfd_link_executable (info))
3872 /* This symbol is resolved locally. */
3873 outrel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
3874 bfd_put_32 (output_bfd,
3875 (h->root.u.def.value
3876 + h->root.u.def.section->output_section->vma
3877 + h->root.u.def.section->output_offset),
3881 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3883 sreloc = htab->elf.irelifunc;
3884 elf_append_rel (output_bfd, sreloc, &outrel);
3886 /* If this reloc is against an external symbol, we
3887 do not want to fiddle with the addend. Otherwise,
3888 we need to include the symbol value so that it
3889 becomes an addend for the dynamic reloc. For an
3890 internal symbol, we have updated addend. */
3900 base_got = htab->elf.sgot;
3901 off = h->got.offset;
3903 if (base_got == NULL)
3906 if (off == (bfd_vma) -1)
3908 /* We can't use h->got.offset here to save state, or
3909 even just remember the offset, as finish_dynamic_symbol
3910 would use that as offset into .got. */
3912 if (htab->elf.splt != NULL)
3914 plt_index = h->plt.offset / plt_entry_size - 1;
3915 off = (plt_index + 3) * 4;
3916 base_got = htab->elf.sgotplt;
3920 plt_index = h->plt.offset / plt_entry_size;
3921 off = plt_index * 4;
3922 base_got = htab->elf.igotplt;
3925 if (h->dynindx == -1
3929 /* This references the local defitionion. We must
3930 initialize this entry in the global offset table.
3931 Since the offset must always be a multiple of 8,
3932 we use the least significant bit to record
3933 whether we have initialized it already.
3935 When doing a dynamic link, we create a .rela.got
3936 relocation entry to initialize the value. This
3937 is done in the finish_dynamic_symbol routine. */
3942 bfd_put_32 (output_bfd, relocation,
3943 base_got->contents + off);
3950 /* Adjust for static executables. */
3951 if (htab->elf.splt == NULL)
3952 relocation += gotplt->output_offset;
3956 relocation = (base_got->output_section->vma
3957 + base_got->output_offset + off
3958 - gotplt->output_section->vma
3959 - gotplt->output_offset);
3960 /* Adjust for static executables. */
3961 if (htab->elf.splt == NULL)
3962 relocation += gotplt->output_offset;
3968 relocation -= (gotplt->output_section->vma
3969 + gotplt->output_offset);
3974 eh = (struct elf_i386_link_hash_entry *) h;
3975 resolved_to_zero = (eh != NULL
3976 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
3983 /* Avoid optimizing _DYNAMIC since ld.so may use its
3984 link-time address. */
3985 if (h == htab->elf.hdynamic)
3988 if (bfd_link_pic (info))
3990 /* It is OK to convert mov to lea and convert indirect
3991 branch to direct branch. It is OK to convert adc,
3992 add, and, cmp, or, sbb, sub, test, xor only when PIC
3994 unsigned int opcode, addend;
3995 addend = bfd_get_32 (input_bfd, contents + rel->r_offset);
3998 opcode = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
3999 if (opcode != 0x8b && opcode != 0xff)
4003 /* Resolve "mov GOT[(%reg)], %reg",
4004 "call/jmp *GOT[(%reg)]", "test %reg, foo@GOT[(%reg)]"
4005 and "binop foo@GOT[(%reg)], %reg". */
4007 || (h->plt.offset == (bfd_vma) -1
4008 && h->got.offset == (bfd_vma) -1)
4009 || htab->elf.sgotplt == NULL)
4012 offplt = (htab->elf.sgotplt->output_section->vma
4013 + htab->elf.sgotplt->output_offset);
4015 /* It is relative to .got.plt section. */
4016 if (h->got.offset != (bfd_vma) -1)
4017 /* Use GOT entry. Mask off the least significant bit in
4018 GOT offset which may be set by R_386_GOT32 processing
4020 relocation = (htab->elf.sgot->output_section->vma
4021 + htab->elf.sgot->output_offset
4022 + (h->got.offset & ~1) - offplt);
4024 /* Use GOTPLT entry. */
4025 relocation = (h->plt.offset / plt_entry_size - 1 + 3) * 4;
4027 if (!bfd_link_pic (info))
4029 /* If not PIC, add the .got.plt section address for
4030 baseless addressing. */
4032 modrm = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4033 if ((modrm & 0xc7) == 0x5)
4034 relocation += offplt;
4037 unresolved_reloc = FALSE;
4042 /* Relocation is to the entry for this symbol in the global
4044 if (htab->elf.sgot == NULL)
4051 off = h->got.offset;
4052 dyn = htab->elf.dynamic_sections_created;
4053 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4054 bfd_link_pic (info),
4056 || (bfd_link_pic (info)
4057 && SYMBOL_REFERENCES_LOCAL (info, h))
4058 || (ELF_ST_VISIBILITY (h->other)
4059 && h->root.type == bfd_link_hash_undefweak))
4061 /* This is actually a static link, or it is a
4062 -Bsymbolic link and the symbol is defined
4063 locally, or the symbol was forced to be local
4064 because of a version file. We must initialize
4065 this entry in the global offset table. Since the
4066 offset must always be a multiple of 4, we use the
4067 least significant bit to record whether we have
4068 initialized it already.
4070 When doing a dynamic link, we create a .rel.got
4071 relocation entry to initialize the value. This
4072 is done in the finish_dynamic_symbol routine. */
4077 bfd_put_32 (output_bfd, relocation,
4078 htab->elf.sgot->contents + off);
4083 unresolved_reloc = FALSE;
4087 if (local_got_offsets == NULL)
4090 off = local_got_offsets[r_symndx];
4092 /* The offset must always be a multiple of 4. We use
4093 the least significant bit to record whether we have
4094 already generated the necessary reloc. */
4099 bfd_put_32 (output_bfd, relocation,
4100 htab->elf.sgot->contents + off);
4102 if (bfd_link_pic (info))
4105 Elf_Internal_Rela outrel;
4107 s = htab->elf.srelgot;
4111 outrel.r_offset = (htab->elf.sgot->output_section->vma
4112 + htab->elf.sgot->output_offset
4114 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4115 elf_append_rel (output_bfd, s, &outrel);
4118 local_got_offsets[r_symndx] |= 1;
4122 if (off >= (bfd_vma) -2)
4125 relocation = htab->elf.sgot->output_section->vma
4126 + htab->elf.sgot->output_offset + off
4127 - htab->elf.sgotplt->output_section->vma
4128 - htab->elf.sgotplt->output_offset;
4132 /* Relocation is relative to the start of the global offset
4135 /* Check to make sure it isn't a protected function or data
4136 symbol for shared library since it may not be local when
4137 used as function address or with copy relocation. We also
4138 need to make sure that a symbol is referenced locally. */
4139 if (!bfd_link_executable (info) && h)
4141 if (!h->def_regular)
4145 switch (ELF_ST_VISIBILITY (h->other))
4148 v = _("hidden symbol");
4151 v = _("internal symbol");
4154 v = _("protected symbol");
4161 (*_bfd_error_handler)
4162 (_("%B: relocation R_386_GOTOFF against undefined %s `%s' can not be used when making a shared object"),
4163 input_bfd, v, h->root.root.string);
4164 bfd_set_error (bfd_error_bad_value);
4167 else if (!SYMBOL_REFERENCES_LOCAL (info, h)
4168 && (h->type == STT_FUNC
4169 || h->type == STT_OBJECT)
4170 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
4172 (*_bfd_error_handler)
4173 (_("%B: relocation R_386_GOTOFF against protected %s `%s' can not be used when making a shared object"),
4175 h->type == STT_FUNC ? "function" : "data",
4176 h->root.root.string);
4177 bfd_set_error (bfd_error_bad_value);
4182 /* Note that sgot is not involved in this
4183 calculation. We always want the start of .got.plt. If we
4184 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4185 permitted by the ABI, we might have to change this
4187 relocation -= htab->elf.sgotplt->output_section->vma
4188 + htab->elf.sgotplt->output_offset;
4192 /* Use global offset table as symbol value. */
4193 relocation = htab->elf.sgotplt->output_section->vma
4194 + htab->elf.sgotplt->output_offset;
4195 unresolved_reloc = FALSE;
4199 /* Relocation is to the entry for this symbol in the
4200 procedure linkage table. */
4202 /* Resolve a PLT32 reloc against a local symbol directly,
4203 without using the procedure linkage table. */
4207 if ((h->plt.offset == (bfd_vma) -1
4208 && eh->plt_got.offset == (bfd_vma) -1)
4209 || htab->elf.splt == NULL)
4211 /* We didn't make a PLT entry for this symbol. This
4212 happens when statically linking PIC code, or when
4213 using -Bsymbolic. */
4217 if (h->plt.offset != (bfd_vma) -1)
4219 resolved_plt = htab->elf.splt;
4220 plt_offset = h->plt.offset;
4224 resolved_plt = htab->plt_got;
4225 plt_offset = eh->plt_got.offset;
4228 relocation = (resolved_plt->output_section->vma
4229 + resolved_plt->output_offset
4231 unresolved_reloc = FALSE;
4235 /* Set to symbol size. */
4236 relocation = st_size;
4241 if ((input_section->flags & SEC_ALLOC) == 0
4245 /* Copy dynamic function pointer relocations. Don't generate
4246 dynamic relocations against resolved undefined weak symbols
4247 in PIE, except for R_386_PC32. */
4248 if ((bfd_link_pic (info)
4250 || ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4251 && (!resolved_to_zero
4252 || r_type == R_386_PC32))
4253 || h->root.type != bfd_link_hash_undefweak))
4254 && ((r_type != R_386_PC32 && r_type != R_386_SIZE32)
4255 || !SYMBOL_CALLS_LOCAL (info, h)))
4256 || (ELIMINATE_COPY_RELOCS
4257 && !bfd_link_pic (info)
4261 || eh->func_pointer_refcount > 0
4262 || (h->root.type == bfd_link_hash_undefweak
4263 && !resolved_to_zero))
4264 && ((h->def_dynamic && !h->def_regular)
4265 /* Undefined weak symbol is bound locally when
4267 || h->root.type == bfd_link_hash_undefweak)))
4269 Elf_Internal_Rela outrel;
4270 bfd_boolean skip, relocate;
4273 /* When generating a shared object, these relocations
4274 are copied into the output file to be resolved at run
4281 _bfd_elf_section_offset (output_bfd, info, input_section,
4283 if (outrel.r_offset == (bfd_vma) -1)
4285 else if (outrel.r_offset == (bfd_vma) -2)
4286 skip = TRUE, relocate = TRUE;
4287 outrel.r_offset += (input_section->output_section->vma
4288 + input_section->output_offset);
4291 memset (&outrel, 0, sizeof outrel);
4294 && (r_type == R_386_PC32
4295 || !(bfd_link_executable (info)
4296 || SYMBOLIC_BIND (info, h))
4297 || !h->def_regular))
4298 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4301 /* This symbol is local, or marked to become local. */
4303 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4306 sreloc = elf_section_data (input_section)->sreloc;
4308 if (sreloc == NULL || sreloc->contents == NULL)
4310 r = bfd_reloc_notsupported;
4311 goto check_relocation_error;
4314 elf_append_rel (output_bfd, sreloc, &outrel);
4316 /* If this reloc is against an external symbol, we do
4317 not want to fiddle with the addend. Otherwise, we
4318 need to include the symbol value so that it becomes
4319 an addend for the dynamic reloc. */
4326 if (!bfd_link_executable (info))
4328 Elf_Internal_Rela outrel;
4331 outrel.r_offset = rel->r_offset
4332 + input_section->output_section->vma
4333 + input_section->output_offset;
4334 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
4335 sreloc = elf_section_data (input_section)->sreloc;
4338 elf_append_rel (output_bfd, sreloc, &outrel);
4343 case R_386_TLS_GOTDESC:
4344 case R_386_TLS_DESC_CALL:
4345 case R_386_TLS_IE_32:
4346 case R_386_TLS_GOTIE:
4347 tls_type = GOT_UNKNOWN;
4348 if (h == NULL && local_got_offsets)
4349 tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
4351 tls_type = elf_i386_hash_entry(h)->tls_type;
4352 if (tls_type == GOT_TLS_IE)
4353 tls_type = GOT_TLS_IE_NEG;
4355 if (! elf_i386_tls_transition (info, input_bfd,
4356 input_section, contents,
4357 symtab_hdr, sym_hashes,
4358 &r_type, tls_type, rel,
4359 relend, h, r_symndx))
4362 if (r_type == R_386_TLS_LE_32)
4364 BFD_ASSERT (! unresolved_reloc);
4365 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
4370 /* GD->LE transition. */
4371 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
4374 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
4376 movl %gs:0, %eax; subl $foo@tpoff, %eax
4377 (6 byte form of subl). */
4378 memcpy (contents + rel->r_offset - 3,
4379 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
4380 roff = rel->r_offset + 5;
4384 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
4386 movl %gs:0, %eax; subl $foo@tpoff, %eax
4387 (6 byte form of subl). */
4388 memcpy (contents + rel->r_offset - 2,
4389 "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
4390 roff = rel->r_offset + 6;
4392 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
4394 /* Skip R_386_PC32/R_386_PLT32. */
4399 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4401 /* GDesc -> LE transition.
4402 It's originally something like:
4403 leal x@tlsdesc(%ebx), %eax
4407 Registers other than %eax may be set up here. */
4412 roff = rel->r_offset;
4413 val = bfd_get_8 (input_bfd, contents + roff - 1);
4415 /* Now modify the instruction as appropriate. */
4416 /* aoliva FIXME: remove the above and xor the byte
4418 bfd_put_8 (output_bfd, val ^ 0x86,
4419 contents + roff - 1);
4420 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
4424 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4426 /* GDesc -> LE transition.
4434 roff = rel->r_offset;
4435 bfd_put_8 (output_bfd, 0x66, contents + roff);
4436 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4439 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
4443 /* IE->LE transition:
4444 Originally it can be one of:
4452 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4455 /* movl foo, %eax. */
4456 bfd_put_8 (output_bfd, 0xb8,
4457 contents + rel->r_offset - 1);
4463 type = bfd_get_8 (input_bfd,
4464 contents + rel->r_offset - 2);
4469 bfd_put_8 (output_bfd, 0xc7,
4470 contents + rel->r_offset - 2);
4471 bfd_put_8 (output_bfd,
4472 0xc0 | ((val >> 3) & 7),
4473 contents + rel->r_offset - 1);
4477 bfd_put_8 (output_bfd, 0x81,
4478 contents + rel->r_offset - 2);
4479 bfd_put_8 (output_bfd,
4480 0xc0 | ((val >> 3) & 7),
4481 contents + rel->r_offset - 1);
4488 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
4489 contents + rel->r_offset);
4494 unsigned int val, type;
4496 /* {IE_32,GOTIE}->LE transition:
4497 Originally it can be one of:
4498 subl foo(%reg1), %reg2
4499 movl foo(%reg1), %reg2
4500 addl foo(%reg1), %reg2
4503 movl $foo, %reg2 (6 byte form)
4504 addl $foo, %reg2. */
4505 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
4506 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4510 bfd_put_8 (output_bfd, 0xc7,
4511 contents + rel->r_offset - 2);
4512 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4513 contents + rel->r_offset - 1);
4515 else if (type == 0x2b)
4518 bfd_put_8 (output_bfd, 0x81,
4519 contents + rel->r_offset - 2);
4520 bfd_put_8 (output_bfd, 0xe8 | ((val >> 3) & 7),
4521 contents + rel->r_offset - 1);
4523 else if (type == 0x03)
4526 bfd_put_8 (output_bfd, 0x81,
4527 contents + rel->r_offset - 2);
4528 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4529 contents + rel->r_offset - 1);
4533 if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTIE)
4534 bfd_put_32 (output_bfd, -elf_i386_tpoff (info, relocation),
4535 contents + rel->r_offset);
4537 bfd_put_32 (output_bfd, elf_i386_tpoff (info, relocation),
4538 contents + rel->r_offset);
4543 if (htab->elf.sgot == NULL)
4548 off = h->got.offset;
4549 offplt = elf_i386_hash_entry (h)->tlsdesc_got;
4553 if (local_got_offsets == NULL)
4556 off = local_got_offsets[r_symndx];
4557 offplt = local_tlsdesc_gotents[r_symndx];
4564 Elf_Internal_Rela outrel;
4568 if (htab->elf.srelgot == NULL)
4571 indx = h && h->dynindx != -1 ? h->dynindx : 0;
4573 if (GOT_TLS_GDESC_P (tls_type))
4576 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_DESC);
4577 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt + 8
4578 <= htab->elf.sgotplt->size);
4579 outrel.r_offset = (htab->elf.sgotplt->output_section->vma
4580 + htab->elf.sgotplt->output_offset
4582 + htab->sgotplt_jump_table_size);
4583 sreloc = htab->elf.srelplt;
4584 loc = sreloc->contents;
4585 loc += (htab->next_tls_desc_index++
4586 * sizeof (Elf32_External_Rel));
4587 BFD_ASSERT (loc + sizeof (Elf32_External_Rel)
4588 <= sreloc->contents + sreloc->size);
4589 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
4592 BFD_ASSERT (! unresolved_reloc);
4593 bfd_put_32 (output_bfd,
4594 relocation - elf_i386_dtpoff_base (info),
4595 htab->elf.sgotplt->contents + offplt
4596 + htab->sgotplt_jump_table_size + 4);
4600 bfd_put_32 (output_bfd, 0,
4601 htab->elf.sgotplt->contents + offplt
4602 + htab->sgotplt_jump_table_size + 4);
4606 sreloc = htab->elf.srelgot;
4608 outrel.r_offset = (htab->elf.sgot->output_section->vma
4609 + htab->elf.sgot->output_offset + off);
4611 if (GOT_TLS_GD_P (tls_type))
4612 dr_type = R_386_TLS_DTPMOD32;
4613 else if (GOT_TLS_GDESC_P (tls_type))
4615 else if (tls_type == GOT_TLS_IE_POS)
4616 dr_type = R_386_TLS_TPOFF;
4618 dr_type = R_386_TLS_TPOFF32;
4620 if (dr_type == R_386_TLS_TPOFF && indx == 0)
4621 bfd_put_32 (output_bfd,
4622 relocation - elf_i386_dtpoff_base (info),
4623 htab->elf.sgot->contents + off);
4624 else if (dr_type == R_386_TLS_TPOFF32 && indx == 0)
4625 bfd_put_32 (output_bfd,
4626 elf_i386_dtpoff_base (info) - relocation,
4627 htab->elf.sgot->contents + off);
4628 else if (dr_type != R_386_TLS_DESC)
4629 bfd_put_32 (output_bfd, 0,
4630 htab->elf.sgot->contents + off);
4631 outrel.r_info = ELF32_R_INFO (indx, dr_type);
4633 elf_append_rel (output_bfd, sreloc, &outrel);
4635 if (GOT_TLS_GD_P (tls_type))
4639 BFD_ASSERT (! unresolved_reloc);
4640 bfd_put_32 (output_bfd,
4641 relocation - elf_i386_dtpoff_base (info),
4642 htab->elf.sgot->contents + off + 4);
4646 bfd_put_32 (output_bfd, 0,
4647 htab->elf.sgot->contents + off + 4);
4648 outrel.r_info = ELF32_R_INFO (indx,
4649 R_386_TLS_DTPOFF32);
4650 outrel.r_offset += 4;
4651 elf_append_rel (output_bfd, sreloc, &outrel);
4654 else if (tls_type == GOT_TLS_IE_BOTH)
4656 bfd_put_32 (output_bfd,
4658 ? relocation - elf_i386_dtpoff_base (info)
4660 htab->elf.sgot->contents + off + 4);
4661 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4662 outrel.r_offset += 4;
4663 elf_append_rel (output_bfd, sreloc, &outrel);
4670 local_got_offsets[r_symndx] |= 1;
4673 if (off >= (bfd_vma) -2
4674 && ! GOT_TLS_GDESC_P (tls_type))
4676 if (r_type == R_386_TLS_GOTDESC
4677 || r_type == R_386_TLS_DESC_CALL)
4679 relocation = htab->sgotplt_jump_table_size + offplt;
4680 unresolved_reloc = FALSE;
4682 else if (r_type == ELF32_R_TYPE (rel->r_info))
4684 bfd_vma g_o_t = htab->elf.sgotplt->output_section->vma
4685 + htab->elf.sgotplt->output_offset;
4686 relocation = htab->elf.sgot->output_section->vma
4687 + htab->elf.sgot->output_offset + off - g_o_t;
4688 if ((r_type == R_386_TLS_IE || r_type == R_386_TLS_GOTIE)
4689 && tls_type == GOT_TLS_IE_BOTH)
4691 if (r_type == R_386_TLS_IE)
4692 relocation += g_o_t;
4693 unresolved_reloc = FALSE;
4695 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
4697 unsigned int val, type;
4700 /* GD->IE transition. */
4701 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
4702 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
4705 /* leal foo(,%reg,1), %eax; call ___tls_get_addr
4707 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
4709 roff = rel->r_offset - 3;
4713 /* leal foo(%reg), %eax; call ___tls_get_addr; nop
4715 movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax. */
4716 roff = rel->r_offset - 2;
4718 memcpy (contents + roff,
4719 "\x65\xa1\0\0\0\0\x2b\x80\0\0\0", 12);
4720 contents[roff + 7] = 0x80 | (val & 7);
4721 /* If foo is used only with foo@gotntpoff(%reg) and
4722 foo@indntpoff, but not with foo@gottpoff(%reg), change
4723 subl $foo@gottpoff(%reg), %eax
4725 addl $foo@gotntpoff(%reg), %eax. */
4726 if (tls_type == GOT_TLS_IE_POS)
4727 contents[roff + 6] = 0x03;
4728 bfd_put_32 (output_bfd,
4729 htab->elf.sgot->output_section->vma
4730 + htab->elf.sgot->output_offset + off
4731 - htab->elf.sgotplt->output_section->vma
4732 - htab->elf.sgotplt->output_offset,
4733 contents + roff + 8);
4734 /* Skip R_386_PLT32. */
4739 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GOTDESC)
4741 /* GDesc -> IE transition.
4742 It's originally something like:
4743 leal x@tlsdesc(%ebx), %eax
4746 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
4748 movl x@gottpoff(%ebx), %eax # before negl %eax
4750 Registers other than %eax may be set up here. */
4754 /* First, make sure it's a leal adding ebx to a 32-bit
4755 offset into any register, although it's probably
4756 almost always going to be eax. */
4757 roff = rel->r_offset;
4759 /* Now modify the instruction as appropriate. */
4760 /* To turn a leal into a movl in the form we use it, it
4761 suffices to change the first byte from 0x8d to 0x8b.
4762 aoliva FIXME: should we decide to keep the leal, all
4763 we have to do is remove the statement below, and
4764 adjust the relaxation of R_386_TLS_DESC_CALL. */
4765 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4767 if (tls_type == GOT_TLS_IE_BOTH)
4770 bfd_put_32 (output_bfd,
4771 htab->elf.sgot->output_section->vma
4772 + htab->elf.sgot->output_offset + off
4773 - htab->elf.sgotplt->output_section->vma
4774 - htab->elf.sgotplt->output_offset,
4778 else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_DESC_CALL)
4780 /* GDesc -> IE transition.
4788 depending on how we transformed the TLS_GOTDESC above.
4793 roff = rel->r_offset;
4795 /* Now modify the instruction as appropriate. */
4796 if (tls_type != GOT_TLS_IE_NEG)
4799 bfd_put_8 (output_bfd, 0x66, contents + roff);
4800 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4805 bfd_put_8 (output_bfd, 0xf7, contents + roff);
4806 bfd_put_8 (output_bfd, 0xd8, contents + roff + 1);
4816 if (! elf_i386_tls_transition (info, input_bfd,
4817 input_section, contents,
4818 symtab_hdr, sym_hashes,
4819 &r_type, GOT_UNKNOWN, rel,
4820 relend, h, r_symndx))
4823 if (r_type != R_386_TLS_LDM)
4825 /* LD->LE transition:
4826 leal foo(%reg), %eax; call ___tls_get_addr.
4828 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi. */
4829 BFD_ASSERT (r_type == R_386_TLS_LE_32);
4830 memcpy (contents + rel->r_offset - 2,
4831 "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
4832 /* Skip R_386_PC32/R_386_PLT32. */
4838 if (htab->elf.sgot == NULL)
4841 off = htab->tls_ldm_got.offset;
4846 Elf_Internal_Rela outrel;
4848 if (htab->elf.srelgot == NULL)
4851 outrel.r_offset = (htab->elf.sgot->output_section->vma
4852 + htab->elf.sgot->output_offset + off);
4854 bfd_put_32 (output_bfd, 0,
4855 htab->elf.sgot->contents + off);
4856 bfd_put_32 (output_bfd, 0,
4857 htab->elf.sgot->contents + off + 4);
4858 outrel.r_info = ELF32_R_INFO (0, R_386_TLS_DTPMOD32);
4859 elf_append_rel (output_bfd, htab->elf.srelgot, &outrel);
4860 htab->tls_ldm_got.offset |= 1;
4862 relocation = htab->elf.sgot->output_section->vma
4863 + htab->elf.sgot->output_offset + off
4864 - htab->elf.sgotplt->output_section->vma
4865 - htab->elf.sgotplt->output_offset;
4866 unresolved_reloc = FALSE;
4869 case R_386_TLS_LDO_32:
4870 if (!bfd_link_executable (info)
4871 || (input_section->flags & SEC_CODE) == 0)
4872 relocation -= elf_i386_dtpoff_base (info);
4874 /* When converting LDO to LE, we must negate. */
4875 relocation = -elf_i386_tpoff (info, relocation);
4878 case R_386_TLS_LE_32:
4880 if (!bfd_link_executable (info))
4882 Elf_Internal_Rela outrel;
4885 outrel.r_offset = rel->r_offset
4886 + input_section->output_section->vma
4887 + input_section->output_offset;
4888 if (h != NULL && h->dynindx != -1)
4892 if (r_type == R_386_TLS_LE_32)
4893 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF32);
4895 outrel.r_info = ELF32_R_INFO (indx, R_386_TLS_TPOFF);
4896 sreloc = elf_section_data (input_section)->sreloc;
4899 elf_append_rel (output_bfd, sreloc, &outrel);
4902 else if (r_type == R_386_TLS_LE_32)
4903 relocation = elf_i386_dtpoff_base (info) - relocation;
4905 relocation -= elf_i386_dtpoff_base (info);
4907 else if (r_type == R_386_TLS_LE_32)
4908 relocation = elf_i386_tpoff (info, relocation);
4910 relocation = -elf_i386_tpoff (info, relocation);
4917 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4918 because such sections are not SEC_ALLOC and thus ld.so will
4919 not process them. */
4920 if (unresolved_reloc
4921 && !((input_section->flags & SEC_DEBUGGING) != 0
4923 && _bfd_elf_section_offset (output_bfd, info, input_section,
4924 rel->r_offset) != (bfd_vma) -1)
4926 (*_bfd_error_handler)
4927 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4930 (long) rel->r_offset,
4932 h->root.root.string);
4937 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4938 contents, rel->r_offset,
4941 check_relocation_error:
4942 if (r != bfd_reloc_ok)
4947 name = h->root.root.string;
4950 name = bfd_elf_string_from_elf_section (input_bfd,
4951 symtab_hdr->sh_link,
4956 name = bfd_section_name (input_bfd, sec);
4959 if (r == bfd_reloc_overflow)
4961 if (! ((*info->callbacks->reloc_overflow)
4962 (info, (h ? &h->root : NULL), name, howto->name,
4963 (bfd_vma) 0, input_bfd, input_section,
4969 (*_bfd_error_handler)
4970 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4971 input_bfd, input_section,
4972 (long) rel->r_offset, name, (int) r);
4983 Elf_Internal_Shdr *rel_hdr;
4984 size_t deleted = rel - wrel;
4986 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
4987 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
4988 if (rel_hdr->sh_size == 0)
4990 /* It is too late to remove an empty reloc section. Leave
4992 ??? What is wrong with an empty section??? */
4993 rel_hdr->sh_size = rel_hdr->sh_entsize;
4996 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
4997 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
4998 input_section->reloc_count -= deleted;
5004 /* Finish up dynamic symbol handling. We set the contents of various
5005 dynamic sections here. */
5008 elf_i386_finish_dynamic_symbol (bfd *output_bfd,
5009 struct bfd_link_info *info,
5010 struct elf_link_hash_entry *h,
5011 Elf_Internal_Sym *sym)
5013 struct elf_i386_link_hash_table *htab;
5014 unsigned plt_entry_size;
5015 const struct elf_i386_backend_data *abed;
5016 struct elf_i386_link_hash_entry *eh;
5017 bfd_boolean local_undefweak;
5019 htab = elf_i386_hash_table (info);
5023 abed = get_elf_i386_backend_data (output_bfd);
5024 plt_entry_size = GET_PLT_ENTRY_SIZE (output_bfd);
5026 eh = (struct elf_i386_link_hash_entry *) h;
5028 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5029 resolved undefined weak symbols in executable so that their
5030 references have value 0 at run-time. */
5031 local_undefweak = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
5035 if (h->plt.offset != (bfd_vma) -1)
5039 Elf_Internal_Rela rel;
5041 asection *plt, *gotplt, *relplt;
5043 /* When building a static executable, use .iplt, .igot.plt and
5044 .rel.iplt sections for STT_GNU_IFUNC symbols. */
5045 if (htab->elf.splt != NULL)
5047 plt = htab->elf.splt;
5048 gotplt = htab->elf.sgotplt;
5049 relplt = htab->elf.srelplt;
5053 plt = htab->elf.iplt;
5054 gotplt = htab->elf.igotplt;
5055 relplt = htab->elf.irelplt;
5058 /* This symbol has an entry in the procedure linkage table. Set
5061 if ((h->dynindx == -1
5063 && !((h->forced_local || bfd_link_executable (info))
5065 && h->type == STT_GNU_IFUNC))
5071 /* Get the index in the procedure linkage table which
5072 corresponds to this symbol. This is the index of this symbol
5073 in all the symbols for which we are making plt entries. The
5074 first entry in the procedure linkage table is reserved.
5076 Get the offset into the .got table of the entry that
5077 corresponds to this function. Each .got entry is 4 bytes.
5078 The first three are reserved.
5080 For static executables, we don't reserve anything. */
5082 if (plt == htab->elf.splt)
5084 got_offset = h->plt.offset / plt_entry_size - 1;
5085 got_offset = (got_offset + 3) * 4;
5089 got_offset = h->plt.offset / plt_entry_size;
5090 got_offset = got_offset * 4;
5093 /* Fill in the entry in the procedure linkage table. */
5094 if (! bfd_link_pic (info))
5096 memcpy (plt->contents + h->plt.offset, abed->plt->plt_entry,
5097 abed->plt->plt_entry_size);
5098 bfd_put_32 (output_bfd,
5099 (gotplt->output_section->vma
5100 + gotplt->output_offset
5102 plt->contents + h->plt.offset
5103 + abed->plt->plt_got_offset);
5105 if (abed->is_vxworks)
5107 int s, k, reloc_index;
5109 /* Create the R_386_32 relocation referencing the GOT
5110 for this PLT entry. */
5112 /* S: Current slot number (zero-based). */
5113 s = ((h->plt.offset - abed->plt->plt_entry_size)
5114 / abed->plt->plt_entry_size);
5115 /* K: Number of relocations for PLTResolve. */
5116 if (bfd_link_pic (info))
5117 k = PLTRESOLVE_RELOCS_SHLIB;
5119 k = PLTRESOLVE_RELOCS;
5120 /* Skip the PLTresolve relocations, and the relocations for
5121 the other PLT slots. */
5122 reloc_index = k + s * PLT_NON_JUMP_SLOT_RELOCS;
5123 loc = (htab->srelplt2->contents + reloc_index
5124 * sizeof (Elf32_External_Rel));
5126 rel.r_offset = (htab->elf.splt->output_section->vma
5127 + htab->elf.splt->output_offset
5128 + h->plt.offset + 2),
5129 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
5130 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5132 /* Create the R_386_32 relocation referencing the beginning of
5133 the PLT for this GOT entry. */
5134 rel.r_offset = (htab->elf.sgotplt->output_section->vma
5135 + htab->elf.sgotplt->output_offset
5137 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
5138 bfd_elf32_swap_reloc_out (output_bfd, &rel,
5139 loc + sizeof (Elf32_External_Rel));
5144 memcpy (plt->contents + h->plt.offset, abed->plt->pic_plt_entry,
5145 abed->plt->plt_entry_size);
5146 bfd_put_32 (output_bfd, got_offset,
5147 plt->contents + h->plt.offset
5148 + abed->plt->plt_got_offset);
5151 /* Fill in the entry in the global offset table. Leave the entry
5152 as zero for undefined weak symbol in PIE. No PLT relocation
5153 against undefined weak symbol in PIE. */
5154 if (!local_undefweak)
5156 bfd_put_32 (output_bfd,
5157 (plt->output_section->vma
5158 + plt->output_offset
5160 + abed->plt->plt_lazy_offset),
5161 gotplt->contents + got_offset);
5163 /* Fill in the entry in the .rel.plt section. */
5164 rel.r_offset = (gotplt->output_section->vma
5165 + gotplt->output_offset
5167 if (h->dynindx == -1
5168 || ((bfd_link_executable (info)
5169 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
5171 && h->type == STT_GNU_IFUNC))
5173 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5174 R_386_IRELATIVE instead of R_386_JUMP_SLOT. Store addend
5175 in the .got.plt section. */
5176 bfd_put_32 (output_bfd,
5177 (h->root.u.def.value
5178 + h->root.u.def.section->output_section->vma
5179 + h->root.u.def.section->output_offset),
5180 gotplt->contents + got_offset);
5181 rel.r_info = ELF32_R_INFO (0, R_386_IRELATIVE);
5182 /* R_386_IRELATIVE comes last. */
5183 plt_index = htab->next_irelative_index--;
5187 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT);
5188 plt_index = htab->next_jump_slot_index++;
5191 loc = relplt->contents + plt_index * sizeof (Elf32_External_Rel);
5192 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5194 /* Don't fill PLT entry for static executables. */
5195 if (plt == htab->elf.splt)
5197 bfd_put_32 (output_bfd,
5198 plt_index * sizeof (Elf32_External_Rel),
5199 plt->contents + h->plt.offset
5200 + abed->plt->plt_reloc_offset);
5201 bfd_put_32 (output_bfd, - (h->plt.offset
5202 + abed->plt->plt_plt_offset + 4),
5203 plt->contents + h->plt.offset
5204 + abed->plt->plt_plt_offset);
5208 else if (eh->plt_got.offset != (bfd_vma) -1)
5210 bfd_vma got_offset, plt_offset;
5211 asection *plt, *got, *gotplt;
5212 const bfd_byte *got_plt_entry;
5214 /* Offset of displacement of the indirect jump. */
5215 bfd_vma plt_got_offset = 2;
5217 /* Set the entry in the GOT procedure linkage table. */
5218 plt = htab->plt_got;
5219 got = htab->elf.sgot;
5220 gotplt = htab->elf.sgotplt;
5221 got_offset = h->got.offset;
5223 if (got_offset == (bfd_vma) -1
5229 /* Fill in the entry in the GOT procedure linkage table. */
5230 if (! bfd_link_pic (info))
5232 got_plt_entry = elf_i386_got_plt_entry;
5233 got_offset += got->output_section->vma + got->output_offset;
5237 got_plt_entry = elf_i386_pic_got_plt_entry;
5238 got_offset += (got->output_section->vma
5239 + got->output_offset
5240 - gotplt->output_section->vma
5241 - gotplt->output_offset);
5244 plt_offset = eh->plt_got.offset;
5245 memcpy (plt->contents + plt_offset, got_plt_entry,
5246 sizeof (elf_i386_got_plt_entry));
5247 bfd_put_32 (output_bfd, got_offset,
5248 plt->contents + plt_offset + plt_got_offset);
5251 if (!local_undefweak
5253 && (h->plt.offset != (bfd_vma) -1
5254 || eh->plt_got.offset != (bfd_vma) -1))
5256 /* Mark the symbol as undefined, rather than as defined in
5257 the .plt section. Leave the value if there were any
5258 relocations where pointer equality matters (this is a clue
5259 for the dynamic linker, to make function pointer
5260 comparisons work between an application and shared
5261 library), otherwise set it to zero. If a function is only
5262 called from a binary, there is no need to slow down
5263 shared libraries because of that. */
5264 sym->st_shndx = SHN_UNDEF;
5265 if (!h->pointer_equality_needed)
5269 /* Don't generate dynamic GOT relocation against undefined weak
5270 symbol in executable. */
5271 if (h->got.offset != (bfd_vma) -1
5272 && ! GOT_TLS_GD_ANY_P (elf_i386_hash_entry(h)->tls_type)
5273 && (elf_i386_hash_entry(h)->tls_type & GOT_TLS_IE) == 0
5274 && !local_undefweak)
5276 Elf_Internal_Rela rel;
5278 /* This symbol has an entry in the global offset table. Set it
5281 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
5284 rel.r_offset = (htab->elf.sgot->output_section->vma
5285 + htab->elf.sgot->output_offset
5286 + (h->got.offset & ~(bfd_vma) 1));
5288 /* If this is a static link, or it is a -Bsymbolic link and the
5289 symbol is defined locally or was forced to be local because
5290 of a version file, we just want to emit a RELATIVE reloc.
5291 The entry in the global offset table will already have been
5292 initialized in the relocate_section function. */
5294 && h->type == STT_GNU_IFUNC)
5296 if (bfd_link_pic (info))
5298 /* Generate R_386_GLOB_DAT. */
5305 if (!h->pointer_equality_needed)
5308 /* For non-shared object, we can't use .got.plt, which
5309 contains the real function addres if we need pointer
5310 equality. We load the GOT entry with the PLT entry. */
5311 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
5312 bfd_put_32 (output_bfd,
5313 (plt->output_section->vma
5314 + plt->output_offset + h->plt.offset),
5315 htab->elf.sgot->contents + h->got.offset);
5319 else if (bfd_link_pic (info)
5320 && SYMBOL_REFERENCES_LOCAL (info, h))
5322 BFD_ASSERT((h->got.offset & 1) != 0);
5323 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE);
5327 BFD_ASSERT((h->got.offset & 1) == 0);
5329 bfd_put_32 (output_bfd, (bfd_vma) 0,
5330 htab->elf.sgot->contents + h->got.offset);
5331 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT);
5334 elf_append_rel (output_bfd, htab->elf.srelgot, &rel);
5339 Elf_Internal_Rela rel;
5341 /* This symbol needs a copy reloc. Set it up. */
5343 if (h->dynindx == -1
5344 || (h->root.type != bfd_link_hash_defined
5345 && h->root.type != bfd_link_hash_defweak)
5346 || htab->srelbss == NULL)
5349 rel.r_offset = (h->root.u.def.value
5350 + h->root.u.def.section->output_section->vma
5351 + h->root.u.def.section->output_offset);
5352 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY);
5353 elf_append_rel (output_bfd, htab->srelbss, &rel);
5359 /* Finish up local dynamic symbol handling. We set the contents of
5360 various dynamic sections here. */
5363 elf_i386_finish_local_dynamic_symbol (void **slot, void *inf)
5365 struct elf_link_hash_entry *h
5366 = (struct elf_link_hash_entry *) *slot;
5367 struct bfd_link_info *info
5368 = (struct bfd_link_info *) inf;
5370 return elf_i386_finish_dynamic_symbol (info->output_bfd, info,
5374 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5375 here since undefined weak symbol may not be dynamic and may not be
5376 called for elf_i386_finish_dynamic_symbol. */
5379 elf_i386_pie_finish_undefweak_symbol (struct bfd_hash_entry *bh,
5382 struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
5383 struct bfd_link_info *info = (struct bfd_link_info *) inf;
5385 if (h->root.type != bfd_link_hash_undefweak
5386 || h->dynindx != -1)
5389 return elf_i386_finish_dynamic_symbol (info->output_bfd,
5393 /* Used to decide how to sort relocs in an optimal manner for the
5394 dynamic linker, before writing them out. */
5396 static enum elf_reloc_type_class
5397 elf_i386_reloc_type_class (const struct bfd_link_info *info,
5398 const asection *rel_sec ATTRIBUTE_UNUSED,
5399 const Elf_Internal_Rela *rela)
5401 bfd *abfd = info->output_bfd;
5402 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5403 struct elf_link_hash_table *htab = elf_hash_table (info);
5405 if (htab->dynsym != NULL
5406 && htab->dynsym->contents != NULL)
5408 /* Check relocation against STT_GNU_IFUNC symbol if there are
5410 unsigned long r_symndx = ELF32_R_SYM (rela->r_info);
5411 Elf_Internal_Sym sym;
5412 if (!bed->s->swap_symbol_in (abfd,
5413 (htab->dynsym->contents
5414 + r_symndx * sizeof (Elf32_External_Sym)),
5418 if (ELF32_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
5419 return reloc_class_ifunc;
5422 switch (ELF32_R_TYPE (rela->r_info))
5424 case R_386_RELATIVE:
5425 return reloc_class_relative;
5426 case R_386_JUMP_SLOT:
5427 return reloc_class_plt;
5429 return reloc_class_copy;
5431 return reloc_class_normal;
5435 /* Finish up the dynamic sections. */
5438 elf_i386_finish_dynamic_sections (bfd *output_bfd,
5439 struct bfd_link_info *info)
5441 struct elf_i386_link_hash_table *htab;
5444 const struct elf_i386_backend_data *abed;
5446 htab = elf_i386_hash_table (info);
5450 dynobj = htab->elf.dynobj;
5451 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
5452 abed = get_elf_i386_backend_data (output_bfd);
5454 if (htab->elf.dynamic_sections_created)
5456 Elf32_External_Dyn *dyncon, *dynconend;
5458 if (sdyn == NULL || htab->elf.sgot == NULL)
5461 dyncon = (Elf32_External_Dyn *) sdyn->contents;
5462 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5463 for (; dyncon < dynconend; dyncon++)
5465 Elf_Internal_Dyn dyn;
5468 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5473 if (abed->is_vxworks
5474 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
5479 s = htab->elf.sgotplt;
5480 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5484 s = htab->elf.srelplt;
5485 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5489 s = htab->elf.srelplt;
5490 dyn.d_un.d_val = s->size;
5494 /* My reading of the SVR4 ABI indicates that the
5495 procedure linkage table relocs (DT_JMPREL) should be
5496 included in the overall relocs (DT_REL). This is
5497 what Solaris does. However, UnixWare can not handle
5498 that case. Therefore, we override the DT_RELSZ entry
5499 here to make it not include the JMPREL relocs. */
5500 s = htab->elf.srelplt;
5503 dyn.d_un.d_val -= s->size;
5507 /* We may not be using the standard ELF linker script.
5508 If .rel.plt is the first .rel section, we adjust
5509 DT_REL to not include it. */
5510 s = htab->elf.srelplt;
5513 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
5515 dyn.d_un.d_ptr += s->size;
5519 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5522 /* Fill in the first entry in the procedure linkage table. */
5523 if (htab->elf.splt && htab->elf.splt->size > 0)
5525 if (bfd_link_pic (info))
5527 memcpy (htab->elf.splt->contents, abed->plt->pic_plt0_entry,
5528 abed->plt->plt0_entry_size);
5529 memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
5530 abed->plt0_pad_byte,
5531 abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
5535 memcpy (htab->elf.splt->contents, abed->plt->plt0_entry,
5536 abed->plt->plt0_entry_size);
5537 memset (htab->elf.splt->contents + abed->plt->plt0_entry_size,
5538 abed->plt0_pad_byte,
5539 abed->plt->plt_entry_size - abed->plt->plt0_entry_size);
5540 bfd_put_32 (output_bfd,
5541 (htab->elf.sgotplt->output_section->vma
5542 + htab->elf.sgotplt->output_offset
5544 htab->elf.splt->contents
5545 + abed->plt->plt0_got1_offset);
5546 bfd_put_32 (output_bfd,
5547 (htab->elf.sgotplt->output_section->vma
5548 + htab->elf.sgotplt->output_offset
5550 htab->elf.splt->contents
5551 + abed->plt->plt0_got2_offset);
5553 if (abed->is_vxworks)
5555 Elf_Internal_Rela rel;
5557 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 4.
5558 On IA32 we use REL relocations so the addend goes in
5559 the PLT directly. */
5560 rel.r_offset = (htab->elf.splt->output_section->vma
5561 + htab->elf.splt->output_offset
5562 + abed->plt->plt0_got1_offset);
5563 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
5564 bfd_elf32_swap_reloc_out (output_bfd, &rel,
5565 htab->srelplt2->contents);
5566 /* Generate a relocation for _GLOBAL_OFFSET_TABLE_ + 8. */
5567 rel.r_offset = (htab->elf.splt->output_section->vma
5568 + htab->elf.splt->output_offset
5569 + abed->plt->plt0_got2_offset);
5570 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
5571 bfd_elf32_swap_reloc_out (output_bfd, &rel,
5572 htab->srelplt2->contents +
5573 sizeof (Elf32_External_Rel));
5577 /* UnixWare sets the entsize of .plt to 4, although that doesn't
5578 really seem like the right value. */
5579 elf_section_data (htab->elf.splt->output_section)
5580 ->this_hdr.sh_entsize = 4;
5582 /* Correct the .rel.plt.unloaded relocations. */
5583 if (abed->is_vxworks && !bfd_link_pic (info))
5585 int num_plts = (htab->elf.splt->size
5586 / abed->plt->plt_entry_size) - 1;
5589 p = htab->srelplt2->contents;
5590 if (bfd_link_pic (info))
5591 p += PLTRESOLVE_RELOCS_SHLIB * sizeof (Elf32_External_Rel);
5593 p += PLTRESOLVE_RELOCS * sizeof (Elf32_External_Rel);
5595 for (; num_plts; num_plts--)
5597 Elf_Internal_Rela rel;
5598 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
5599 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_386_32);
5600 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
5601 p += sizeof (Elf32_External_Rel);
5603 bfd_elf32_swap_reloc_in (output_bfd, p, &rel);
5604 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_386_32);
5605 bfd_elf32_swap_reloc_out (output_bfd, &rel, p);
5606 p += sizeof (Elf32_External_Rel);
5612 if (htab->elf.sgotplt)
5614 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
5616 (*_bfd_error_handler)
5617 (_("discarded output section: `%A'"), htab->elf.sgotplt);
5621 /* Fill in the first three entries in the global offset table. */
5622 if (htab->elf.sgotplt->size > 0)
5624 bfd_put_32 (output_bfd,
5626 : sdyn->output_section->vma + sdyn->output_offset),
5627 htab->elf.sgotplt->contents);
5628 bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 4);
5629 bfd_put_32 (output_bfd, 0, htab->elf.sgotplt->contents + 8);
5632 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize = 4;
5635 /* Adjust .eh_frame for .plt section. */
5636 if (htab->plt_eh_frame != NULL
5637 && htab->plt_eh_frame->contents != NULL)
5639 if (htab->elf.splt != NULL
5640 && htab->elf.splt->size != 0
5641 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
5642 && htab->elf.splt->output_section != NULL
5643 && htab->plt_eh_frame->output_section != NULL)
5645 bfd_vma plt_start = htab->elf.splt->output_section->vma;
5646 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
5647 + htab->plt_eh_frame->output_offset
5648 + PLT_FDE_START_OFFSET;
5649 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
5650 htab->plt_eh_frame->contents
5651 + PLT_FDE_START_OFFSET);
5653 if (htab->plt_eh_frame->sec_info_type
5654 == SEC_INFO_TYPE_EH_FRAME)
5656 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
5658 htab->plt_eh_frame->contents))
5663 if (htab->elf.sgot && htab->elf.sgot->size > 0)
5664 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 4;
5666 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5667 htab_traverse (htab->loc_hash_table,
5668 elf_i386_finish_local_dynamic_symbol,
5671 /* Fill PLT entries for undefined weak symbols in PIE. */
5672 if (bfd_link_pie (info))
5673 bfd_hash_traverse (&info->hash->table,
5674 elf_i386_pie_finish_undefweak_symbol,
5680 /* Return an array of PLT entry symbol values. */
5683 elf_i386_get_plt_sym_val (bfd *abfd, asymbol **dynsyms, asection *plt,
5686 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
5689 bfd_vma *plt_sym_val;
5691 bfd_byte *plt_contents;
5692 const struct elf_i386_backend_data *bed
5693 = get_elf_i386_backend_data (abfd);
5694 Elf_Internal_Shdr *hdr;
5696 /* Get the .plt section contents. */
5697 plt_contents = (bfd_byte *) bfd_malloc (plt->size);
5698 if (plt_contents == NULL)
5700 if (!bfd_get_section_contents (abfd, (asection *) plt,
5701 plt_contents, 0, plt->size))
5704 free (plt_contents);
5708 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
5709 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
5712 hdr = &elf_section_data (relplt)->this_hdr;
5713 count = relplt->size / hdr->sh_entsize;
5715 plt_sym_val = (bfd_vma *) bfd_malloc (sizeof (bfd_vma) * count);
5716 if (plt_sym_val == NULL)
5719 for (i = 0; i < count; i++)
5720 plt_sym_val[i] = -1;
5722 plt_offset = bed->plt->plt_entry_size;
5723 p = relplt->relocation;
5724 for (i = 0; i < count; i++, p++)
5728 /* Skip unknown relocation. PR 17512: file: bc9d6cf5. */
5729 if (p->howto == NULL)
5732 if (p->howto->type != R_386_JUMP_SLOT
5733 && p->howto->type != R_386_IRELATIVE)
5736 reloc_index = H_GET_32 (abfd, (plt_contents + plt_offset
5737 + bed->plt->plt_reloc_offset));
5738 reloc_index /= sizeof (Elf32_External_Rel);
5739 if (reloc_index < count)
5740 plt_sym_val[reloc_index] = plt->vma + plt_offset;
5742 plt_offset += bed->plt->plt_entry_size;
5744 /* PR binutils/18437: Skip extra relocations in the .rel.plt
5746 if (plt_offset >= plt->size)
5750 free (plt_contents);
5755 /* Similar to _bfd_elf_get_synthetic_symtab. */
5758 elf_i386_get_synthetic_symtab (bfd *abfd,
5765 asection *plt = bfd_get_section_by_name (abfd, ".plt");
5766 return _bfd_elf_ifunc_get_synthetic_symtab (abfd, symcount, syms,
5767 dynsymcount, dynsyms, ret,
5769 elf_i386_get_plt_sym_val);
5772 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5775 elf_i386_hash_symbol (struct elf_link_hash_entry *h)
5777 if (h->plt.offset != (bfd_vma) -1
5779 && !h->pointer_equality_needed)
5782 return _bfd_elf_hash_symbol (h);
5785 /* Hook called by the linker routine which adds symbols from an object
5789 elf_i386_add_symbol_hook (bfd * abfd,
5790 struct bfd_link_info * info,
5791 Elf_Internal_Sym * sym,
5792 const char ** namep ATTRIBUTE_UNUSED,
5793 flagword * flagsp ATTRIBUTE_UNUSED,
5794 asection ** secp ATTRIBUTE_UNUSED,
5795 bfd_vma * valp ATTRIBUTE_UNUSED)
5797 if (ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE
5798 && (abfd->flags & DYNAMIC) == 0
5799 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
5800 elf_tdata (info->output_bfd)->has_gnu_symbols
5801 |= elf_gnu_symbol_unique;
5806 #define TARGET_LITTLE_SYM i386_elf32_vec
5807 #define TARGET_LITTLE_NAME "elf32-i386"
5808 #define ELF_ARCH bfd_arch_i386
5809 #define ELF_TARGET_ID I386_ELF_DATA
5810 #define ELF_MACHINE_CODE EM_386
5811 #define ELF_MAXPAGESIZE 0x1000
5813 #define elf_backend_can_gc_sections 1
5814 #define elf_backend_can_refcount 1
5815 #define elf_backend_want_got_plt 1
5816 #define elf_backend_plt_readonly 1
5817 #define elf_backend_want_plt_sym 0
5818 #define elf_backend_got_header_size 12
5819 #define elf_backend_plt_alignment 4
5820 #define elf_backend_extern_protected_data 1
5822 /* Support RELA for objdump of prelink objects. */
5823 #define elf_info_to_howto elf_i386_info_to_howto_rel
5824 #define elf_info_to_howto_rel elf_i386_info_to_howto_rel
5826 #define bfd_elf32_mkobject elf_i386_mkobject
5828 #define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name
5829 #define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create
5830 #define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup
5831 #define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
5832 #define bfd_elf32_get_synthetic_symtab elf_i386_get_synthetic_symtab
5834 #define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol
5835 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
5836 #define elf_backend_check_relocs elf_i386_check_relocs
5837 #define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol
5838 #define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections
5839 #define elf_backend_fake_sections elf_i386_fake_sections
5840 #define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections
5841 #define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol
5842 #define elf_backend_gc_mark_hook elf_i386_gc_mark_hook
5843 #define elf_backend_grok_prstatus elf_i386_grok_prstatus
5844 #define elf_backend_grok_psinfo elf_i386_grok_psinfo
5845 #define elf_backend_reloc_type_class elf_i386_reloc_type_class
5846 #define elf_backend_relocate_section elf_i386_relocate_section
5847 #define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections
5848 #define elf_backend_always_size_sections elf_i386_always_size_sections
5849 #define elf_backend_omit_section_dynsym \
5850 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5851 #define elf_backend_hash_symbol elf_i386_hash_symbol
5852 #define elf_backend_add_symbol_hook elf_i386_add_symbol_hook
5853 #define elf_backend_fixup_symbol elf_i386_fixup_symbol
5855 #include "elf32-target.h"
5857 /* FreeBSD support. */
5859 #undef TARGET_LITTLE_SYM
5860 #define TARGET_LITTLE_SYM i386_elf32_fbsd_vec
5861 #undef TARGET_LITTLE_NAME
5862 #define TARGET_LITTLE_NAME "elf32-i386-freebsd"
5864 #define ELF_OSABI ELFOSABI_FREEBSD
5866 /* The kernel recognizes executables as valid only if they carry a
5867 "FreeBSD" label in the ELF header. So we put this label on all
5868 executables and (for simplicity) also all other object files. */
5871 elf_i386_fbsd_post_process_headers (bfd *abfd, struct bfd_link_info *info)
5873 _bfd_elf_post_process_headers (abfd, info);
5875 #ifdef OLD_FREEBSD_ABI_LABEL
5877 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
5878 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
5879 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
5884 #undef elf_backend_post_process_headers
5885 #define elf_backend_post_process_headers elf_i386_fbsd_post_process_headers
5887 #define elf32_bed elf32_i386_fbsd_bed
5889 #undef elf_backend_add_symbol_hook
5891 #include "elf32-target.h"
5895 #undef TARGET_LITTLE_SYM
5896 #define TARGET_LITTLE_SYM i386_elf32_sol2_vec
5897 #undef TARGET_LITTLE_NAME
5898 #define TARGET_LITTLE_NAME "elf32-i386-sol2"
5900 #undef elf_backend_post_process_headers
5902 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5903 objects won't be recognized. */
5907 #define elf32_bed elf32_i386_sol2_bed
5909 /* The 32-bit static TLS arena size is rounded to the nearest 8-byte
5911 #undef elf_backend_static_tls_alignment
5912 #define elf_backend_static_tls_alignment 8
5914 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5916 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5918 #undef elf_backend_want_plt_sym
5919 #define elf_backend_want_plt_sym 1
5921 #undef elf_backend_strtab_flags
5922 #define elf_backend_strtab_flags SHF_STRINGS
5924 /* Called to set the sh_flags, sh_link and sh_info fields of OSECTION which
5925 has a type >= SHT_LOOS. Returns TRUE if these fields were initialised
5926 FALSE otherwise. ISECTION is the best guess matching section from the
5927 input bfd IBFD, but it might be NULL. */
5930 elf32_i386_copy_solaris_special_section_fields (const bfd *ibfd ATTRIBUTE_UNUSED,
5931 bfd *obfd ATTRIBUTE_UNUSED,
5932 const Elf_Internal_Shdr *isection ATTRIBUTE_UNUSED,
5933 Elf_Internal_Shdr *osection ATTRIBUTE_UNUSED)
5935 /* PR 19938: FIXME: Need to add code for setting the sh_info
5936 and sh_link fields of Solaris specific section types. */
5939 /* Based upon Oracle Solaris 11.3 Linkers and Libraries Guide, Ch. 13,
5940 Object File Format, Table 13-9 ELF sh_link and sh_info Interpretation:
5942 http://docs.oracle.com/cd/E53394_01/html/E54813/chapter6-94076.html#scrolltoc
5944 The following values should be set:
5947 -----------------------------------------------------------------------------
5948 SHT_SUNW_ancillary The section header index of 0
5949 [0x6fffffee] the associated string table.
5951 SHT_SUNW_capinfo The section header index of For a dynamic object, the
5952 [0x6ffffff0] the associated symbol table. section header index of
5954 SHT_SUNW_capchain table,
5957 SHT_SUNW_symsort The section header index of 0
5958 [0x6ffffff1] the associated symbol table.
5960 SHT_SUNW_tlssort The section header index of 0
5961 [0x6ffffff2] the associated symbol table.
5963 SHT_SUNW_LDYNSYM The section header index of One greater than the
5964 [0x6ffffff3] the associated string table. symbol table index of the
5965 This index is the same string last local symbol,
5966 table used by the SHT_DYNSYM STB_LOCAL. Since
5967 section. SHT_SUNW_LDYNSYM only
5968 contains local symbols,
5969 sh_info is equivalent to
5970 the number of symbols in
5973 SHT_SUNW_cap If symbol capabilities exist, If any capabilities refer
5974 [0x6ffffff5] the section header index of to named strings, the
5975 the associated section header index of
5976 SHT_SUNW_capinfo table, the associated string
5977 otherwise 0. table, otherwise 0.
5979 SHT_SUNW_move The section header index of 0
5980 [0x6ffffffa] the associated symbol table.
5985 SHT_SUNW_syminfo The section header index of The section header index
5986 [0x6ffffffc] the associated symbol table. of the associated
5989 SHT_SUNW_verdef The section header index of The number of version
5990 [0x6ffffffd] the associated string table. definitions within the
5993 SHT_SUNW_verneed The section header index of The number of version
5994 [0x6ffffffe] the associated string table. dependencies within the
5997 SHT_SUNW_versym The section header index of 0
5998 [0x6fffffff] the associated symbol table. */
6001 #undef elf_backend_copy_special_section_fields
6002 #define elf_backend_copy_special_section_fields elf32_i386_copy_solaris_special_section_fields
6004 #include "elf32-target.h"
6006 /* Intel MCU support. */
6009 elf32_iamcu_elf_object_p (bfd *abfd)
6011 /* Set the right machine number for an IAMCU elf32 file. */
6012 bfd_default_set_arch_mach (abfd, bfd_arch_iamcu, bfd_mach_i386_iamcu);
6016 #undef TARGET_LITTLE_SYM
6017 #define TARGET_LITTLE_SYM iamcu_elf32_vec
6018 #undef TARGET_LITTLE_NAME
6019 #define TARGET_LITTLE_NAME "elf32-iamcu"
6021 #define ELF_ARCH bfd_arch_iamcu
6023 #undef ELF_MACHINE_CODE
6024 #define ELF_MACHINE_CODE EM_IAMCU
6029 #define elf32_bed elf32_iamcu_bed
6031 #undef elf_backend_object_p
6032 #define elf_backend_object_p elf32_iamcu_elf_object_p
6034 #undef elf_backend_static_tls_alignment
6036 #undef elf_backend_want_plt_sym
6037 #define elf_backend_want_plt_sym 0
6039 #undef elf_backend_strtab_flags
6040 #undef elf_backend_copy_special_section_fields
6042 #include "elf32-target.h"
6044 /* Restore defaults. */
6046 #define ELF_ARCH bfd_arch_i386
6047 #undef ELF_MACHINE_CODE
6048 #define ELF_MACHINE_CODE EM_386
6050 /* Native Client support. */
6052 #undef TARGET_LITTLE_SYM
6053 #define TARGET_LITTLE_SYM i386_elf32_nacl_vec
6054 #undef TARGET_LITTLE_NAME
6055 #define TARGET_LITTLE_NAME "elf32-i386-nacl"
6057 #define elf32_bed elf32_i386_nacl_bed
6059 #undef ELF_MAXPAGESIZE
6060 #define ELF_MAXPAGESIZE 0x10000
6062 /* Restore defaults. */
6064 #undef elf_backend_want_plt_sym
6065 #define elf_backend_want_plt_sym 0
6066 #undef elf_backend_post_process_headers
6067 #undef elf_backend_static_tls_alignment
6069 /* NaCl uses substantially different PLT entries for the same effects. */
6071 #undef elf_backend_plt_alignment
6072 #define elf_backend_plt_alignment 5
6073 #define NACL_PLT_ENTRY_SIZE 64
6074 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6076 static const bfd_byte elf_i386_nacl_plt0_entry[] =
6078 0xff, 0x35, /* pushl contents of address */
6079 0, 0, 0, 0, /* replaced with address of .got + 4. */
6080 0x8b, 0x0d, /* movl contents of address, %ecx */
6081 0, 0, 0, 0, /* replaced with address of .got + 8. */
6082 0x83, 0xe1, NACLMASK, /* andl $NACLMASK, %ecx */
6083 0xff, 0xe1 /* jmp *%ecx */
6086 static const bfd_byte elf_i386_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
6088 0x8b, 0x0d, /* movl contents of address, %ecx */
6089 0, 0, 0, 0, /* replaced with GOT slot address. */
6090 0x83, 0xe1, NACLMASK, /* andl $NACLMASK, %ecx */
6091 0xff, 0xe1, /* jmp *%ecx */
6093 /* Pad to the next 32-byte boundary with nop instructions. */
6095 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6096 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6098 /* Lazy GOT entries point here (32-byte aligned). */
6099 0x68, /* pushl immediate */
6100 0, 0, 0, 0, /* replaced with reloc offset. */
6101 0xe9, /* jmp relative */
6102 0, 0, 0, 0, /* replaced with offset to .plt. */
6104 /* Pad to the next 32-byte boundary with nop instructions. */
6105 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6106 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6110 static const bfd_byte
6111 elf_i386_nacl_pic_plt0_entry[sizeof (elf_i386_nacl_plt0_entry)] =
6113 0xff, 0x73, 0x04, /* pushl 4(%ebx) */
6114 0x8b, 0x4b, 0x08, /* mov 0x8(%ebx), %ecx */
6115 0x83, 0xe1, 0xe0, /* and $NACLMASK, %ecx */
6116 0xff, 0xe1, /* jmp *%ecx */
6118 /* This is expected to be the same size as elf_i386_nacl_plt0_entry,
6119 so pad to that size with nop instructions. */
6120 0x90, 0x90, 0x90, 0x90, 0x90, 0x90
6123 static const bfd_byte elf_i386_nacl_pic_plt_entry[NACL_PLT_ENTRY_SIZE] =
6125 0x8b, 0x8b, /* movl offset(%ebx), %ecx */
6126 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */
6127 0x83, 0xe1, 0xe0, /* andl $NACLMASK, %ecx */
6128 0xff, 0xe1, /* jmp *%ecx */
6130 /* Pad to the next 32-byte boundary with nop instructions. */
6132 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6133 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6135 /* Lazy GOT entries point here (32-byte aligned). */
6136 0x68, /* pushl immediate */
6137 0, 0, 0, 0, /* replaced with offset into relocation table. */
6138 0xe9, /* jmp relative */
6139 0, 0, 0, 0, /* replaced with offset to start of .plt. */
6141 /* Pad to the next 32-byte boundary with nop instructions. */
6142 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6143 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
6147 static const bfd_byte elf_i386_nacl_eh_frame_plt[] =
6149 #if (PLT_CIE_LENGTH != 20 \
6150 || PLT_FDE_LENGTH != 36 \
6151 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6152 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6153 # error "Need elf_i386_backend_data parameters for eh_frame_plt offsets!"
6155 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
6156 0, 0, 0, 0, /* CIE ID */
6157 1, /* CIE version */
6158 'z', 'R', 0, /* Augmentation string */
6159 1, /* Code alignment factor */
6160 0x7c, /* Data alignment factor: -4 */
6161 8, /* Return address column */
6162 1, /* Augmentation size */
6163 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
6164 DW_CFA_def_cfa, 4, 4, /* DW_CFA_def_cfa: r4 (esp) ofs 4 */
6165 DW_CFA_offset + 8, 1, /* DW_CFA_offset: r8 (eip) at cfa-4 */
6166 DW_CFA_nop, DW_CFA_nop,
6168 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
6169 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
6170 0, 0, 0, 0, /* R_386_PC32 .plt goes here */
6171 0, 0, 0, 0, /* .plt size goes here */
6172 0, /* Augmentation size */
6173 DW_CFA_def_cfa_offset, 8, /* DW_CFA_def_cfa_offset: 8 */
6174 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6175 DW_CFA_def_cfa_offset, 12, /* DW_CFA_def_cfa_offset: 12 */
6176 DW_CFA_advance_loc + 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6177 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
6178 13, /* Block length */
6179 DW_OP_breg4, 4, /* DW_OP_breg4 (esp): 4 */
6180 DW_OP_breg8, 0, /* DW_OP_breg8 (eip): 0 */
6181 DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
6182 DW_OP_lit2, DW_OP_shl, DW_OP_plus,
6183 DW_CFA_nop, DW_CFA_nop
6186 static const struct elf_i386_plt_layout elf_i386_nacl_plt =
6188 elf_i386_nacl_plt0_entry, /* plt0_entry */
6189 sizeof (elf_i386_nacl_plt0_entry), /* plt0_entry_size */
6190 2, /* plt0_got1_offset */
6191 8, /* plt0_got2_offset */
6192 elf_i386_nacl_plt_entry, /* plt_entry */
6193 NACL_PLT_ENTRY_SIZE, /* plt_entry_size */
6194 2, /* plt_got_offset */
6195 33, /* plt_reloc_offset */
6196 38, /* plt_plt_offset */
6197 32, /* plt_lazy_offset */
6198 elf_i386_nacl_pic_plt0_entry, /* pic_plt0_entry */
6199 elf_i386_nacl_pic_plt_entry, /* pic_plt_entry */
6200 elf_i386_nacl_eh_frame_plt, /* eh_frame_plt */
6201 sizeof (elf_i386_nacl_eh_frame_plt),/* eh_frame_plt_size */
6204 static const struct elf_i386_backend_data elf_i386_nacl_arch_bed =
6206 &elf_i386_nacl_plt, /* plt */
6207 0x90, /* plt0_pad_byte: nop insn */
6212 elf32_i386_nacl_elf_object_p (bfd *abfd)
6214 /* Set the right machine number for a NaCl i386 ELF32 file. */
6215 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_i386_i386_nacl);
6219 #undef elf_backend_arch_data
6220 #define elf_backend_arch_data &elf_i386_nacl_arch_bed
6222 #undef elf_backend_object_p
6223 #define elf_backend_object_p elf32_i386_nacl_elf_object_p
6224 #undef elf_backend_modify_segment_map
6225 #define elf_backend_modify_segment_map nacl_modify_segment_map
6226 #undef elf_backend_modify_program_headers
6227 #define elf_backend_modify_program_headers nacl_modify_program_headers
6228 #undef elf_backend_final_write_processing
6229 #define elf_backend_final_write_processing nacl_final_write_processing
6231 #include "elf32-target.h"
6233 /* Restore defaults. */
6234 #undef elf_backend_object_p
6235 #undef elf_backend_modify_segment_map
6236 #undef elf_backend_modify_program_headers
6237 #undef elf_backend_final_write_processing
6239 /* VxWorks support. */
6241 #undef TARGET_LITTLE_SYM
6242 #define TARGET_LITTLE_SYM i386_elf32_vxworks_vec
6243 #undef TARGET_LITTLE_NAME
6244 #define TARGET_LITTLE_NAME "elf32-i386-vxworks"
6246 #undef elf_backend_plt_alignment
6247 #define elf_backend_plt_alignment 4
6249 static const struct elf_i386_backend_data elf_i386_vxworks_arch_bed =
6251 &elf_i386_plt, /* plt */
6252 0x90, /* plt0_pad_byte */
6256 #undef elf_backend_arch_data
6257 #define elf_backend_arch_data &elf_i386_vxworks_arch_bed
6259 #undef elf_backend_relocs_compatible
6260 #undef elf_backend_add_symbol_hook
6261 #define elf_backend_add_symbol_hook \
6262 elf_vxworks_add_symbol_hook
6263 #undef elf_backend_link_output_symbol_hook
6264 #define elf_backend_link_output_symbol_hook \
6265 elf_vxworks_link_output_symbol_hook
6266 #undef elf_backend_emit_relocs
6267 #define elf_backend_emit_relocs elf_vxworks_emit_relocs
6268 #undef elf_backend_final_write_processing
6269 #define elf_backend_final_write_processing \
6270 elf_vxworks_final_write_processing
6271 #undef elf_backend_static_tls_alignment
6273 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so
6275 #undef elf_backend_want_plt_sym
6276 #define elf_backend_want_plt_sym 1
6279 #define elf32_bed elf32_i386_vxworks_bed
6281 #include "elf32-target.h"