1 /* X86-64 specific support for ELF
2 Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
4 Free Software Foundation, Inc.
5 Contributed by Jan Hubicka <jh@suse.cz>.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
30 #include "bfd_stdint.h"
34 #include "libiberty.h"
36 #include "elf/x86-64.h"
43 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
44 #define MINUS_ONE (~ (bfd_vma) 0)
46 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
47 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
48 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
49 since they are the same. */
51 #define ABI_64_P(abfd) \
52 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
54 /* The relocation "howto" table. Order of fields:
55 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
56 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
57 static reloc_howto_type x86_64_elf_howto_table[] =
59 HOWTO(R_X86_64_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
60 bfd_elf_generic_reloc, "R_X86_64_NONE", FALSE, 0x00000000, 0x00000000,
62 HOWTO(R_X86_64_64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
63 bfd_elf_generic_reloc, "R_X86_64_64", FALSE, MINUS_ONE, MINUS_ONE,
65 HOWTO(R_X86_64_PC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
66 bfd_elf_generic_reloc, "R_X86_64_PC32", FALSE, 0xffffffff, 0xffffffff,
68 HOWTO(R_X86_64_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
69 bfd_elf_generic_reloc, "R_X86_64_GOT32", FALSE, 0xffffffff, 0xffffffff,
71 HOWTO(R_X86_64_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
72 bfd_elf_generic_reloc, "R_X86_64_PLT32", FALSE, 0xffffffff, 0xffffffff,
74 HOWTO(R_X86_64_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
75 bfd_elf_generic_reloc, "R_X86_64_COPY", FALSE, 0xffffffff, 0xffffffff,
77 HOWTO(R_X86_64_GLOB_DAT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
78 bfd_elf_generic_reloc, "R_X86_64_GLOB_DAT", FALSE, MINUS_ONE,
80 HOWTO(R_X86_64_JUMP_SLOT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
81 bfd_elf_generic_reloc, "R_X86_64_JUMP_SLOT", FALSE, MINUS_ONE,
83 HOWTO(R_X86_64_RELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
84 bfd_elf_generic_reloc, "R_X86_64_RELATIVE", FALSE, MINUS_ONE,
86 HOWTO(R_X86_64_GOTPCREL, 0, 2, 32, TRUE, 0, complain_overflow_signed,
87 bfd_elf_generic_reloc, "R_X86_64_GOTPCREL", FALSE, 0xffffffff,
89 HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
90 bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
92 HOWTO(R_X86_64_32S, 0, 2, 32, FALSE, 0, complain_overflow_signed,
93 bfd_elf_generic_reloc, "R_X86_64_32S", FALSE, 0xffffffff, 0xffffffff,
95 HOWTO(R_X86_64_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
96 bfd_elf_generic_reloc, "R_X86_64_16", FALSE, 0xffff, 0xffff, FALSE),
97 HOWTO(R_X86_64_PC16,0, 1, 16, TRUE, 0, complain_overflow_bitfield,
98 bfd_elf_generic_reloc, "R_X86_64_PC16", FALSE, 0xffff, 0xffff, TRUE),
99 HOWTO(R_X86_64_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
100 bfd_elf_generic_reloc, "R_X86_64_8", FALSE, 0xff, 0xff, FALSE),
101 HOWTO(R_X86_64_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
102 bfd_elf_generic_reloc, "R_X86_64_PC8", FALSE, 0xff, 0xff, TRUE),
103 HOWTO(R_X86_64_DTPMOD64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
104 bfd_elf_generic_reloc, "R_X86_64_DTPMOD64", FALSE, MINUS_ONE,
106 HOWTO(R_X86_64_DTPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
107 bfd_elf_generic_reloc, "R_X86_64_DTPOFF64", FALSE, MINUS_ONE,
109 HOWTO(R_X86_64_TPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
110 bfd_elf_generic_reloc, "R_X86_64_TPOFF64", FALSE, MINUS_ONE,
112 HOWTO(R_X86_64_TLSGD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
113 bfd_elf_generic_reloc, "R_X86_64_TLSGD", FALSE, 0xffffffff,
115 HOWTO(R_X86_64_TLSLD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
116 bfd_elf_generic_reloc, "R_X86_64_TLSLD", FALSE, 0xffffffff,
118 HOWTO(R_X86_64_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
119 bfd_elf_generic_reloc, "R_X86_64_DTPOFF32", FALSE, 0xffffffff,
121 HOWTO(R_X86_64_GOTTPOFF, 0, 2, 32, TRUE, 0, complain_overflow_signed,
122 bfd_elf_generic_reloc, "R_X86_64_GOTTPOFF", FALSE, 0xffffffff,
124 HOWTO(R_X86_64_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
125 bfd_elf_generic_reloc, "R_X86_64_TPOFF32", FALSE, 0xffffffff,
127 HOWTO(R_X86_64_PC64, 0, 4, 64, TRUE, 0, complain_overflow_bitfield,
128 bfd_elf_generic_reloc, "R_X86_64_PC64", FALSE, MINUS_ONE, MINUS_ONE,
130 HOWTO(R_X86_64_GOTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
131 bfd_elf_generic_reloc, "R_X86_64_GOTOFF64",
132 FALSE, MINUS_ONE, MINUS_ONE, FALSE),
133 HOWTO(R_X86_64_GOTPC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
134 bfd_elf_generic_reloc, "R_X86_64_GOTPC32",
135 FALSE, 0xffffffff, 0xffffffff, TRUE),
136 HOWTO(R_X86_64_GOT64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
137 bfd_elf_generic_reloc, "R_X86_64_GOT64", FALSE, MINUS_ONE, MINUS_ONE,
139 HOWTO(R_X86_64_GOTPCREL64, 0, 4, 64, TRUE, 0, complain_overflow_signed,
140 bfd_elf_generic_reloc, "R_X86_64_GOTPCREL64", FALSE, MINUS_ONE,
142 HOWTO(R_X86_64_GOTPC64, 0, 4, 64, TRUE, 0, complain_overflow_signed,
143 bfd_elf_generic_reloc, "R_X86_64_GOTPC64",
144 FALSE, MINUS_ONE, MINUS_ONE, TRUE),
145 HOWTO(R_X86_64_GOTPLT64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
146 bfd_elf_generic_reloc, "R_X86_64_GOTPLT64", FALSE, MINUS_ONE,
148 HOWTO(R_X86_64_PLTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
149 bfd_elf_generic_reloc, "R_X86_64_PLTOFF64", FALSE, MINUS_ONE,
151 HOWTO(R_X86_64_SIZE32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
152 bfd_elf_generic_reloc, "R_X86_64_SIZE32", FALSE, 0xffffffff, 0xffffffff,
154 HOWTO(R_X86_64_SIZE64, 0, 4, 64, FALSE, 0, complain_overflow_unsigned,
155 bfd_elf_generic_reloc, "R_X86_64_SIZE64", FALSE, MINUS_ONE, MINUS_ONE,
157 HOWTO(R_X86_64_GOTPC32_TLSDESC, 0, 2, 32, TRUE, 0,
158 complain_overflow_bitfield, bfd_elf_generic_reloc,
159 "R_X86_64_GOTPC32_TLSDESC",
160 FALSE, 0xffffffff, 0xffffffff, TRUE),
161 HOWTO(R_X86_64_TLSDESC_CALL, 0, 0, 0, FALSE, 0,
162 complain_overflow_dont, bfd_elf_generic_reloc,
163 "R_X86_64_TLSDESC_CALL",
165 HOWTO(R_X86_64_TLSDESC, 0, 4, 64, FALSE, 0,
166 complain_overflow_bitfield, bfd_elf_generic_reloc,
168 FALSE, MINUS_ONE, MINUS_ONE, FALSE),
169 HOWTO(R_X86_64_IRELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
170 bfd_elf_generic_reloc, "R_X86_64_IRELATIVE", FALSE, MINUS_ONE,
172 HOWTO(R_X86_64_RELATIVE64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
173 bfd_elf_generic_reloc, "R_X86_64_RELATIVE64", FALSE, MINUS_ONE,
176 /* We have a gap in the reloc numbers here.
177 R_X86_64_standard counts the number up to this point, and
178 R_X86_64_vt_offset is the value to subtract from a reloc type of
179 R_X86_64_GNU_VT* to form an index into this table. */
180 #define R_X86_64_standard (R_X86_64_RELATIVE64 + 1)
181 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
183 /* GNU extension to record C++ vtable hierarchy. */
184 HOWTO (R_X86_64_GNU_VTINHERIT, 0, 4, 0, FALSE, 0, complain_overflow_dont,
185 NULL, "R_X86_64_GNU_VTINHERIT", FALSE, 0, 0, FALSE),
187 /* GNU extension to record C++ vtable member usage. */
188 HOWTO (R_X86_64_GNU_VTENTRY, 0, 4, 0, FALSE, 0, complain_overflow_dont,
189 _bfd_elf_rel_vtable_reloc_fn, "R_X86_64_GNU_VTENTRY", FALSE, 0, 0,
192 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
193 HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
194 bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
198 #define IS_X86_64_PCREL_TYPE(TYPE) \
199 ( ((TYPE) == R_X86_64_PC8) \
200 || ((TYPE) == R_X86_64_PC16) \
201 || ((TYPE) == R_X86_64_PC32) \
202 || ((TYPE) == R_X86_64_PC64))
204 /* Map BFD relocs to the x86_64 elf relocs. */
207 bfd_reloc_code_real_type bfd_reloc_val;
208 unsigned char elf_reloc_val;
211 static const struct elf_reloc_map x86_64_reloc_map[] =
213 { BFD_RELOC_NONE, R_X86_64_NONE, },
214 { BFD_RELOC_64, R_X86_64_64, },
215 { BFD_RELOC_32_PCREL, R_X86_64_PC32, },
216 { BFD_RELOC_X86_64_GOT32, R_X86_64_GOT32,},
217 { BFD_RELOC_X86_64_PLT32, R_X86_64_PLT32,},
218 { BFD_RELOC_X86_64_COPY, R_X86_64_COPY, },
219 { BFD_RELOC_X86_64_GLOB_DAT, R_X86_64_GLOB_DAT, },
220 { BFD_RELOC_X86_64_JUMP_SLOT, R_X86_64_JUMP_SLOT, },
221 { BFD_RELOC_X86_64_RELATIVE, R_X86_64_RELATIVE, },
222 { BFD_RELOC_X86_64_GOTPCREL, R_X86_64_GOTPCREL, },
223 { BFD_RELOC_32, R_X86_64_32, },
224 { BFD_RELOC_X86_64_32S, R_X86_64_32S, },
225 { BFD_RELOC_16, R_X86_64_16, },
226 { BFD_RELOC_16_PCREL, R_X86_64_PC16, },
227 { BFD_RELOC_8, R_X86_64_8, },
228 { BFD_RELOC_8_PCREL, R_X86_64_PC8, },
229 { BFD_RELOC_X86_64_DTPMOD64, R_X86_64_DTPMOD64, },
230 { BFD_RELOC_X86_64_DTPOFF64, R_X86_64_DTPOFF64, },
231 { BFD_RELOC_X86_64_TPOFF64, R_X86_64_TPOFF64, },
232 { BFD_RELOC_X86_64_TLSGD, R_X86_64_TLSGD, },
233 { BFD_RELOC_X86_64_TLSLD, R_X86_64_TLSLD, },
234 { BFD_RELOC_X86_64_DTPOFF32, R_X86_64_DTPOFF32, },
235 { BFD_RELOC_X86_64_GOTTPOFF, R_X86_64_GOTTPOFF, },
236 { BFD_RELOC_X86_64_TPOFF32, R_X86_64_TPOFF32, },
237 { BFD_RELOC_64_PCREL, R_X86_64_PC64, },
238 { BFD_RELOC_X86_64_GOTOFF64, R_X86_64_GOTOFF64, },
239 { BFD_RELOC_X86_64_GOTPC32, R_X86_64_GOTPC32, },
240 { BFD_RELOC_X86_64_GOT64, R_X86_64_GOT64, },
241 { BFD_RELOC_X86_64_GOTPCREL64,R_X86_64_GOTPCREL64, },
242 { BFD_RELOC_X86_64_GOTPC64, R_X86_64_GOTPC64, },
243 { BFD_RELOC_X86_64_GOTPLT64, R_X86_64_GOTPLT64, },
244 { BFD_RELOC_X86_64_PLTOFF64, R_X86_64_PLTOFF64, },
245 { BFD_RELOC_SIZE32, R_X86_64_SIZE32, },
246 { BFD_RELOC_SIZE64, R_X86_64_SIZE64, },
247 { BFD_RELOC_X86_64_GOTPC32_TLSDESC, R_X86_64_GOTPC32_TLSDESC, },
248 { BFD_RELOC_X86_64_TLSDESC_CALL, R_X86_64_TLSDESC_CALL, },
249 { BFD_RELOC_X86_64_TLSDESC, R_X86_64_TLSDESC, },
250 { BFD_RELOC_X86_64_IRELATIVE, R_X86_64_IRELATIVE, },
251 { BFD_RELOC_VTABLE_INHERIT, R_X86_64_GNU_VTINHERIT, },
252 { BFD_RELOC_VTABLE_ENTRY, R_X86_64_GNU_VTENTRY, },
255 static reloc_howto_type *
256 elf_x86_64_rtype_to_howto (bfd *abfd, unsigned r_type)
260 if (r_type == (unsigned int) R_X86_64_32)
265 i = ARRAY_SIZE (x86_64_elf_howto_table) - 1;
267 else if (r_type < (unsigned int) R_X86_64_GNU_VTINHERIT
268 || r_type >= (unsigned int) R_X86_64_max)
270 if (r_type >= (unsigned int) R_X86_64_standard)
272 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
274 r_type = R_X86_64_NONE;
279 i = r_type - (unsigned int) R_X86_64_vt_offset;
280 BFD_ASSERT (x86_64_elf_howto_table[i].type == r_type);
281 return &x86_64_elf_howto_table[i];
284 /* Given a BFD reloc type, return a HOWTO structure. */
285 static reloc_howto_type *
286 elf_x86_64_reloc_type_lookup (bfd *abfd,
287 bfd_reloc_code_real_type code)
291 for (i = 0; i < sizeof (x86_64_reloc_map) / sizeof (struct elf_reloc_map);
294 if (x86_64_reloc_map[i].bfd_reloc_val == code)
295 return elf_x86_64_rtype_to_howto (abfd,
296 x86_64_reloc_map[i].elf_reloc_val);
301 static reloc_howto_type *
302 elf_x86_64_reloc_name_lookup (bfd *abfd,
307 if (!ABI_64_P (abfd) && strcasecmp (r_name, "R_X86_64_32") == 0)
309 /* Get x32 R_X86_64_32. */
310 reloc_howto_type *reloc
311 = &x86_64_elf_howto_table[ARRAY_SIZE (x86_64_elf_howto_table) - 1];
312 BFD_ASSERT (reloc->type == (unsigned int) R_X86_64_32);
316 for (i = 0; i < ARRAY_SIZE (x86_64_elf_howto_table); i++)
317 if (x86_64_elf_howto_table[i].name != NULL
318 && strcasecmp (x86_64_elf_howto_table[i].name, r_name) == 0)
319 return &x86_64_elf_howto_table[i];
324 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
327 elf_x86_64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
328 Elf_Internal_Rela *dst)
332 r_type = ELF32_R_TYPE (dst->r_info);
333 cache_ptr->howto = elf_x86_64_rtype_to_howto (abfd, r_type);
334 BFD_ASSERT (r_type == cache_ptr->howto->type);
337 /* Support for core dump NOTE sections. */
339 elf_x86_64_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
344 switch (note->descsz)
349 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
351 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
354 elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24);
362 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
364 elf_tdata (abfd)->core_signal
365 = bfd_get_16 (abfd, note->descdata + 12);
368 elf_tdata (abfd)->core_lwpid
369 = bfd_get_32 (abfd, note->descdata + 32);
378 /* Make a ".reg/999" section. */
379 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
380 size, note->descpos + offset);
384 elf_x86_64_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
386 switch (note->descsz)
391 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
392 elf_tdata (abfd)->core_pid
393 = bfd_get_32 (abfd, note->descdata + 12);
394 elf_tdata (abfd)->core_program
395 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
396 elf_tdata (abfd)->core_command
397 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
400 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
401 elf_tdata (abfd)->core_pid
402 = bfd_get_32 (abfd, note->descdata + 24);
403 elf_tdata (abfd)->core_program
404 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
405 elf_tdata (abfd)->core_command
406 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
409 /* Note that for some reason, a spurious space is tacked
410 onto the end of the args in some (at least one anyway)
411 implementations, so strip it off if it exists. */
414 char *command = elf_tdata (abfd)->core_command;
415 int n = strlen (command);
417 if (0 < n && command[n - 1] == ' ')
418 command[n - 1] = '\0';
426 elf_x86_64_write_core_note (bfd *abfd, char *buf, int *bufsiz,
429 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
431 const char *fname, *psargs;
442 va_start (ap, note_type);
443 fname = va_arg (ap, const char *);
444 psargs = va_arg (ap, const char *);
447 if (bed->s->elfclass == ELFCLASS32)
450 memset (&data, 0, sizeof (data));
451 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
452 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
453 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
454 &data, sizeof (data));
459 memset (&data, 0, sizeof (data));
460 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
461 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
462 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
463 &data, sizeof (data));
468 va_start (ap, note_type);
469 pid = va_arg (ap, long);
470 cursig = va_arg (ap, int);
471 gregs = va_arg (ap, const void *);
474 if (bed->s->elfclass == ELFCLASS32)
476 if (bed->elf_machine_code == EM_X86_64)
478 prstatusx32_t prstat;
479 memset (&prstat, 0, sizeof (prstat));
481 prstat.pr_cursig = cursig;
482 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
483 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
484 &prstat, sizeof (prstat));
489 memset (&prstat, 0, sizeof (prstat));
491 prstat.pr_cursig = cursig;
492 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
493 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
494 &prstat, sizeof (prstat));
500 memset (&prstat, 0, sizeof (prstat));
502 prstat.pr_cursig = cursig;
503 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
504 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
505 &prstat, sizeof (prstat));
512 /* Functions for the x86-64 ELF linker. */
514 /* The name of the dynamic interpreter. This is put in the .interp
517 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
518 #define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
520 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
521 copying dynamic variables from a shared lib into an app's dynbss
522 section, and instead use a dynamic relocation to point into the
524 #define ELIMINATE_COPY_RELOCS 1
526 /* The size in bytes of an entry in the global offset table. */
528 #define GOT_ENTRY_SIZE 8
530 /* The size in bytes of an entry in the procedure linkage table. */
532 #define PLT_ENTRY_SIZE 16
534 /* The first entry in a procedure linkage table looks like this. See the
535 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
537 static const bfd_byte elf_x86_64_plt0_entry[PLT_ENTRY_SIZE] =
539 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
540 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
541 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
544 /* Subsequent entries in a procedure linkage table look like this. */
546 static const bfd_byte elf_x86_64_plt_entry[PLT_ENTRY_SIZE] =
548 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
549 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
550 0x68, /* pushq immediate */
551 0, 0, 0, 0, /* replaced with index into relocation table. */
552 0xe9, /* jmp relative */
553 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
556 /* .eh_frame covering the .plt section. */
558 static const bfd_byte elf_x86_64_eh_frame_plt[] =
560 #define PLT_CIE_LENGTH 20
561 #define PLT_FDE_LENGTH 36
562 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
563 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
564 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
565 0, 0, 0, 0, /* CIE ID */
567 'z', 'R', 0, /* Augmentation string */
568 1, /* Code alignment factor */
569 0x78, /* Data alignment factor */
570 16, /* Return address column */
571 1, /* Augmentation size */
572 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
573 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
574 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
575 DW_CFA_nop, DW_CFA_nop,
577 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
578 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
579 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
580 0, 0, 0, 0, /* .plt size goes here */
581 0, /* Augmentation size */
582 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
583 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
584 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
585 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
586 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
587 11, /* Block length */
588 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
589 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
590 DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
591 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
592 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
595 /* Architecture-specific backend data for x86-64. */
597 struct elf_x86_64_backend_data
599 /* Templates for the initial PLT entry and for subsequent entries. */
600 const bfd_byte *plt0_entry;
601 const bfd_byte *plt_entry;
602 unsigned int plt_entry_size; /* Size of each PLT entry. */
604 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
605 unsigned int plt0_got1_offset;
606 unsigned int plt0_got2_offset;
608 /* Offset of the end of the PC-relative instruction containing
610 unsigned int plt0_got2_insn_end;
612 /* Offsets into plt_entry that are to be replaced with... */
613 unsigned int plt_got_offset; /* ... address of this symbol in .got. */
614 unsigned int plt_reloc_offset; /* ... offset into relocation table. */
615 unsigned int plt_plt_offset; /* ... offset to start of .plt. */
617 /* Length of the PC-relative instruction containing plt_got_offset. */
618 unsigned int plt_got_insn_size;
620 /* Offset of the end of the PC-relative jump to plt0_entry. */
621 unsigned int plt_plt_insn_end;
623 /* Offset into plt_entry where the initial value of the GOT entry points. */
624 unsigned int plt_lazy_offset;
626 /* .eh_frame covering the .plt section. */
627 const bfd_byte *eh_frame_plt;
628 unsigned int eh_frame_plt_size;
631 #define get_elf_x86_64_backend_data(abfd) \
632 ((const struct elf_x86_64_backend_data *) \
633 get_elf_backend_data (abfd)->arch_data)
635 #define GET_PLT_ENTRY_SIZE(abfd) \
636 get_elf_x86_64_backend_data (abfd)->plt_entry_size
638 /* These are the standard parameters. */
639 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed =
641 elf_x86_64_plt0_entry, /* plt0_entry */
642 elf_x86_64_plt_entry, /* plt_entry */
643 sizeof (elf_x86_64_plt_entry), /* plt_entry_size */
644 2, /* plt0_got1_offset */
645 8, /* plt0_got2_offset */
646 12, /* plt0_got2_insn_end */
647 2, /* plt_got_offset */
648 7, /* plt_reloc_offset */
649 12, /* plt_plt_offset */
650 6, /* plt_got_insn_size */
651 PLT_ENTRY_SIZE, /* plt_plt_insn_end */
652 6, /* plt_lazy_offset */
653 elf_x86_64_eh_frame_plt, /* eh_frame_plt */
654 sizeof (elf_x86_64_eh_frame_plt), /* eh_frame_plt_size */
657 #define elf_backend_arch_data &elf_x86_64_arch_bed
659 /* x86-64 ELF linker hash entry. */
661 struct elf_x86_64_link_hash_entry
663 struct elf_link_hash_entry elf;
665 /* Track dynamic relocs copied for this symbol. */
666 struct elf_dyn_relocs *dyn_relocs;
668 #define GOT_UNKNOWN 0
672 #define GOT_TLS_GDESC 4
673 #define GOT_TLS_GD_BOTH_P(type) \
674 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
675 #define GOT_TLS_GD_P(type) \
676 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
677 #define GOT_TLS_GDESC_P(type) \
678 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
679 #define GOT_TLS_GD_ANY_P(type) \
680 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
681 unsigned char tls_type;
683 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
684 starting at the end of the jump table. */
688 #define elf_x86_64_hash_entry(ent) \
689 ((struct elf_x86_64_link_hash_entry *)(ent))
691 struct elf_x86_64_obj_tdata
693 struct elf_obj_tdata root;
695 /* tls_type for each local got entry. */
696 char *local_got_tls_type;
698 /* GOTPLT entries for TLS descriptors. */
699 bfd_vma *local_tlsdesc_gotent;
702 #define elf_x86_64_tdata(abfd) \
703 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
705 #define elf_x86_64_local_got_tls_type(abfd) \
706 (elf_x86_64_tdata (abfd)->local_got_tls_type)
708 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
709 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
711 #define is_x86_64_elf(bfd) \
712 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
713 && elf_tdata (bfd) != NULL \
714 && elf_object_id (bfd) == X86_64_ELF_DATA)
717 elf_x86_64_mkobject (bfd *abfd)
719 return bfd_elf_allocate_object (abfd, sizeof (struct elf_x86_64_obj_tdata),
723 /* x86-64 ELF linker hash table. */
725 struct elf_x86_64_link_hash_table
727 struct elf_link_hash_table elf;
729 /* Short-cuts to get to dynamic linker sections. */
732 asection *plt_eh_frame;
736 bfd_signed_vma refcount;
740 /* The amount of space used by the jump slots in the GOT. */
741 bfd_vma sgotplt_jump_table_size;
743 /* Small local sym cache. */
744 struct sym_cache sym_cache;
746 bfd_vma (*r_info) (bfd_vma, bfd_vma);
747 bfd_vma (*r_sym) (bfd_vma);
748 unsigned int pointer_r_type;
749 const char *dynamic_interpreter;
750 int dynamic_interpreter_size;
752 /* _TLS_MODULE_BASE_ symbol. */
753 struct bfd_link_hash_entry *tls_module_base;
755 /* Used by local STT_GNU_IFUNC symbols. */
756 htab_t loc_hash_table;
757 void * loc_hash_memory;
759 /* The offset into splt of the PLT entry for the TLS descriptor
760 resolver. Special values are 0, if not necessary (or not found
761 to be necessary yet), and -1 if needed but not determined
764 /* The offset into sgot of the GOT entry used by the PLT entry
768 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
769 bfd_vma next_jump_slot_index;
770 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
771 bfd_vma next_irelative_index;
774 /* Get the x86-64 ELF linker hash table from a link_info structure. */
776 #define elf_x86_64_hash_table(p) \
777 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
778 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
780 #define elf_x86_64_compute_jump_table_size(htab) \
781 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
783 /* Create an entry in an x86-64 ELF linker hash table. */
785 static struct bfd_hash_entry *
786 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry *entry,
787 struct bfd_hash_table *table,
790 /* Allocate the structure if it has not already been allocated by a
794 entry = (struct bfd_hash_entry *)
795 bfd_hash_allocate (table,
796 sizeof (struct elf_x86_64_link_hash_entry));
801 /* Call the allocation method of the superclass. */
802 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
805 struct elf_x86_64_link_hash_entry *eh;
807 eh = (struct elf_x86_64_link_hash_entry *) entry;
808 eh->dyn_relocs = NULL;
809 eh->tls_type = GOT_UNKNOWN;
810 eh->tlsdesc_got = (bfd_vma) -1;
816 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
817 for local symbol so that we can handle local STT_GNU_IFUNC symbols
818 as global symbol. We reuse indx and dynstr_index for local symbol
819 hash since they aren't used by global symbols in this backend. */
822 elf_x86_64_local_htab_hash (const void *ptr)
824 struct elf_link_hash_entry *h
825 = (struct elf_link_hash_entry *) ptr;
826 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
829 /* Compare local hash entries. */
832 elf_x86_64_local_htab_eq (const void *ptr1, const void *ptr2)
834 struct elf_link_hash_entry *h1
835 = (struct elf_link_hash_entry *) ptr1;
836 struct elf_link_hash_entry *h2
837 = (struct elf_link_hash_entry *) ptr2;
839 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
842 /* Find and/or create a hash entry for local symbol. */
844 static struct elf_link_hash_entry *
845 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table *htab,
846 bfd *abfd, const Elf_Internal_Rela *rel,
849 struct elf_x86_64_link_hash_entry e, *ret;
850 asection *sec = abfd->sections;
851 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
852 htab->r_sym (rel->r_info));
855 e.elf.indx = sec->id;
856 e.elf.dynstr_index = htab->r_sym (rel->r_info);
857 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
858 create ? INSERT : NO_INSERT);
865 ret = (struct elf_x86_64_link_hash_entry *) *slot;
869 ret = (struct elf_x86_64_link_hash_entry *)
870 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
871 sizeof (struct elf_x86_64_link_hash_entry));
874 memset (ret, 0, sizeof (*ret));
875 ret->elf.indx = sec->id;
876 ret->elf.dynstr_index = htab->r_sym (rel->r_info);
877 ret->elf.dynindx = -1;
883 /* Create an X86-64 ELF linker hash table. */
885 static struct bfd_link_hash_table *
886 elf_x86_64_link_hash_table_create (bfd *abfd)
888 struct elf_x86_64_link_hash_table *ret;
889 bfd_size_type amt = sizeof (struct elf_x86_64_link_hash_table);
891 ret = (struct elf_x86_64_link_hash_table *) bfd_malloc (amt);
895 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
896 elf_x86_64_link_hash_newfunc,
897 sizeof (struct elf_x86_64_link_hash_entry),
906 ret->plt_eh_frame = NULL;
907 ret->sym_cache.abfd = NULL;
908 ret->tlsdesc_plt = 0;
909 ret->tlsdesc_got = 0;
910 ret->tls_ld_got.refcount = 0;
911 ret->sgotplt_jump_table_size = 0;
912 ret->tls_module_base = NULL;
913 ret->next_jump_slot_index = 0;
914 ret->next_irelative_index = 0;
918 ret->r_info = elf64_r_info;
919 ret->r_sym = elf64_r_sym;
920 ret->pointer_r_type = R_X86_64_64;
921 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
922 ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
926 ret->r_info = elf32_r_info;
927 ret->r_sym = elf32_r_sym;
928 ret->pointer_r_type = R_X86_64_32;
929 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
930 ret->dynamic_interpreter_size = sizeof ELF32_DYNAMIC_INTERPRETER;
933 ret->loc_hash_table = htab_try_create (1024,
934 elf_x86_64_local_htab_hash,
935 elf_x86_64_local_htab_eq,
937 ret->loc_hash_memory = objalloc_create ();
938 if (!ret->loc_hash_table || !ret->loc_hash_memory)
944 return &ret->elf.root;
947 /* Destroy an X86-64 ELF linker hash table. */
950 elf_x86_64_link_hash_table_free (struct bfd_link_hash_table *hash)
952 struct elf_x86_64_link_hash_table *htab
953 = (struct elf_x86_64_link_hash_table *) hash;
955 if (htab->loc_hash_table)
956 htab_delete (htab->loc_hash_table);
957 if (htab->loc_hash_memory)
958 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
959 _bfd_generic_link_hash_table_free (hash);
962 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
963 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
967 elf_x86_64_create_dynamic_sections (bfd *dynobj,
968 struct bfd_link_info *info)
970 struct elf_x86_64_link_hash_table *htab;
972 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
975 htab = elf_x86_64_hash_table (info);
979 htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
981 htab->srelbss = bfd_get_linker_section (dynobj, ".rela.bss");
984 || (!info->shared && !htab->srelbss))
987 if (!info->no_ld_generated_unwind_info
988 && htab->plt_eh_frame == NULL
989 && htab->elf.splt != NULL)
991 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
992 | SEC_HAS_CONTENTS | SEC_IN_MEMORY
993 | SEC_LINKER_CREATED);
995 = bfd_make_section_anyway_with_flags (dynobj, ".eh_frame", flags);
996 if (htab->plt_eh_frame == NULL
997 || !bfd_set_section_alignment (dynobj, htab->plt_eh_frame, 3))
1003 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1006 elf_x86_64_copy_indirect_symbol (struct bfd_link_info *info,
1007 struct elf_link_hash_entry *dir,
1008 struct elf_link_hash_entry *ind)
1010 struct elf_x86_64_link_hash_entry *edir, *eind;
1012 edir = (struct elf_x86_64_link_hash_entry *) dir;
1013 eind = (struct elf_x86_64_link_hash_entry *) ind;
1015 if (eind->dyn_relocs != NULL)
1017 if (edir->dyn_relocs != NULL)
1019 struct elf_dyn_relocs **pp;
1020 struct elf_dyn_relocs *p;
1022 /* Add reloc counts against the indirect sym to the direct sym
1023 list. Merge any entries against the same section. */
1024 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1026 struct elf_dyn_relocs *q;
1028 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1029 if (q->sec == p->sec)
1031 q->pc_count += p->pc_count;
1032 q->count += p->count;
1039 *pp = edir->dyn_relocs;
1042 edir->dyn_relocs = eind->dyn_relocs;
1043 eind->dyn_relocs = NULL;
1046 if (ind->root.type == bfd_link_hash_indirect
1047 && dir->got.refcount <= 0)
1049 edir->tls_type = eind->tls_type;
1050 eind->tls_type = GOT_UNKNOWN;
1053 if (ELIMINATE_COPY_RELOCS
1054 && ind->root.type != bfd_link_hash_indirect
1055 && dir->dynamic_adjusted)
1057 /* If called to transfer flags for a weakdef during processing
1058 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1059 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1060 dir->ref_dynamic |= ind->ref_dynamic;
1061 dir->ref_regular |= ind->ref_regular;
1062 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1063 dir->needs_plt |= ind->needs_plt;
1064 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1067 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1071 elf64_x86_64_elf_object_p (bfd *abfd)
1073 /* Set the right machine number for an x86-64 elf64 file. */
1074 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64);
1079 elf32_x86_64_elf_object_p (bfd *abfd)
1081 /* Set the right machine number for an x86-64 elf32 file. */
1082 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32);
1086 /* Return TRUE if the TLS access code sequence support transition
1090 elf_x86_64_check_tls_transition (bfd *abfd,
1091 struct bfd_link_info *info,
1094 Elf_Internal_Shdr *symtab_hdr,
1095 struct elf_link_hash_entry **sym_hashes,
1096 unsigned int r_type,
1097 const Elf_Internal_Rela *rel,
1098 const Elf_Internal_Rela *relend)
1101 unsigned long r_symndx;
1102 struct elf_link_hash_entry *h;
1104 struct elf_x86_64_link_hash_table *htab;
1106 /* Get the section contents. */
1107 if (contents == NULL)
1109 if (elf_section_data (sec)->this_hdr.contents != NULL)
1110 contents = elf_section_data (sec)->this_hdr.contents;
1113 /* FIXME: How to better handle error condition? */
1114 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1117 /* Cache the section contents for elf_link_input_bfd. */
1118 elf_section_data (sec)->this_hdr.contents = contents;
1122 htab = elf_x86_64_hash_table (info);
1123 offset = rel->r_offset;
1126 case R_X86_64_TLSGD:
1127 case R_X86_64_TLSLD:
1128 if ((rel + 1) >= relend)
1131 if (r_type == R_X86_64_TLSGD)
1133 /* Check transition from GD access model. For 64bit, only
1134 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1135 .word 0x6666; rex64; call __tls_get_addr
1136 can transit to different access model. For 32bit, only
1137 leaq foo@tlsgd(%rip), %rdi
1138 .word 0x6666; rex64; call __tls_get_addr
1139 can transit to different access model. */
1141 static const unsigned char call[] = { 0x66, 0x66, 0x48, 0xe8 };
1142 static const unsigned char leaq[] = { 0x66, 0x48, 0x8d, 0x3d };
1144 if ((offset + 12) > sec->size
1145 || memcmp (contents + offset + 4, call, 4) != 0)
1148 if (ABI_64_P (abfd))
1151 || memcmp (contents + offset - 4, leaq, 4) != 0)
1157 || memcmp (contents + offset - 3, leaq + 1, 3) != 0)
1163 /* Check transition from LD access model. Only
1164 leaq foo@tlsld(%rip), %rdi;
1166 can transit to different access model. */
1168 static const unsigned char lea[] = { 0x48, 0x8d, 0x3d };
1170 if (offset < 3 || (offset + 9) > sec->size)
1173 if (memcmp (contents + offset - 3, lea, 3) != 0
1174 || 0xe8 != *(contents + offset + 4))
1178 r_symndx = htab->r_sym (rel[1].r_info);
1179 if (r_symndx < symtab_hdr->sh_info)
1182 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1183 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1184 may be versioned. */
1186 && h->root.root.string != NULL
1187 && (ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PC32
1188 || ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PLT32)
1189 && (strncmp (h->root.root.string,
1190 "__tls_get_addr", 14) == 0));
1192 case R_X86_64_GOTTPOFF:
1193 /* Check transition from IE access model:
1194 mov foo@gottpoff(%rip), %reg
1195 add foo@gottpoff(%rip), %reg
1198 /* Check REX prefix first. */
1199 if (offset >= 3 && (offset + 4) <= sec->size)
1201 val = bfd_get_8 (abfd, contents + offset - 3);
1202 if (val != 0x48 && val != 0x4c)
1204 /* X32 may have 0x44 REX prefix or no REX prefix. */
1205 if (ABI_64_P (abfd))
1211 /* X32 may not have any REX prefix. */
1212 if (ABI_64_P (abfd))
1214 if (offset < 2 || (offset + 3) > sec->size)
1218 val = bfd_get_8 (abfd, contents + offset - 2);
1219 if (val != 0x8b && val != 0x03)
1222 val = bfd_get_8 (abfd, contents + offset - 1);
1223 return (val & 0xc7) == 5;
1225 case R_X86_64_GOTPC32_TLSDESC:
1226 /* Check transition from GDesc access model:
1227 leaq x@tlsdesc(%rip), %rax
1229 Make sure it's a leaq adding rip to a 32-bit offset
1230 into any register, although it's probably almost always
1233 if (offset < 3 || (offset + 4) > sec->size)
1236 val = bfd_get_8 (abfd, contents + offset - 3);
1237 if ((val & 0xfb) != 0x48)
1240 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1243 val = bfd_get_8 (abfd, contents + offset - 1);
1244 return (val & 0xc7) == 0x05;
1246 case R_X86_64_TLSDESC_CALL:
1247 /* Check transition from GDesc access model:
1248 call *x@tlsdesc(%rax)
1250 if (offset + 2 <= sec->size)
1252 /* Make sure that it's a call *x@tlsdesc(%rax). */
1253 static const unsigned char call[] = { 0xff, 0x10 };
1254 return memcmp (contents + offset, call, 2) == 0;
1264 /* Return TRUE if the TLS access transition is OK or no transition
1265 will be performed. Update R_TYPE if there is a transition. */
1268 elf_x86_64_tls_transition (struct bfd_link_info *info, bfd *abfd,
1269 asection *sec, bfd_byte *contents,
1270 Elf_Internal_Shdr *symtab_hdr,
1271 struct elf_link_hash_entry **sym_hashes,
1272 unsigned int *r_type, int tls_type,
1273 const Elf_Internal_Rela *rel,
1274 const Elf_Internal_Rela *relend,
1275 struct elf_link_hash_entry *h,
1276 unsigned long r_symndx)
1278 unsigned int from_type = *r_type;
1279 unsigned int to_type = from_type;
1280 bfd_boolean check = TRUE;
1282 /* Skip TLS transition for functions. */
1284 && (h->type == STT_FUNC
1285 || h->type == STT_GNU_IFUNC))
1290 case R_X86_64_TLSGD:
1291 case R_X86_64_GOTPC32_TLSDESC:
1292 case R_X86_64_TLSDESC_CALL:
1293 case R_X86_64_GOTTPOFF:
1294 if (info->executable)
1297 to_type = R_X86_64_TPOFF32;
1299 to_type = R_X86_64_GOTTPOFF;
1302 /* When we are called from elf_x86_64_relocate_section,
1303 CONTENTS isn't NULL and there may be additional transitions
1304 based on TLS_TYPE. */
1305 if (contents != NULL)
1307 unsigned int new_to_type = to_type;
1309 if (info->executable
1312 && tls_type == GOT_TLS_IE)
1313 new_to_type = R_X86_64_TPOFF32;
1315 if (to_type == R_X86_64_TLSGD
1316 || to_type == R_X86_64_GOTPC32_TLSDESC
1317 || to_type == R_X86_64_TLSDESC_CALL)
1319 if (tls_type == GOT_TLS_IE)
1320 new_to_type = R_X86_64_GOTTPOFF;
1323 /* We checked the transition before when we were called from
1324 elf_x86_64_check_relocs. We only want to check the new
1325 transition which hasn't been checked before. */
1326 check = new_to_type != to_type && from_type == to_type;
1327 to_type = new_to_type;
1332 case R_X86_64_TLSLD:
1333 if (info->executable)
1334 to_type = R_X86_64_TPOFF32;
1341 /* Return TRUE if there is no transition. */
1342 if (from_type == to_type)
1345 /* Check if the transition can be performed. */
1347 && ! elf_x86_64_check_tls_transition (abfd, info, sec, contents,
1348 symtab_hdr, sym_hashes,
1349 from_type, rel, relend))
1351 reloc_howto_type *from, *to;
1354 from = elf_x86_64_rtype_to_howto (abfd, from_type);
1355 to = elf_x86_64_rtype_to_howto (abfd, to_type);
1358 name = h->root.root.string;
1361 struct elf_x86_64_link_hash_table *htab;
1363 htab = elf_x86_64_hash_table (info);
1368 Elf_Internal_Sym *isym;
1370 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1372 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1376 (*_bfd_error_handler)
1377 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1378 "in section `%A' failed"),
1379 abfd, sec, from->name, to->name, name,
1380 (unsigned long) rel->r_offset);
1381 bfd_set_error (bfd_error_bad_value);
1389 /* Look through the relocs for a section during the first phase, and
1390 calculate needed space in the global offset table, procedure
1391 linkage table, and dynamic reloc sections. */
1394 elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info,
1396 const Elf_Internal_Rela *relocs)
1398 struct elf_x86_64_link_hash_table *htab;
1399 Elf_Internal_Shdr *symtab_hdr;
1400 struct elf_link_hash_entry **sym_hashes;
1401 const Elf_Internal_Rela *rel;
1402 const Elf_Internal_Rela *rel_end;
1405 if (info->relocatable)
1408 BFD_ASSERT (is_x86_64_elf (abfd));
1410 htab = elf_x86_64_hash_table (info);
1414 symtab_hdr = &elf_symtab_hdr (abfd);
1415 sym_hashes = elf_sym_hashes (abfd);
1419 rel_end = relocs + sec->reloc_count;
1420 for (rel = relocs; rel < rel_end; rel++)
1422 unsigned int r_type;
1423 unsigned long r_symndx;
1424 struct elf_link_hash_entry *h;
1425 Elf_Internal_Sym *isym;
1427 bfd_boolean size_reloc;
1429 r_symndx = htab->r_sym (rel->r_info);
1430 r_type = ELF32_R_TYPE (rel->r_info);
1432 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1434 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1439 if (r_symndx < symtab_hdr->sh_info)
1441 /* A local symbol. */
1442 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1447 /* Check relocation against local STT_GNU_IFUNC symbol. */
1448 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1450 h = elf_x86_64_get_local_sym_hash (htab, abfd, rel,
1455 /* Fake a STT_GNU_IFUNC symbol. */
1456 h->type = STT_GNU_IFUNC;
1459 h->forced_local = 1;
1460 h->root.type = bfd_link_hash_defined;
1468 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1469 while (h->root.type == bfd_link_hash_indirect
1470 || h->root.type == bfd_link_hash_warning)
1471 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1474 /* Check invalid x32 relocations. */
1475 if (!ABI_64_P (abfd))
1481 case R_X86_64_DTPOFF64:
1482 case R_X86_64_TPOFF64:
1484 case R_X86_64_GOTOFF64:
1485 case R_X86_64_GOT64:
1486 case R_X86_64_GOTPCREL64:
1487 case R_X86_64_GOTPC64:
1488 case R_X86_64_GOTPLT64:
1489 case R_X86_64_PLTOFF64:
1492 name = h->root.root.string;
1494 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1496 (*_bfd_error_handler)
1497 (_("%B: relocation %s against symbol `%s' isn't "
1498 "supported in x32 mode"), abfd,
1499 x86_64_elf_howto_table[r_type].name, name);
1500 bfd_set_error (bfd_error_bad_value);
1508 /* Create the ifunc sections for static executables. If we
1509 never see an indirect function symbol nor we are building
1510 a static executable, those sections will be empty and
1511 won't appear in output. */
1522 case R_X86_64_PLT32:
1523 case R_X86_64_GOTPCREL:
1524 case R_X86_64_GOTPCREL64:
1525 if (htab->elf.dynobj == NULL)
1526 htab->elf.dynobj = abfd;
1527 if (!_bfd_elf_create_ifunc_sections (htab->elf.dynobj, info))
1532 /* It is referenced by a non-shared object. */
1536 if (! elf_x86_64_tls_transition (info, abfd, sec, NULL,
1537 symtab_hdr, sym_hashes,
1538 &r_type, GOT_UNKNOWN,
1539 rel, rel_end, h, r_symndx))
1544 case R_X86_64_TLSLD:
1545 htab->tls_ld_got.refcount += 1;
1548 case R_X86_64_TPOFF32:
1549 if (!info->executable && ABI_64_P (abfd))
1552 name = h->root.root.string;
1554 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1556 (*_bfd_error_handler)
1557 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1559 x86_64_elf_howto_table[r_type].name, name);
1560 bfd_set_error (bfd_error_bad_value);
1565 case R_X86_64_GOTTPOFF:
1566 if (!info->executable)
1567 info->flags |= DF_STATIC_TLS;
1570 case R_X86_64_GOT32:
1571 case R_X86_64_GOTPCREL:
1572 case R_X86_64_TLSGD:
1573 case R_X86_64_GOT64:
1574 case R_X86_64_GOTPCREL64:
1575 case R_X86_64_GOTPLT64:
1576 case R_X86_64_GOTPC32_TLSDESC:
1577 case R_X86_64_TLSDESC_CALL:
1578 /* This symbol requires a global offset table entry. */
1580 int tls_type, old_tls_type;
1584 default: tls_type = GOT_NORMAL; break;
1585 case R_X86_64_TLSGD: tls_type = GOT_TLS_GD; break;
1586 case R_X86_64_GOTTPOFF: tls_type = GOT_TLS_IE; break;
1587 case R_X86_64_GOTPC32_TLSDESC:
1588 case R_X86_64_TLSDESC_CALL:
1589 tls_type = GOT_TLS_GDESC; break;
1594 if (r_type == R_X86_64_GOTPLT64)
1596 /* This relocation indicates that we also need
1597 a PLT entry, as this is a function. We don't need
1598 a PLT entry for local symbols. */
1600 h->plt.refcount += 1;
1602 h->got.refcount += 1;
1603 old_tls_type = elf_x86_64_hash_entry (h)->tls_type;
1607 bfd_signed_vma *local_got_refcounts;
1609 /* This is a global offset table entry for a local symbol. */
1610 local_got_refcounts = elf_local_got_refcounts (abfd);
1611 if (local_got_refcounts == NULL)
1615 size = symtab_hdr->sh_info;
1616 size *= sizeof (bfd_signed_vma)
1617 + sizeof (bfd_vma) + sizeof (char);
1618 local_got_refcounts = ((bfd_signed_vma *)
1619 bfd_zalloc (abfd, size));
1620 if (local_got_refcounts == NULL)
1622 elf_local_got_refcounts (abfd) = local_got_refcounts;
1623 elf_x86_64_local_tlsdesc_gotent (abfd)
1624 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
1625 elf_x86_64_local_got_tls_type (abfd)
1626 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
1628 local_got_refcounts[r_symndx] += 1;
1630 = elf_x86_64_local_got_tls_type (abfd) [r_symndx];
1633 /* If a TLS symbol is accessed using IE at least once,
1634 there is no point to use dynamic model for it. */
1635 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1636 && (! GOT_TLS_GD_ANY_P (old_tls_type)
1637 || tls_type != GOT_TLS_IE))
1639 if (old_tls_type == GOT_TLS_IE && GOT_TLS_GD_ANY_P (tls_type))
1640 tls_type = old_tls_type;
1641 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1642 && GOT_TLS_GD_ANY_P (tls_type))
1643 tls_type |= old_tls_type;
1647 name = h->root.root.string;
1649 name = bfd_elf_sym_name (abfd, symtab_hdr,
1651 (*_bfd_error_handler)
1652 (_("%B: '%s' accessed both as normal and thread local symbol"),
1654 bfd_set_error (bfd_error_bad_value);
1659 if (old_tls_type != tls_type)
1662 elf_x86_64_hash_entry (h)->tls_type = tls_type;
1664 elf_x86_64_local_got_tls_type (abfd) [r_symndx] = tls_type;
1669 case R_X86_64_GOTOFF64:
1670 case R_X86_64_GOTPC32:
1671 case R_X86_64_GOTPC64:
1673 if (htab->elf.sgot == NULL)
1675 if (htab->elf.dynobj == NULL)
1676 htab->elf.dynobj = abfd;
1677 if (!_bfd_elf_create_got_section (htab->elf.dynobj,
1683 case R_X86_64_PLT32:
1684 /* This symbol requires a procedure linkage table entry. We
1685 actually build the entry in adjust_dynamic_symbol,
1686 because this might be a case of linking PIC code which is
1687 never referenced by a dynamic object, in which case we
1688 don't need to generate a procedure linkage table entry
1691 /* If this is a local symbol, we resolve it directly without
1692 creating a procedure linkage table entry. */
1697 h->plt.refcount += 1;
1700 case R_X86_64_PLTOFF64:
1701 /* This tries to form the 'address' of a function relative
1702 to GOT. For global symbols we need a PLT entry. */
1706 h->plt.refcount += 1;
1710 case R_X86_64_SIZE32:
1711 case R_X86_64_SIZE64:
1716 if (!ABI_64_P (abfd))
1721 /* Let's help debug shared library creation. These relocs
1722 cannot be used in shared libs. Don't error out for
1723 sections we don't care about, such as debug sections or
1724 non-constant sections. */
1726 && (sec->flags & SEC_ALLOC) != 0
1727 && (sec->flags & SEC_READONLY) != 0)
1730 name = h->root.root.string;
1732 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1733 (*_bfd_error_handler)
1734 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1735 abfd, x86_64_elf_howto_table[r_type].name, name);
1736 bfd_set_error (bfd_error_bad_value);
1747 if (h != NULL && info->executable)
1749 /* If this reloc is in a read-only section, we might
1750 need a copy reloc. We can't check reliably at this
1751 stage whether the section is read-only, as input
1752 sections have not yet been mapped to output sections.
1753 Tentatively set the flag for now, and correct in
1754 adjust_dynamic_symbol. */
1757 /* We may need a .plt entry if the function this reloc
1758 refers to is in a shared lib. */
1759 h->plt.refcount += 1;
1760 if (r_type != R_X86_64_PC32 && r_type != R_X86_64_PC64)
1761 h->pointer_equality_needed = 1;
1766 /* If we are creating a shared library, and this is a reloc
1767 against a global symbol, or a non PC relative reloc
1768 against a local symbol, then we need to copy the reloc
1769 into the shared library. However, if we are linking with
1770 -Bsymbolic, we do not need to copy a reloc against a
1771 global symbol which is defined in an object we are
1772 including in the link (i.e., DEF_REGULAR is set). At
1773 this point we have not seen all the input files, so it is
1774 possible that DEF_REGULAR is not set now but will be set
1775 later (it is never cleared). In case of a weak definition,
1776 DEF_REGULAR may be cleared later by a strong definition in
1777 a shared library. We account for that possibility below by
1778 storing information in the relocs_copied field of the hash
1779 table entry. A similar situation occurs when creating
1780 shared libraries and symbol visibility changes render the
1783 If on the other hand, we are creating an executable, we
1784 may need to keep relocations for symbols satisfied by a
1785 dynamic library if we manage to avoid copy relocs for the
1788 && (sec->flags & SEC_ALLOC) != 0
1789 && (! IS_X86_64_PCREL_TYPE (r_type)
1791 && (! SYMBOLIC_BIND (info, h)
1792 || h->root.type == bfd_link_hash_defweak
1793 || !h->def_regular))))
1794 || (ELIMINATE_COPY_RELOCS
1796 && (sec->flags & SEC_ALLOC) != 0
1798 && (h->root.type == bfd_link_hash_defweak
1799 || !h->def_regular)))
1801 struct elf_dyn_relocs *p;
1802 struct elf_dyn_relocs **head;
1804 /* We must copy these reloc types into the output file.
1805 Create a reloc section in dynobj and make room for
1809 if (htab->elf.dynobj == NULL)
1810 htab->elf.dynobj = abfd;
1812 sreloc = _bfd_elf_make_dynamic_reloc_section
1813 (sec, htab->elf.dynobj, ABI_64_P (abfd) ? 3 : 2,
1814 abfd, /*rela?*/ TRUE);
1820 /* If this is a global symbol, we count the number of
1821 relocations we need for this symbol. */
1824 head = &((struct elf_x86_64_link_hash_entry *) h)->dyn_relocs;
1828 /* Track dynamic relocs needed for local syms too.
1829 We really need local syms available to do this
1834 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1839 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1843 /* Beware of type punned pointers vs strict aliasing
1845 vpp = &(elf_section_data (s)->local_dynrel);
1846 head = (struct elf_dyn_relocs **)vpp;
1850 if (p == NULL || p->sec != sec)
1852 bfd_size_type amt = sizeof *p;
1854 p = ((struct elf_dyn_relocs *)
1855 bfd_alloc (htab->elf.dynobj, amt));
1866 /* Count size relocation as PC-relative relocation. */
1867 if (IS_X86_64_PCREL_TYPE (r_type) || size_reloc)
1872 /* This relocation describes the C++ object vtable hierarchy.
1873 Reconstruct it for later use during GC. */
1874 case R_X86_64_GNU_VTINHERIT:
1875 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1879 /* This relocation describes which C++ vtable entries are actually
1880 used. Record for later use during GC. */
1881 case R_X86_64_GNU_VTENTRY:
1882 BFD_ASSERT (h != NULL);
1884 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1896 /* Return the section that should be marked against GC for a given
1900 elf_x86_64_gc_mark_hook (asection *sec,
1901 struct bfd_link_info *info,
1902 Elf_Internal_Rela *rel,
1903 struct elf_link_hash_entry *h,
1904 Elf_Internal_Sym *sym)
1907 switch (ELF32_R_TYPE (rel->r_info))
1909 case R_X86_64_GNU_VTINHERIT:
1910 case R_X86_64_GNU_VTENTRY:
1914 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1917 /* Update the got entry reference counts for the section being removed. */
1920 elf_x86_64_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1922 const Elf_Internal_Rela *relocs)
1924 struct elf_x86_64_link_hash_table *htab;
1925 Elf_Internal_Shdr *symtab_hdr;
1926 struct elf_link_hash_entry **sym_hashes;
1927 bfd_signed_vma *local_got_refcounts;
1928 const Elf_Internal_Rela *rel, *relend;
1930 if (info->relocatable)
1933 htab = elf_x86_64_hash_table (info);
1937 elf_section_data (sec)->local_dynrel = NULL;
1939 symtab_hdr = &elf_symtab_hdr (abfd);
1940 sym_hashes = elf_sym_hashes (abfd);
1941 local_got_refcounts = elf_local_got_refcounts (abfd);
1943 htab = elf_x86_64_hash_table (info);
1944 relend = relocs + sec->reloc_count;
1945 for (rel = relocs; rel < relend; rel++)
1947 unsigned long r_symndx;
1948 unsigned int r_type;
1949 struct elf_link_hash_entry *h = NULL;
1951 r_symndx = htab->r_sym (rel->r_info);
1952 if (r_symndx >= symtab_hdr->sh_info)
1954 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1955 while (h->root.type == bfd_link_hash_indirect
1956 || h->root.type == bfd_link_hash_warning)
1957 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1961 /* A local symbol. */
1962 Elf_Internal_Sym *isym;
1964 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1967 /* Check relocation against local STT_GNU_IFUNC symbol. */
1969 && ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1971 h = elf_x86_64_get_local_sym_hash (htab, abfd, rel, FALSE);
1979 struct elf_x86_64_link_hash_entry *eh;
1980 struct elf_dyn_relocs **pp;
1981 struct elf_dyn_relocs *p;
1983 eh = (struct elf_x86_64_link_hash_entry *) h;
1985 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1988 /* Everything must go for SEC. */
1994 r_type = ELF32_R_TYPE (rel->r_info);
1995 if (! elf_x86_64_tls_transition (info, abfd, sec, NULL,
1996 symtab_hdr, sym_hashes,
1997 &r_type, GOT_UNKNOWN,
1998 rel, relend, h, r_symndx))
2003 case R_X86_64_TLSLD:
2004 if (htab->tls_ld_got.refcount > 0)
2005 htab->tls_ld_got.refcount -= 1;
2008 case R_X86_64_TLSGD:
2009 case R_X86_64_GOTPC32_TLSDESC:
2010 case R_X86_64_TLSDESC_CALL:
2011 case R_X86_64_GOTTPOFF:
2012 case R_X86_64_GOT32:
2013 case R_X86_64_GOTPCREL:
2014 case R_X86_64_GOT64:
2015 case R_X86_64_GOTPCREL64:
2016 case R_X86_64_GOTPLT64:
2019 if (r_type == R_X86_64_GOTPLT64 && h->plt.refcount > 0)
2020 h->plt.refcount -= 1;
2021 if (h->got.refcount > 0)
2022 h->got.refcount -= 1;
2023 if (h->type == STT_GNU_IFUNC)
2025 if (h->plt.refcount > 0)
2026 h->plt.refcount -= 1;
2029 else if (local_got_refcounts != NULL)
2031 if (local_got_refcounts[r_symndx] > 0)
2032 local_got_refcounts[r_symndx] -= 1;
2045 case R_X86_64_SIZE32:
2046 case R_X86_64_SIZE64:
2048 && (h == NULL || h->type != STT_GNU_IFUNC))
2052 case R_X86_64_PLT32:
2053 case R_X86_64_PLTOFF64:
2056 if (h->plt.refcount > 0)
2057 h->plt.refcount -= 1;
2069 /* Adjust a symbol defined by a dynamic object and referenced by a
2070 regular object. The current definition is in some section of the
2071 dynamic object, but we're not including those sections. We have to
2072 change the definition to something the rest of the link can
2076 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info *info,
2077 struct elf_link_hash_entry *h)
2079 struct elf_x86_64_link_hash_table *htab;
2081 struct elf_x86_64_link_hash_entry *eh;
2082 struct elf_dyn_relocs *p;
2084 /* STT_GNU_IFUNC symbol must go through PLT. */
2085 if (h->type == STT_GNU_IFUNC)
2087 /* All local STT_GNU_IFUNC references must be treate as local
2088 calls via local PLT. */
2090 && SYMBOL_CALLS_LOCAL (info, h))
2092 bfd_size_type pc_count = 0, count = 0;
2093 struct elf_dyn_relocs **pp;
2095 eh = (struct elf_x86_64_link_hash_entry *) h;
2096 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2098 pc_count += p->pc_count;
2099 p->count -= p->pc_count;
2108 if (pc_count || count)
2112 if (h->plt.refcount <= 0)
2113 h->plt.refcount = 1;
2115 h->plt.refcount += 1;
2119 if (h->plt.refcount <= 0)
2121 h->plt.offset = (bfd_vma) -1;
2127 /* If this is a function, put it in the procedure linkage table. We
2128 will fill in the contents of the procedure linkage table later,
2129 when we know the address of the .got section. */
2130 if (h->type == STT_FUNC
2133 if (h->plt.refcount <= 0
2134 || SYMBOL_CALLS_LOCAL (info, h)
2135 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2136 && h->root.type == bfd_link_hash_undefweak))
2138 /* This case can occur if we saw a PLT32 reloc in an input
2139 file, but the symbol was never referred to by a dynamic
2140 object, or if all references were garbage collected. In
2141 such a case, we don't actually need to build a procedure
2142 linkage table, and we can just do a PC32 reloc instead. */
2143 h->plt.offset = (bfd_vma) -1;
2150 /* It's possible that we incorrectly decided a .plt reloc was
2151 needed for an R_X86_64_PC32 reloc to a non-function sym in
2152 check_relocs. We can't decide accurately between function and
2153 non-function syms in check-relocs; Objects loaded later in
2154 the link may change h->type. So fix it now. */
2155 h->plt.offset = (bfd_vma) -1;
2157 /* If this is a weak symbol, and there is a real definition, the
2158 processor independent code will have arranged for us to see the
2159 real definition first, and we can just use the same value. */
2160 if (h->u.weakdef != NULL)
2162 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2163 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2164 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2165 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2166 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
2167 h->non_got_ref = h->u.weakdef->non_got_ref;
2171 /* This is a reference to a symbol defined by a dynamic object which
2172 is not a function. */
2174 /* If we are creating a shared library, we must presume that the
2175 only references to the symbol are via the global offset table.
2176 For such cases we need not do anything here; the relocations will
2177 be handled correctly by relocate_section. */
2181 /* If there are no references to this symbol that do not use the
2182 GOT, we don't need to generate a copy reloc. */
2183 if (!h->non_got_ref)
2186 /* If -z nocopyreloc was given, we won't generate them either. */
2187 if (info->nocopyreloc)
2193 if (ELIMINATE_COPY_RELOCS)
2195 eh = (struct elf_x86_64_link_hash_entry *) h;
2196 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2198 s = p->sec->output_section;
2199 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2203 /* If we didn't find any dynamic relocs in read-only sections, then
2204 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2212 /* We must allocate the symbol in our .dynbss section, which will
2213 become part of the .bss section of the executable. There will be
2214 an entry for this symbol in the .dynsym section. The dynamic
2215 object will contain position independent code, so all references
2216 from the dynamic object to this symbol will go through the global
2217 offset table. The dynamic linker will use the .dynsym entry to
2218 determine the address it must put in the global offset table, so
2219 both the dynamic object and the regular object will refer to the
2220 same memory location for the variable. */
2222 htab = elf_x86_64_hash_table (info);
2226 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2227 to copy the initial value out of the dynamic object and into the
2228 runtime process image. */
2229 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2231 const struct elf_backend_data *bed;
2232 bed = get_elf_backend_data (info->output_bfd);
2233 htab->srelbss->size += bed->s->sizeof_rela;
2239 return _bfd_elf_adjust_dynamic_copy (h, s);
2242 /* Allocate space in .plt, .got and associated reloc sections for
2246 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2248 struct bfd_link_info *info;
2249 struct elf_x86_64_link_hash_table *htab;
2250 struct elf_x86_64_link_hash_entry *eh;
2251 struct elf_dyn_relocs *p;
2252 const struct elf_backend_data *bed;
2253 unsigned int plt_entry_size;
2255 if (h->root.type == bfd_link_hash_indirect)
2258 eh = (struct elf_x86_64_link_hash_entry *) h;
2260 info = (struct bfd_link_info *) inf;
2261 htab = elf_x86_64_hash_table (info);
2264 bed = get_elf_backend_data (info->output_bfd);
2265 plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
2267 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2268 here if it is defined and referenced in a non-shared object. */
2269 if (h->type == STT_GNU_IFUNC
2271 return _bfd_elf_allocate_ifunc_dyn_relocs (info, h,
2275 else if (htab->elf.dynamic_sections_created
2276 && h->plt.refcount > 0)
2278 /* Make sure this symbol is output as a dynamic symbol.
2279 Undefined weak syms won't yet be marked as dynamic. */
2280 if (h->dynindx == -1
2281 && !h->forced_local)
2283 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2288 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2290 asection *s = htab->elf.splt;
2292 /* If this is the first .plt entry, make room for the special
2295 s->size += plt_entry_size;
2297 h->plt.offset = s->size;
2299 /* If this symbol is not defined in a regular file, and we are
2300 not generating a shared library, then set the symbol to this
2301 location in the .plt. This is required to make function
2302 pointers compare as equal between the normal executable and
2303 the shared library. */
2307 h->root.u.def.section = s;
2308 h->root.u.def.value = h->plt.offset;
2311 /* Make room for this entry. */
2312 s->size += plt_entry_size;
2314 /* We also need to make an entry in the .got.plt section, which
2315 will be placed in the .got section by the linker script. */
2316 htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
2318 /* We also need to make an entry in the .rela.plt section. */
2319 htab->elf.srelplt->size += bed->s->sizeof_rela;
2320 htab->elf.srelplt->reloc_count++;
2324 h->plt.offset = (bfd_vma) -1;
2330 h->plt.offset = (bfd_vma) -1;
2334 eh->tlsdesc_got = (bfd_vma) -1;
2336 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2337 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2338 if (h->got.refcount > 0
2341 && elf_x86_64_hash_entry (h)->tls_type == GOT_TLS_IE)
2343 h->got.offset = (bfd_vma) -1;
2345 else if (h->got.refcount > 0)
2349 int tls_type = elf_x86_64_hash_entry (h)->tls_type;
2351 /* Make sure this symbol is output as a dynamic symbol.
2352 Undefined weak syms won't yet be marked as dynamic. */
2353 if (h->dynindx == -1
2354 && !h->forced_local)
2356 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2360 if (GOT_TLS_GDESC_P (tls_type))
2362 eh->tlsdesc_got = htab->elf.sgotplt->size
2363 - elf_x86_64_compute_jump_table_size (htab);
2364 htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
2365 h->got.offset = (bfd_vma) -2;
2367 if (! GOT_TLS_GDESC_P (tls_type)
2368 || GOT_TLS_GD_P (tls_type))
2371 h->got.offset = s->size;
2372 s->size += GOT_ENTRY_SIZE;
2373 if (GOT_TLS_GD_P (tls_type))
2374 s->size += GOT_ENTRY_SIZE;
2376 dyn = htab->elf.dynamic_sections_created;
2377 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2379 R_X86_64_GOTTPOFF needs one dynamic relocation. */
2380 if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
2381 || tls_type == GOT_TLS_IE)
2382 htab->elf.srelgot->size += bed->s->sizeof_rela;
2383 else if (GOT_TLS_GD_P (tls_type))
2384 htab->elf.srelgot->size += 2 * bed->s->sizeof_rela;
2385 else if (! GOT_TLS_GDESC_P (tls_type)
2386 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2387 || h->root.type != bfd_link_hash_undefweak)
2389 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
2390 htab->elf.srelgot->size += bed->s->sizeof_rela;
2391 if (GOT_TLS_GDESC_P (tls_type))
2393 htab->elf.srelplt->size += bed->s->sizeof_rela;
2394 htab->tlsdesc_plt = (bfd_vma) -1;
2398 h->got.offset = (bfd_vma) -1;
2400 if (eh->dyn_relocs == NULL)
2403 /* In the shared -Bsymbolic case, discard space allocated for
2404 dynamic pc-relative relocs against symbols which turn out to be
2405 defined in regular objects. For the normal shared case, discard
2406 space for pc-relative relocs that have become local due to symbol
2407 visibility changes. */
2411 /* Relocs that use pc_count are those that appear on a call
2412 insn, or certain REL relocs that can generated via assembly.
2413 We want calls to protected symbols to resolve directly to the
2414 function rather than going via the plt. If people want
2415 function pointer comparisons to work as expected then they
2416 should avoid writing weird assembly. */
2417 if (SYMBOL_CALLS_LOCAL (info, h))
2419 struct elf_dyn_relocs **pp;
2421 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2423 p->count -= p->pc_count;
2432 /* Also discard relocs on undefined weak syms with non-default
2434 if (eh->dyn_relocs != NULL
2435 && h->root.type == bfd_link_hash_undefweak)
2437 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2438 eh->dyn_relocs = NULL;
2440 /* Make sure undefined weak symbols are output as a dynamic
2442 else if (h->dynindx == -1
2443 && ! h->forced_local
2444 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2449 else if (ELIMINATE_COPY_RELOCS)
2451 /* For the non-shared case, discard space for relocs against
2452 symbols which turn out to need copy relocs or are not
2458 || (htab->elf.dynamic_sections_created
2459 && (h->root.type == bfd_link_hash_undefweak
2460 || h->root.type == bfd_link_hash_undefined))))
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
2465 && ! h->forced_local
2466 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2469 /* If that succeeded, we know we'll be keeping all the
2471 if (h->dynindx != -1)
2475 eh->dyn_relocs = NULL;
2480 /* Finally, allocate space. */
2481 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2485 sreloc = elf_section_data (p->sec)->sreloc;
2487 BFD_ASSERT (sreloc != NULL);
2489 sreloc->size += p->count * bed->s->sizeof_rela;
2495 /* Allocate space in .plt, .got and associated reloc sections for
2496 local dynamic relocs. */
2499 elf_x86_64_allocate_local_dynrelocs (void **slot, void *inf)
2501 struct elf_link_hash_entry *h
2502 = (struct elf_link_hash_entry *) *slot;
2504 if (h->type != STT_GNU_IFUNC
2508 || h->root.type != bfd_link_hash_defined)
2511 return elf_x86_64_allocate_dynrelocs (h, inf);
2514 /* Find any dynamic relocs that apply to read-only sections. */
2517 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry *h,
2520 struct elf_x86_64_link_hash_entry *eh;
2521 struct elf_dyn_relocs *p;
2523 /* Skip local IFUNC symbols. */
2524 if (h->forced_local && h->type == STT_GNU_IFUNC)
2527 eh = (struct elf_x86_64_link_hash_entry *) h;
2528 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2530 asection *s = p->sec->output_section;
2532 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2534 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2536 info->flags |= DF_TEXTREL;
2538 if (info->warn_shared_textrel && info->shared)
2539 info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2540 p->sec->owner, h->root.root.string,
2543 /* Not an error, just cut short the traversal. */
2551 mov foo@GOTPCREL(%rip), %reg
2554 with the local symbol, foo. */
2557 elf_x86_64_convert_mov_to_lea (bfd *abfd, asection *sec,
2558 struct bfd_link_info *link_info)
2560 Elf_Internal_Shdr *symtab_hdr;
2561 Elf_Internal_Rela *internal_relocs;
2562 Elf_Internal_Rela *irel, *irelend;
2564 struct elf_x86_64_link_hash_table *htab;
2565 bfd_boolean changed_contents;
2566 bfd_boolean changed_relocs;
2567 bfd_signed_vma *local_got_refcounts;
2569 /* Don't even try to convert non-ELF outputs. */
2570 if (!is_elf_hash_table (link_info->hash))
2573 /* Nothing to do if there are no codes, no relocations or no output. */
2574 if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
2575 || sec->reloc_count == 0
2576 || discarded_section (sec))
2579 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2581 /* Load the relocations for this section. */
2582 internal_relocs = (_bfd_elf_link_read_relocs
2583 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
2584 link_info->keep_memory));
2585 if (internal_relocs == NULL)
2588 htab = elf_x86_64_hash_table (link_info);
2589 changed_contents = FALSE;
2590 changed_relocs = FALSE;
2591 local_got_refcounts = elf_local_got_refcounts (abfd);
2593 /* Get the section contents. */
2594 if (elf_section_data (sec)->this_hdr.contents != NULL)
2595 contents = elf_section_data (sec)->this_hdr.contents;
2598 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
2602 irelend = internal_relocs + sec->reloc_count;
2603 for (irel = internal_relocs; irel < irelend; irel++)
2605 unsigned int r_type = ELF32_R_TYPE (irel->r_info);
2606 unsigned int r_symndx = htab->r_sym (irel->r_info);
2608 struct elf_link_hash_entry *h;
2610 if (r_type != R_X86_64_GOTPCREL)
2613 /* Get the symbol referred to by the reloc. */
2614 if (r_symndx < symtab_hdr->sh_info)
2616 Elf_Internal_Sym *isym;
2618 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2621 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. */
2622 if (ELF_ST_TYPE (isym->st_info) != STT_GNU_IFUNC
2623 && bfd_get_8 (input_bfd,
2624 contents + irel->r_offset - 2) == 0x8b)
2626 bfd_put_8 (output_bfd, 0x8d,
2627 contents + irel->r_offset - 2);
2628 irel->r_info = htab->r_info (r_symndx, R_X86_64_PC32);
2629 if (local_got_refcounts != NULL
2630 && local_got_refcounts[r_symndx] > 0)
2631 local_got_refcounts[r_symndx] -= 1;
2632 changed_contents = TRUE;
2633 changed_relocs = TRUE;
2638 indx = r_symndx - symtab_hdr->sh_info;
2639 h = elf_sym_hashes (abfd)[indx];
2640 BFD_ASSERT (h != NULL);
2642 while (h->root.type == bfd_link_hash_indirect
2643 || h->root.type == bfd_link_hash_warning)
2644 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2646 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. We also
2647 avoid optimizing _DYNAMIC since ld.so may use its link-time
2650 && h->type != STT_GNU_IFUNC
2651 && h != htab->elf.hdynamic
2652 && SYMBOL_REFERENCES_LOCAL (link_info, h)
2653 && bfd_get_8 (input_bfd,
2654 contents + irel->r_offset - 2) == 0x8b)
2656 bfd_put_8 (output_bfd, 0x8d,
2657 contents + irel->r_offset - 2);
2658 irel->r_info = htab->r_info (r_symndx, R_X86_64_PC32);
2659 if (h->got.refcount > 0)
2660 h->got.refcount -= 1;
2661 changed_contents = TRUE;
2662 changed_relocs = TRUE;
2666 if (contents != NULL
2667 && elf_section_data (sec)->this_hdr.contents != contents)
2669 if (!changed_contents && !link_info->keep_memory)
2673 /* Cache the section contents for elf_link_input_bfd. */
2674 elf_section_data (sec)->this_hdr.contents = contents;
2678 if (elf_section_data (sec)->relocs != internal_relocs)
2680 if (!changed_relocs)
2681 free (internal_relocs);
2683 elf_section_data (sec)->relocs = internal_relocs;
2689 if (contents != NULL
2690 && elf_section_data (sec)->this_hdr.contents != contents)
2692 if (internal_relocs != NULL
2693 && elf_section_data (sec)->relocs != internal_relocs)
2694 free (internal_relocs);
2698 /* Set the sizes of the dynamic sections. */
2701 elf_x86_64_size_dynamic_sections (bfd *output_bfd,
2702 struct bfd_link_info *info)
2704 struct elf_x86_64_link_hash_table *htab;
2709 const struct elf_backend_data *bed;
2711 htab = elf_x86_64_hash_table (info);
2714 bed = get_elf_backend_data (output_bfd);
2716 dynobj = htab->elf.dynobj;
2720 if (htab->elf.dynamic_sections_created)
2722 /* Set the contents of the .interp section to the interpreter. */
2723 if (info->executable)
2725 s = bfd_get_linker_section (dynobj, ".interp");
2728 s->size = htab->dynamic_interpreter_size;
2729 s->contents = (unsigned char *) htab->dynamic_interpreter;
2733 /* Set up .got offsets for local syms, and space for local dynamic
2735 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2737 bfd_signed_vma *local_got;
2738 bfd_signed_vma *end_local_got;
2739 char *local_tls_type;
2740 bfd_vma *local_tlsdesc_gotent;
2741 bfd_size_type locsymcount;
2742 Elf_Internal_Shdr *symtab_hdr;
2745 if (! is_x86_64_elf (ibfd))
2748 for (s = ibfd->sections; s != NULL; s = s->next)
2750 struct elf_dyn_relocs *p;
2752 if (!elf_x86_64_convert_mov_to_lea (ibfd, s, info))
2755 for (p = (struct elf_dyn_relocs *)
2756 (elf_section_data (s)->local_dynrel);
2760 if (!bfd_is_abs_section (p->sec)
2761 && bfd_is_abs_section (p->sec->output_section))
2763 /* Input section has been discarded, either because
2764 it is a copy of a linkonce section or due to
2765 linker script /DISCARD/, so we'll be discarding
2768 else if (p->count != 0)
2770 srel = elf_section_data (p->sec)->sreloc;
2771 srel->size += p->count * bed->s->sizeof_rela;
2772 if ((p->sec->output_section->flags & SEC_READONLY) != 0
2773 && (info->flags & DF_TEXTREL) == 0)
2775 info->flags |= DF_TEXTREL;
2776 if (info->warn_shared_textrel && info->shared)
2777 info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
2778 p->sec->owner, p->sec);
2784 local_got = elf_local_got_refcounts (ibfd);
2788 symtab_hdr = &elf_symtab_hdr (ibfd);
2789 locsymcount = symtab_hdr->sh_info;
2790 end_local_got = local_got + locsymcount;
2791 local_tls_type = elf_x86_64_local_got_tls_type (ibfd);
2792 local_tlsdesc_gotent = elf_x86_64_local_tlsdesc_gotent (ibfd);
2794 srel = htab->elf.srelgot;
2795 for (; local_got < end_local_got;
2796 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
2798 *local_tlsdesc_gotent = (bfd_vma) -1;
2801 if (GOT_TLS_GDESC_P (*local_tls_type))
2803 *local_tlsdesc_gotent = htab->elf.sgotplt->size
2804 - elf_x86_64_compute_jump_table_size (htab);
2805 htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
2806 *local_got = (bfd_vma) -2;
2808 if (! GOT_TLS_GDESC_P (*local_tls_type)
2809 || GOT_TLS_GD_P (*local_tls_type))
2811 *local_got = s->size;
2812 s->size += GOT_ENTRY_SIZE;
2813 if (GOT_TLS_GD_P (*local_tls_type))
2814 s->size += GOT_ENTRY_SIZE;
2817 || GOT_TLS_GD_ANY_P (*local_tls_type)
2818 || *local_tls_type == GOT_TLS_IE)
2820 if (GOT_TLS_GDESC_P (*local_tls_type))
2822 htab->elf.srelplt->size
2823 += bed->s->sizeof_rela;
2824 htab->tlsdesc_plt = (bfd_vma) -1;
2826 if (! GOT_TLS_GDESC_P (*local_tls_type)
2827 || GOT_TLS_GD_P (*local_tls_type))
2828 srel->size += bed->s->sizeof_rela;
2832 *local_got = (bfd_vma) -1;
2836 if (htab->tls_ld_got.refcount > 0)
2838 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
2840 htab->tls_ld_got.offset = htab->elf.sgot->size;
2841 htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
2842 htab->elf.srelgot->size += bed->s->sizeof_rela;
2845 htab->tls_ld_got.offset = -1;
2847 /* Allocate global sym .plt and .got entries, and space for global
2848 sym dynamic relocs. */
2849 elf_link_hash_traverse (&htab->elf, elf_x86_64_allocate_dynrelocs,
2852 /* Allocate .plt and .got entries, and space for local symbols. */
2853 htab_traverse (htab->loc_hash_table,
2854 elf_x86_64_allocate_local_dynrelocs,
2857 /* For every jump slot reserved in the sgotplt, reloc_count is
2858 incremented. However, when we reserve space for TLS descriptors,
2859 it's not incremented, so in order to compute the space reserved
2860 for them, it suffices to multiply the reloc count by the jump
2863 PR ld/13302: We start next_irelative_index at the end of .rela.plt
2864 so that R_X86_64_IRELATIVE entries come last. */
2865 if (htab->elf.srelplt)
2867 htab->sgotplt_jump_table_size
2868 = elf_x86_64_compute_jump_table_size (htab);
2869 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
2871 else if (htab->elf.irelplt)
2872 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
2874 if (htab->tlsdesc_plt)
2876 /* If we're not using lazy TLS relocations, don't generate the
2877 PLT and GOT entries they require. */
2878 if ((info->flags & DF_BIND_NOW))
2879 htab->tlsdesc_plt = 0;
2882 htab->tlsdesc_got = htab->elf.sgot->size;
2883 htab->elf.sgot->size += GOT_ENTRY_SIZE;
2884 /* Reserve room for the initial entry.
2885 FIXME: we could probably do away with it in this case. */
2886 if (htab->elf.splt->size == 0)
2887 htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd);
2888 htab->tlsdesc_plt = htab->elf.splt->size;
2889 htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd);
2893 if (htab->elf.sgotplt)
2895 /* Don't allocate .got.plt section if there are no GOT nor PLT
2896 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
2897 if ((htab->elf.hgot == NULL
2898 || !htab->elf.hgot->ref_regular_nonweak)
2899 && (htab->elf.sgotplt->size
2900 == get_elf_backend_data (output_bfd)->got_header_size)
2901 && (htab->elf.splt == NULL
2902 || htab->elf.splt->size == 0)
2903 && (htab->elf.sgot == NULL
2904 || htab->elf.sgot->size == 0)
2905 && (htab->elf.iplt == NULL
2906 || htab->elf.iplt->size == 0)
2907 && (htab->elf.igotplt == NULL
2908 || htab->elf.igotplt->size == 0))
2909 htab->elf.sgotplt->size = 0;
2912 if (htab->plt_eh_frame != NULL
2913 && htab->elf.splt != NULL
2914 && htab->elf.splt->size != 0
2915 && !bfd_is_abs_section (htab->elf.splt->output_section)
2916 && _bfd_elf_eh_frame_present (info))
2918 const struct elf_x86_64_backend_data *arch_data
2919 = (const struct elf_x86_64_backend_data *) bed->arch_data;
2920 htab->plt_eh_frame->size = arch_data->eh_frame_plt_size;
2923 /* We now have determined the sizes of the various dynamic sections.
2924 Allocate memory for them. */
2926 for (s = dynobj->sections; s != NULL; s = s->next)
2928 if ((s->flags & SEC_LINKER_CREATED) == 0)
2931 if (s == htab->elf.splt
2932 || s == htab->elf.sgot
2933 || s == htab->elf.sgotplt
2934 || s == htab->elf.iplt
2935 || s == htab->elf.igotplt
2936 || s == htab->plt_eh_frame
2937 || s == htab->sdynbss)
2939 /* Strip this section if we don't need it; see the
2942 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2944 if (s->size != 0 && s != htab->elf.srelplt)
2947 /* We use the reloc_count field as a counter if we need
2948 to copy relocs into the output file. */
2949 if (s != htab->elf.srelplt)
2954 /* It's not one of our sections, so don't allocate space. */
2960 /* If we don't need this section, strip it from the
2961 output file. This is mostly to handle .rela.bss and
2962 .rela.plt. We must create both sections in
2963 create_dynamic_sections, because they must be created
2964 before the linker maps input sections to output
2965 sections. The linker does that before
2966 adjust_dynamic_symbol is called, and it is that
2967 function which decides whether anything needs to go
2968 into these sections. */
2970 s->flags |= SEC_EXCLUDE;
2974 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2977 /* Allocate memory for the section contents. We use bfd_zalloc
2978 here in case unused entries are not reclaimed before the
2979 section's contents are written out. This should not happen,
2980 but this way if it does, we get a R_X86_64_NONE reloc instead
2982 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2983 if (s->contents == NULL)
2987 if (htab->plt_eh_frame != NULL
2988 && htab->plt_eh_frame->contents != NULL)
2990 const struct elf_x86_64_backend_data *arch_data
2991 = (const struct elf_x86_64_backend_data *) bed->arch_data;
2993 memcpy (htab->plt_eh_frame->contents,
2994 arch_data->eh_frame_plt, htab->plt_eh_frame->size);
2995 bfd_put_32 (dynobj, htab->elf.splt->size,
2996 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
2999 if (htab->elf.dynamic_sections_created)
3001 /* Add some entries to the .dynamic section. We fill in the
3002 values later, in elf_x86_64_finish_dynamic_sections, but we
3003 must add the entries now so that we get the correct size for
3004 the .dynamic section. The DT_DEBUG entry is filled in by the
3005 dynamic linker and used by the debugger. */
3006 #define add_dynamic_entry(TAG, VAL) \
3007 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3009 if (info->executable)
3011 if (!add_dynamic_entry (DT_DEBUG, 0))
3015 if (htab->elf.splt->size != 0)
3017 if (!add_dynamic_entry (DT_PLTGOT, 0)
3018 || !add_dynamic_entry (DT_PLTRELSZ, 0)
3019 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3020 || !add_dynamic_entry (DT_JMPREL, 0))
3023 if (htab->tlsdesc_plt
3024 && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
3025 || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
3031 if (!add_dynamic_entry (DT_RELA, 0)
3032 || !add_dynamic_entry (DT_RELASZ, 0)
3033 || !add_dynamic_entry (DT_RELAENT, bed->s->sizeof_rela))
3036 /* If any dynamic relocs apply to a read-only section,
3037 then we need a DT_TEXTREL entry. */
3038 if ((info->flags & DF_TEXTREL) == 0)
3039 elf_link_hash_traverse (&htab->elf,
3040 elf_x86_64_readonly_dynrelocs,
3043 if ((info->flags & DF_TEXTREL) != 0)
3045 if (!add_dynamic_entry (DT_TEXTREL, 0))
3050 #undef add_dynamic_entry
3056 elf_x86_64_always_size_sections (bfd *output_bfd,
3057 struct bfd_link_info *info)
3059 asection *tls_sec = elf_hash_table (info)->tls_sec;
3063 struct elf_link_hash_entry *tlsbase;
3065 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
3066 "_TLS_MODULE_BASE_",
3067 FALSE, FALSE, FALSE);
3069 if (tlsbase && tlsbase->type == STT_TLS)
3071 struct elf_x86_64_link_hash_table *htab;
3072 struct bfd_link_hash_entry *bh = NULL;
3073 const struct elf_backend_data *bed
3074 = get_elf_backend_data (output_bfd);
3076 htab = elf_x86_64_hash_table (info);
3080 if (!(_bfd_generic_link_add_one_symbol
3081 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
3082 tls_sec, 0, NULL, FALSE,
3083 bed->collect, &bh)))
3086 htab->tls_module_base = bh;
3088 tlsbase = (struct elf_link_hash_entry *)bh;
3089 tlsbase->def_regular = 1;
3090 tlsbase->other = STV_HIDDEN;
3091 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
3098 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3099 executables. Rather than setting it to the beginning of the TLS
3100 section, we have to set it to the end. This function may be called
3101 multiple times, it is idempotent. */
3104 elf_x86_64_set_tls_module_base (struct bfd_link_info *info)
3106 struct elf_x86_64_link_hash_table *htab;
3107 struct bfd_link_hash_entry *base;
3109 if (!info->executable)
3112 htab = elf_x86_64_hash_table (info);
3116 base = htab->tls_module_base;
3120 base->u.def.value = htab->elf.tls_size;
3123 /* Return the base VMA address which should be subtracted from real addresses
3124 when resolving @dtpoff relocation.
3125 This is PT_TLS segment p_vaddr. */
3128 elf_x86_64_dtpoff_base (struct bfd_link_info *info)
3130 /* If tls_sec is NULL, we should have signalled an error already. */
3131 if (elf_hash_table (info)->tls_sec == NULL)
3133 return elf_hash_table (info)->tls_sec->vma;
3136 /* Return the relocation value for @tpoff relocation
3137 if STT_TLS virtual address is ADDRESS. */
3140 elf_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address)
3142 struct elf_link_hash_table *htab = elf_hash_table (info);
3143 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3144 bfd_vma static_tls_size;
3146 /* If tls_segment is NULL, we should have signalled an error already. */
3147 if (htab->tls_sec == NULL)
3150 /* Consider special static TLS alignment requirements. */
3151 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3152 return address - static_tls_size - htab->tls_sec->vma;
3155 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
3159 is_32bit_relative_branch (bfd_byte *contents, bfd_vma offset)
3161 /* Opcode Instruction
3164 0x0f 0x8x conditional jump */
3166 && (contents [offset - 1] == 0xe8
3167 || contents [offset - 1] == 0xe9))
3169 && contents [offset - 2] == 0x0f
3170 && (contents [offset - 1] & 0xf0) == 0x80));
3173 /* Relocate an x86_64 ELF section. */
3176 elf_x86_64_relocate_section (bfd *output_bfd,
3177 struct bfd_link_info *info,
3179 asection *input_section,
3181 Elf_Internal_Rela *relocs,
3182 Elf_Internal_Sym *local_syms,
3183 asection **local_sections)
3185 struct elf_x86_64_link_hash_table *htab;
3186 Elf_Internal_Shdr *symtab_hdr;
3187 struct elf_link_hash_entry **sym_hashes;
3188 bfd_vma *local_got_offsets;
3189 bfd_vma *local_tlsdesc_gotents;
3190 Elf_Internal_Rela *rel;
3191 Elf_Internal_Rela *relend;
3192 const unsigned int plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
3194 BFD_ASSERT (is_x86_64_elf (input_bfd));
3196 htab = elf_x86_64_hash_table (info);
3199 symtab_hdr = &elf_symtab_hdr (input_bfd);
3200 sym_hashes = elf_sym_hashes (input_bfd);
3201 local_got_offsets = elf_local_got_offsets (input_bfd);
3202 local_tlsdesc_gotents = elf_x86_64_local_tlsdesc_gotent (input_bfd);
3204 elf_x86_64_set_tls_module_base (info);
3207 relend = relocs + input_section->reloc_count;
3208 for (; rel < relend; rel++)
3210 unsigned int r_type;
3211 reloc_howto_type *howto;
3212 unsigned long r_symndx;
3213 struct elf_link_hash_entry *h;
3214 Elf_Internal_Sym *sym;
3216 bfd_vma off, offplt;
3218 bfd_boolean unresolved_reloc;
3219 bfd_reloc_status_type r;
3224 r_type = ELF32_R_TYPE (rel->r_info);
3225 if (r_type == (int) R_X86_64_GNU_VTINHERIT
3226 || r_type == (int) R_X86_64_GNU_VTENTRY)
3229 if (r_type >= (int) R_X86_64_standard)
3231 (*_bfd_error_handler)
3232 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3233 input_bfd, input_section, r_type);
3234 bfd_set_error (bfd_error_bad_value);
3238 if (r_type != (int) R_X86_64_32
3239 || ABI_64_P (output_bfd))
3240 howto = x86_64_elf_howto_table + r_type;
3242 howto = (x86_64_elf_howto_table
3243 + ARRAY_SIZE (x86_64_elf_howto_table) - 1);
3244 r_symndx = htab->r_sym (rel->r_info);
3248 unresolved_reloc = FALSE;
3249 if (r_symndx < symtab_hdr->sh_info)
3251 sym = local_syms + r_symndx;
3252 sec = local_sections[r_symndx];
3254 relocation = _bfd_elf_rela_local_sym (output_bfd, sym,
3256 st_size = sym->st_size;
3258 /* Relocate against local STT_GNU_IFUNC symbol. */
3259 if (!info->relocatable
3260 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3262 h = elf_x86_64_get_local_sym_hash (htab, input_bfd,
3267 /* Set STT_GNU_IFUNC symbol value. */
3268 h->root.u.def.value = sym->st_value;
3269 h->root.u.def.section = sec;
3274 bfd_boolean warned ATTRIBUTE_UNUSED;
3276 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3277 r_symndx, symtab_hdr, sym_hashes,
3279 unresolved_reloc, warned);
3283 if (sec != NULL && discarded_section (sec))
3284 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3285 rel, 1, relend, howto, 0, contents);
3287 if (info->relocatable)
3290 if (rel->r_addend == 0 && !ABI_64_P (output_bfd))
3292 if (r_type == R_X86_64_64)
3294 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
3295 zero-extend it to 64bit if addend is zero. */
3296 r_type = R_X86_64_32;
3297 memset (contents + rel->r_offset + 4, 0, 4);
3299 else if (r_type == R_X86_64_SIZE64)
3301 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
3302 zero-extend it to 64bit if addend is zero. */
3303 r_type = R_X86_64_SIZE32;
3304 memset (contents + rel->r_offset + 4, 0, 4);
3308 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3309 it here if it is defined in a non-shared object. */
3311 && h->type == STT_GNU_IFUNC
3318 if ((input_section->flags & SEC_ALLOC) == 0
3319 || h->plt.offset == (bfd_vma) -1)
3322 /* STT_GNU_IFUNC symbol must go through PLT. */
3323 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
3324 relocation = (plt->output_section->vma
3325 + plt->output_offset + h->plt.offset);
3330 if (h->root.root.string)
3331 name = h->root.root.string;
3333 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3335 (*_bfd_error_handler)
3336 (_("%B: relocation %s against STT_GNU_IFUNC "
3337 "symbol `%s' isn't handled by %s"), input_bfd,
3338 x86_64_elf_howto_table[r_type].name,
3339 name, __FUNCTION__);
3340 bfd_set_error (bfd_error_bad_value);
3349 if (ABI_64_P (output_bfd))
3353 if (rel->r_addend != 0)
3355 if (h->root.root.string)
3356 name = h->root.root.string;
3358 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
3360 (*_bfd_error_handler)
3361 (_("%B: relocation %s against STT_GNU_IFUNC "
3362 "symbol `%s' has non-zero addend: %d"),
3363 input_bfd, x86_64_elf_howto_table[r_type].name,
3364 name, rel->r_addend);
3365 bfd_set_error (bfd_error_bad_value);
3369 /* Generate dynamic relcoation only when there is a
3370 non-GOT reference in a shared object. */
3371 if (info->shared && h->non_got_ref)
3373 Elf_Internal_Rela outrel;
3376 /* Need a dynamic relocation to get the real function
3378 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
3382 if (outrel.r_offset == (bfd_vma) -1
3383 || outrel.r_offset == (bfd_vma) -2)
3386 outrel.r_offset += (input_section->output_section->vma
3387 + input_section->output_offset);
3389 if (h->dynindx == -1
3391 || info->executable)
3393 /* This symbol is resolved locally. */
3394 outrel.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
3395 outrel.r_addend = (h->root.u.def.value
3396 + h->root.u.def.section->output_section->vma
3397 + h->root.u.def.section->output_offset);
3401 outrel.r_info = htab->r_info (h->dynindx, r_type);
3402 outrel.r_addend = 0;
3405 sreloc = htab->elf.irelifunc;
3406 elf_append_rela (output_bfd, sreloc, &outrel);
3408 /* If this reloc is against an external symbol, we
3409 do not want to fiddle with the addend. Otherwise,
3410 we need to include the symbol value so that it
3411 becomes an addend for the dynamic reloc. For an
3412 internal symbol, we have updated addend. */
3418 case R_X86_64_PLT32:
3421 case R_X86_64_GOTPCREL:
3422 case R_X86_64_GOTPCREL64:
3423 base_got = htab->elf.sgot;
3424 off = h->got.offset;
3426 if (base_got == NULL)
3429 if (off == (bfd_vma) -1)
3431 /* We can't use h->got.offset here to save state, or
3432 even just remember the offset, as finish_dynamic_symbol
3433 would use that as offset into .got. */
3435 if (htab->elf.splt != NULL)
3437 plt_index = h->plt.offset / plt_entry_size - 1;
3438 off = (plt_index + 3) * GOT_ENTRY_SIZE;
3439 base_got = htab->elf.sgotplt;
3443 plt_index = h->plt.offset / plt_entry_size;
3444 off = plt_index * GOT_ENTRY_SIZE;
3445 base_got = htab->elf.igotplt;
3448 if (h->dynindx == -1
3452 /* This references the local defitionion. We must
3453 initialize this entry in the global offset table.
3454 Since the offset must always be a multiple of 8,
3455 we use the least significant bit to record
3456 whether we have initialized it already.
3458 When doing a dynamic link, we create a .rela.got
3459 relocation entry to initialize the value. This
3460 is done in the finish_dynamic_symbol routine. */
3465 bfd_put_64 (output_bfd, relocation,
3466 base_got->contents + off);
3467 /* Note that this is harmless for the GOTPLT64
3468 case, as -1 | 1 still is -1. */
3474 relocation = (base_got->output_section->vma
3475 + base_got->output_offset + off);
3481 /* When generating a shared object, the relocations handled here are
3482 copied into the output file to be resolved at run time. */
3485 case R_X86_64_GOT32:
3486 case R_X86_64_GOT64:
3487 /* Relocation is to the entry for this symbol in the global
3489 case R_X86_64_GOTPCREL:
3490 case R_X86_64_GOTPCREL64:
3491 /* Use global offset table entry as symbol value. */
3492 case R_X86_64_GOTPLT64:
3493 /* This is the same as GOT64 for relocation purposes, but
3494 indicates the existence of a PLT entry. The difficulty is,
3495 that we must calculate the GOT slot offset from the PLT
3496 offset, if this symbol got a PLT entry (it was global).
3497 Additionally if it's computed from the PLT entry, then that
3498 GOT offset is relative to .got.plt, not to .got. */
3499 base_got = htab->elf.sgot;
3501 if (htab->elf.sgot == NULL)
3508 off = h->got.offset;
3510 && h->plt.offset != (bfd_vma)-1
3511 && off == (bfd_vma)-1)
3513 /* We can't use h->got.offset here to save
3514 state, or even just remember the offset, as
3515 finish_dynamic_symbol would use that as offset into
3517 bfd_vma plt_index = h->plt.offset / plt_entry_size - 1;
3518 off = (plt_index + 3) * GOT_ENTRY_SIZE;
3519 base_got = htab->elf.sgotplt;
3522 dyn = htab->elf.dynamic_sections_created;
3524 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3526 && SYMBOL_REFERENCES_LOCAL (info, h))
3527 || (ELF_ST_VISIBILITY (h->other)
3528 && h->root.type == bfd_link_hash_undefweak))
3530 /* This is actually a static link, or it is a -Bsymbolic
3531 link and the symbol is defined locally, or the symbol
3532 was forced to be local because of a version file. We
3533 must initialize this entry in the global offset table.
3534 Since the offset must always be a multiple of 8, we
3535 use the least significant bit to record whether we
3536 have initialized it already.
3538 When doing a dynamic link, we create a .rela.got
3539 relocation entry to initialize the value. This is
3540 done in the finish_dynamic_symbol routine. */
3545 bfd_put_64 (output_bfd, relocation,
3546 base_got->contents + off);
3547 /* Note that this is harmless for the GOTPLT64 case,
3548 as -1 | 1 still is -1. */
3553 unresolved_reloc = FALSE;
3557 if (local_got_offsets == NULL)
3560 off = local_got_offsets[r_symndx];
3562 /* The offset must always be a multiple of 8. We use
3563 the least significant bit to record whether we have
3564 already generated the necessary reloc. */
3569 bfd_put_64 (output_bfd, relocation,
3570 base_got->contents + off);
3575 Elf_Internal_Rela outrel;
3577 /* We need to generate a R_X86_64_RELATIVE reloc
3578 for the dynamic linker. */
3579 s = htab->elf.srelgot;
3583 outrel.r_offset = (base_got->output_section->vma
3584 + base_got->output_offset
3586 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
3587 outrel.r_addend = relocation;
3588 elf_append_rela (output_bfd, s, &outrel);
3591 local_got_offsets[r_symndx] |= 1;
3595 if (off >= (bfd_vma) -2)
3598 relocation = base_got->output_section->vma
3599 + base_got->output_offset + off;
3600 if (r_type != R_X86_64_GOTPCREL && r_type != R_X86_64_GOTPCREL64)
3601 relocation -= htab->elf.sgotplt->output_section->vma
3602 - htab->elf.sgotplt->output_offset;
3606 case R_X86_64_GOTOFF64:
3607 /* Relocation is relative to the start of the global offset
3610 /* Check to make sure it isn't a protected function symbol
3611 for shared library since it may not be local when used
3612 as function address. */
3613 if (!info->executable
3615 && !SYMBOLIC_BIND (info, h)
3617 && h->type == STT_FUNC
3618 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
3620 (*_bfd_error_handler)
3621 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
3622 input_bfd, h->root.root.string);
3623 bfd_set_error (bfd_error_bad_value);
3627 /* Note that sgot is not involved in this
3628 calculation. We always want the start of .got.plt. If we
3629 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3630 permitted by the ABI, we might have to change this
3632 relocation -= htab->elf.sgotplt->output_section->vma
3633 + htab->elf.sgotplt->output_offset;
3636 case R_X86_64_GOTPC32:
3637 case R_X86_64_GOTPC64:
3638 /* Use global offset table as symbol value. */
3639 relocation = htab->elf.sgotplt->output_section->vma
3640 + htab->elf.sgotplt->output_offset;
3641 unresolved_reloc = FALSE;
3644 case R_X86_64_PLTOFF64:
3645 /* Relocation is PLT entry relative to GOT. For local
3646 symbols it's the symbol itself relative to GOT. */
3648 /* See PLT32 handling. */
3649 && h->plt.offset != (bfd_vma) -1
3650 && htab->elf.splt != NULL)
3652 relocation = (htab->elf.splt->output_section->vma
3653 + htab->elf.splt->output_offset
3655 unresolved_reloc = FALSE;
3658 relocation -= htab->elf.sgotplt->output_section->vma
3659 + htab->elf.sgotplt->output_offset;
3662 case R_X86_64_PLT32:
3663 /* Relocation is to the entry for this symbol in the
3664 procedure linkage table. */
3666 /* Resolve a PLT32 reloc against a local symbol directly,
3667 without using the procedure linkage table. */
3671 if (h->plt.offset == (bfd_vma) -1
3672 || htab->elf.splt == NULL)
3674 /* We didn't make a PLT entry for this symbol. This
3675 happens when statically linking PIC code, or when
3676 using -Bsymbolic. */
3680 relocation = (htab->elf.splt->output_section->vma
3681 + htab->elf.splt->output_offset
3683 unresolved_reloc = FALSE;
3686 case R_X86_64_SIZE32:
3687 case R_X86_64_SIZE64:
3688 /* Set to symbol size. */
3689 relocation = st_size;
3696 && (input_section->flags & SEC_ALLOC) != 0
3697 && (input_section->flags & SEC_READONLY) != 0
3700 bfd_boolean fail = FALSE;
3702 = (r_type == R_X86_64_PC32
3703 && is_32bit_relative_branch (contents, rel->r_offset));
3705 if (SYMBOL_REFERENCES_LOCAL (info, h))
3707 /* Symbol is referenced locally. Make sure it is
3708 defined locally or for a branch. */
3709 fail = !h->def_regular && !branch;
3713 /* Symbol isn't referenced locally. We only allow
3714 branch to symbol with non-default visibility. */
3716 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT);
3723 const char *pic = "";
3725 switch (ELF_ST_VISIBILITY (h->other))
3728 v = _("hidden symbol");
3731 v = _("internal symbol");
3734 v = _("protected symbol");
3738 pic = _("; recompile with -fPIC");
3743 fmt = _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
3745 fmt = _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
3747 (*_bfd_error_handler) (fmt, input_bfd,
3748 x86_64_elf_howto_table[r_type].name,
3749 v, h->root.root.string, pic);
3750 bfd_set_error (bfd_error_bad_value);
3761 /* FIXME: The ABI says the linker should make sure the value is
3762 the same when it's zeroextended to 64 bit. */
3765 if ((input_section->flags & SEC_ALLOC) == 0)
3770 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3771 || h->root.type != bfd_link_hash_undefweak)
3772 && ((! IS_X86_64_PCREL_TYPE (r_type)
3773 && r_type != R_X86_64_SIZE32
3774 && r_type != R_X86_64_SIZE64)
3775 || ! SYMBOL_CALLS_LOCAL (info, h)))
3776 || (ELIMINATE_COPY_RELOCS
3783 || h->root.type == bfd_link_hash_undefweak
3784 || h->root.type == bfd_link_hash_undefined)))
3786 Elf_Internal_Rela outrel;
3787 bfd_boolean skip, relocate;
3790 /* When generating a shared object, these relocations
3791 are copied into the output file to be resolved at run
3797 _bfd_elf_section_offset (output_bfd, info, input_section,
3799 if (outrel.r_offset == (bfd_vma) -1)
3801 else if (outrel.r_offset == (bfd_vma) -2)
3802 skip = TRUE, relocate = TRUE;
3804 outrel.r_offset += (input_section->output_section->vma
3805 + input_section->output_offset);
3808 memset (&outrel, 0, sizeof outrel);
3810 /* h->dynindx may be -1 if this symbol was marked to
3814 && (IS_X86_64_PCREL_TYPE (r_type)
3816 || ! SYMBOLIC_BIND (info, h)
3817 || ! h->def_regular))
3819 outrel.r_info = htab->r_info (h->dynindx, r_type);
3820 outrel.r_addend = rel->r_addend;
3824 /* This symbol is local, or marked to become local. */
3825 if (r_type == htab->pointer_r_type)
3828 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
3829 outrel.r_addend = relocation + rel->r_addend;
3831 else if (r_type == R_X86_64_64
3832 && !ABI_64_P (output_bfd))
3835 outrel.r_info = htab->r_info (0,
3836 R_X86_64_RELATIVE64);
3837 outrel.r_addend = relocation + rel->r_addend;
3838 /* Check addend overflow. */
3839 if ((outrel.r_addend & 0x80000000)
3840 != (rel->r_addend & 0x80000000))
3843 int addend = rel->r_addend;
3844 if (h && h->root.root.string)
3845 name = h->root.root.string;
3847 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
3850 (*_bfd_error_handler)
3851 (_("%B: addend -0x%x in relocation %s against "
3852 "symbol `%s' at 0x%lx in section `%A' is "
3854 input_bfd, input_section, addend,
3855 x86_64_elf_howto_table[r_type].name,
3856 name, (unsigned long) rel->r_offset);
3858 (*_bfd_error_handler)
3859 (_("%B: addend 0x%x in relocation %s against "
3860 "symbol `%s' at 0x%lx in section `%A' is "
3862 input_bfd, input_section, addend,
3863 x86_64_elf_howto_table[r_type].name,
3864 name, (unsigned long) rel->r_offset);
3865 bfd_set_error (bfd_error_bad_value);
3873 if (bfd_is_abs_section (sec))
3875 else if (sec == NULL || sec->owner == NULL)
3877 bfd_set_error (bfd_error_bad_value);
3884 /* We are turning this relocation into one
3885 against a section symbol. It would be
3886 proper to subtract the symbol's value,
3887 osec->vma, from the emitted reloc addend,
3888 but ld.so expects buggy relocs. */
3889 osec = sec->output_section;
3890 sindx = elf_section_data (osec)->dynindx;
3893 asection *oi = htab->elf.text_index_section;
3894 sindx = elf_section_data (oi)->dynindx;
3896 BFD_ASSERT (sindx != 0);
3899 outrel.r_info = htab->r_info (sindx, r_type);
3900 outrel.r_addend = relocation + rel->r_addend;
3904 sreloc = elf_section_data (input_section)->sreloc;
3906 if (sreloc == NULL || sreloc->contents == NULL)
3908 r = bfd_reloc_notsupported;
3909 goto check_relocation_error;
3912 elf_append_rela (output_bfd, sreloc, &outrel);
3914 /* If this reloc is against an external symbol, we do
3915 not want to fiddle with the addend. Otherwise, we
3916 need to include the symbol value so that it becomes
3917 an addend for the dynamic reloc. */
3924 case R_X86_64_TLSGD:
3925 case R_X86_64_GOTPC32_TLSDESC:
3926 case R_X86_64_TLSDESC_CALL:
3927 case R_X86_64_GOTTPOFF:
3928 tls_type = GOT_UNKNOWN;
3929 if (h == NULL && local_got_offsets)
3930 tls_type = elf_x86_64_local_got_tls_type (input_bfd) [r_symndx];
3932 tls_type = elf_x86_64_hash_entry (h)->tls_type;
3934 if (! elf_x86_64_tls_transition (info, input_bfd,
3935 input_section, contents,
3936 symtab_hdr, sym_hashes,
3937 &r_type, tls_type, rel,
3938 relend, h, r_symndx))
3941 if (r_type == R_X86_64_TPOFF32)
3943 bfd_vma roff = rel->r_offset;
3945 BFD_ASSERT (! unresolved_reloc);
3947 if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
3949 /* GD->LE transition. For 64bit, change
3950 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3951 .word 0x6666; rex64; call __tls_get_addr
3954 leaq foo@tpoff(%rax), %rax
3956 leaq foo@tlsgd(%rip), %rdi
3957 .word 0x6666; rex64; call __tls_get_addr
3960 leaq foo@tpoff(%rax), %rax */
3961 if (ABI_64_P (output_bfd))
3962 memcpy (contents + roff - 4,
3963 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3966 memcpy (contents + roff - 3,
3967 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3969 bfd_put_32 (output_bfd,
3970 elf_x86_64_tpoff (info, relocation),
3971 contents + roff + 8);
3972 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
3976 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
3978 /* GDesc -> LE transition.
3979 It's originally something like:
3980 leaq x@tlsdesc(%rip), %rax
3983 movl $x@tpoff, %rax. */
3985 unsigned int val, type;
3987 type = bfd_get_8 (input_bfd, contents + roff - 3);
3988 val = bfd_get_8 (input_bfd, contents + roff - 1);
3989 bfd_put_8 (output_bfd, 0x48 | ((type >> 2) & 1),
3990 contents + roff - 3);
3991 bfd_put_8 (output_bfd, 0xc7, contents + roff - 2);
3992 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3993 contents + roff - 1);
3994 bfd_put_32 (output_bfd,
3995 elf_x86_64_tpoff (info, relocation),
3999 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
4001 /* GDesc -> LE transition.
4006 bfd_put_8 (output_bfd, 0x66, contents + roff);
4007 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4010 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTTPOFF)
4012 /* IE->LE transition:
4013 Originally it can be one of:
4014 movq foo@gottpoff(%rip), %reg
4015 addq foo@gottpoff(%rip), %reg
4018 leaq foo(%reg), %reg
4021 unsigned int val, type, reg;
4023 val = bfd_get_8 (input_bfd, contents + roff - 3);
4024 type = bfd_get_8 (input_bfd, contents + roff - 2);
4025 reg = bfd_get_8 (input_bfd, contents + roff - 1);
4031 bfd_put_8 (output_bfd, 0x49,
4032 contents + roff - 3);
4033 else if (!ABI_64_P (output_bfd) && val == 0x44)
4034 bfd_put_8 (output_bfd, 0x41,
4035 contents + roff - 3);
4036 bfd_put_8 (output_bfd, 0xc7,
4037 contents + roff - 2);
4038 bfd_put_8 (output_bfd, 0xc0 | reg,
4039 contents + roff - 1);
4043 /* addq -> addq - addressing with %rsp/%r12 is
4046 bfd_put_8 (output_bfd, 0x49,
4047 contents + roff - 3);
4048 else if (!ABI_64_P (output_bfd) && val == 0x44)
4049 bfd_put_8 (output_bfd, 0x41,
4050 contents + roff - 3);
4051 bfd_put_8 (output_bfd, 0x81,
4052 contents + roff - 2);
4053 bfd_put_8 (output_bfd, 0xc0 | reg,
4054 contents + roff - 1);
4060 bfd_put_8 (output_bfd, 0x4d,
4061 contents + roff - 3);
4062 else if (!ABI_64_P (output_bfd) && val == 0x44)
4063 bfd_put_8 (output_bfd, 0x45,
4064 contents + roff - 3);
4065 bfd_put_8 (output_bfd, 0x8d,
4066 contents + roff - 2);
4067 bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
4068 contents + roff - 1);
4070 bfd_put_32 (output_bfd,
4071 elf_x86_64_tpoff (info, relocation),
4079 if (htab->elf.sgot == NULL)
4084 off = h->got.offset;
4085 offplt = elf_x86_64_hash_entry (h)->tlsdesc_got;
4089 if (local_got_offsets == NULL)
4092 off = local_got_offsets[r_symndx];
4093 offplt = local_tlsdesc_gotents[r_symndx];
4100 Elf_Internal_Rela outrel;
4104 if (htab->elf.srelgot == NULL)
4107 indx = h && h->dynindx != -1 ? h->dynindx : 0;
4109 if (GOT_TLS_GDESC_P (tls_type))
4111 outrel.r_info = htab->r_info (indx, R_X86_64_TLSDESC);
4112 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt
4113 + 2 * GOT_ENTRY_SIZE <= htab->elf.sgotplt->size);
4114 outrel.r_offset = (htab->elf.sgotplt->output_section->vma
4115 + htab->elf.sgotplt->output_offset
4117 + htab->sgotplt_jump_table_size);
4118 sreloc = htab->elf.srelplt;
4120 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
4122 outrel.r_addend = 0;
4123 elf_append_rela (output_bfd, sreloc, &outrel);
4126 sreloc = htab->elf.srelgot;
4128 outrel.r_offset = (htab->elf.sgot->output_section->vma
4129 + htab->elf.sgot->output_offset + off);
4131 if (GOT_TLS_GD_P (tls_type))
4132 dr_type = R_X86_64_DTPMOD64;
4133 else if (GOT_TLS_GDESC_P (tls_type))
4136 dr_type = R_X86_64_TPOFF64;
4138 bfd_put_64 (output_bfd, 0, htab->elf.sgot->contents + off);
4139 outrel.r_addend = 0;
4140 if ((dr_type == R_X86_64_TPOFF64
4141 || dr_type == R_X86_64_TLSDESC) && indx == 0)
4142 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
4143 outrel.r_info = htab->r_info (indx, dr_type);
4145 elf_append_rela (output_bfd, sreloc, &outrel);
4147 if (GOT_TLS_GD_P (tls_type))
4151 BFD_ASSERT (! unresolved_reloc);
4152 bfd_put_64 (output_bfd,
4153 relocation - elf_x86_64_dtpoff_base (info),
4154 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4158 bfd_put_64 (output_bfd, 0,
4159 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4160 outrel.r_info = htab->r_info (indx,
4162 outrel.r_offset += GOT_ENTRY_SIZE;
4163 elf_append_rela (output_bfd, sreloc,
4172 local_got_offsets[r_symndx] |= 1;
4175 if (off >= (bfd_vma) -2
4176 && ! GOT_TLS_GDESC_P (tls_type))
4178 if (r_type == ELF32_R_TYPE (rel->r_info))
4180 if (r_type == R_X86_64_GOTPC32_TLSDESC
4181 || r_type == R_X86_64_TLSDESC_CALL)
4182 relocation = htab->elf.sgotplt->output_section->vma
4183 + htab->elf.sgotplt->output_offset
4184 + offplt + htab->sgotplt_jump_table_size;
4186 relocation = htab->elf.sgot->output_section->vma
4187 + htab->elf.sgot->output_offset + off;
4188 unresolved_reloc = FALSE;
4192 bfd_vma roff = rel->r_offset;
4194 if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
4196 /* GD->IE transition. For 64bit, change
4197 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4198 .word 0x6666; rex64; call __tls_get_addr@plt
4201 addq foo@gottpoff(%rip), %rax
4203 leaq foo@tlsgd(%rip), %rdi
4204 .word 0x6666; rex64; call __tls_get_addr@plt
4207 addq foo@gottpoff(%rip), %rax */
4208 if (ABI_64_P (output_bfd))
4209 memcpy (contents + roff - 4,
4210 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4213 memcpy (contents + roff - 3,
4214 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4217 relocation = (htab->elf.sgot->output_section->vma
4218 + htab->elf.sgot->output_offset + off
4220 - input_section->output_section->vma
4221 - input_section->output_offset
4223 bfd_put_32 (output_bfd, relocation,
4224 contents + roff + 8);
4225 /* Skip R_X86_64_PLT32. */
4229 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
4231 /* GDesc -> IE transition.
4232 It's originally something like:
4233 leaq x@tlsdesc(%rip), %rax
4236 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
4238 /* Now modify the instruction as appropriate. To
4239 turn a leaq into a movq in the form we use it, it
4240 suffices to change the second byte from 0x8d to
4242 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4244 bfd_put_32 (output_bfd,
4245 htab->elf.sgot->output_section->vma
4246 + htab->elf.sgot->output_offset + off
4248 - input_section->output_section->vma
4249 - input_section->output_offset
4254 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
4256 /* GDesc -> IE transition.
4263 bfd_put_8 (output_bfd, 0x66, contents + roff);
4264 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4272 case R_X86_64_TLSLD:
4273 if (! elf_x86_64_tls_transition (info, input_bfd,
4274 input_section, contents,
4275 symtab_hdr, sym_hashes,
4276 &r_type, GOT_UNKNOWN,
4277 rel, relend, h, r_symndx))
4280 if (r_type != R_X86_64_TLSLD)
4282 /* LD->LE transition:
4283 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
4284 For 64bit, we change it into:
4285 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
4286 For 32bit, we change it into:
4287 nopl 0x0(%rax); movl %fs:0, %eax. */
4289 BFD_ASSERT (r_type == R_X86_64_TPOFF32);
4290 if (ABI_64_P (output_bfd))
4291 memcpy (contents + rel->r_offset - 3,
4292 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
4294 memcpy (contents + rel->r_offset - 3,
4295 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
4296 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
4301 if (htab->elf.sgot == NULL)
4304 off = htab->tls_ld_got.offset;
4309 Elf_Internal_Rela outrel;
4311 if (htab->elf.srelgot == NULL)
4314 outrel.r_offset = (htab->elf.sgot->output_section->vma
4315 + htab->elf.sgot->output_offset + off);
4317 bfd_put_64 (output_bfd, 0,
4318 htab->elf.sgot->contents + off);
4319 bfd_put_64 (output_bfd, 0,
4320 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4321 outrel.r_info = htab->r_info (0, R_X86_64_DTPMOD64);
4322 outrel.r_addend = 0;
4323 elf_append_rela (output_bfd, htab->elf.srelgot,
4325 htab->tls_ld_got.offset |= 1;
4327 relocation = htab->elf.sgot->output_section->vma
4328 + htab->elf.sgot->output_offset + off;
4329 unresolved_reloc = FALSE;
4332 case R_X86_64_DTPOFF32:
4333 if (!info->executable|| (input_section->flags & SEC_CODE) == 0)
4334 relocation -= elf_x86_64_dtpoff_base (info);
4336 relocation = elf_x86_64_tpoff (info, relocation);
4339 case R_X86_64_TPOFF32:
4340 case R_X86_64_TPOFF64:
4341 BFD_ASSERT (info->executable);
4342 relocation = elf_x86_64_tpoff (info, relocation);
4349 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4350 because such sections are not SEC_ALLOC and thus ld.so will
4351 not process them. */
4352 if (unresolved_reloc
4353 && !((input_section->flags & SEC_DEBUGGING) != 0
4355 && _bfd_elf_section_offset (output_bfd, info, input_section,
4356 rel->r_offset) != (bfd_vma) -1)
4358 (*_bfd_error_handler)
4359 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4362 (long) rel->r_offset,
4364 h->root.root.string);
4369 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4370 contents, rel->r_offset,
4371 relocation, rel->r_addend);
4373 check_relocation_error:
4374 if (r != bfd_reloc_ok)
4379 name = h->root.root.string;
4382 name = bfd_elf_string_from_elf_section (input_bfd,
4383 symtab_hdr->sh_link,
4388 name = bfd_section_name (input_bfd, sec);
4391 if (r == bfd_reloc_overflow)
4393 if (! ((*info->callbacks->reloc_overflow)
4394 (info, (h ? &h->root : NULL), name, howto->name,
4395 (bfd_vma) 0, input_bfd, input_section,
4401 (*_bfd_error_handler)
4402 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4403 input_bfd, input_section,
4404 (long) rel->r_offset, name, (int) r);
4413 /* Finish up dynamic symbol handling. We set the contents of various
4414 dynamic sections here. */
4417 elf_x86_64_finish_dynamic_symbol (bfd *output_bfd,
4418 struct bfd_link_info *info,
4419 struct elf_link_hash_entry *h,
4420 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
4422 struct elf_x86_64_link_hash_table *htab;
4423 const struct elf_x86_64_backend_data *const abed
4424 = get_elf_x86_64_backend_data (output_bfd);
4426 htab = elf_x86_64_hash_table (info);
4430 if (h->plt.offset != (bfd_vma) -1)
4434 Elf_Internal_Rela rela;
4436 asection *plt, *gotplt, *relplt;
4437 const struct elf_backend_data *bed;
4439 /* When building a static executable, use .iplt, .igot.plt and
4440 .rela.iplt sections for STT_GNU_IFUNC symbols. */
4441 if (htab->elf.splt != NULL)
4443 plt = htab->elf.splt;
4444 gotplt = htab->elf.sgotplt;
4445 relplt = htab->elf.srelplt;
4449 plt = htab->elf.iplt;
4450 gotplt = htab->elf.igotplt;
4451 relplt = htab->elf.irelplt;
4454 /* This symbol has an entry in the procedure linkage table. Set
4456 if ((h->dynindx == -1
4457 && !((h->forced_local || info->executable)
4459 && h->type == STT_GNU_IFUNC))
4465 /* Get the index in the procedure linkage table which
4466 corresponds to this symbol. This is the index of this symbol
4467 in all the symbols for which we are making plt entries. The
4468 first entry in the procedure linkage table is reserved.
4470 Get the offset into the .got table of the entry that
4471 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
4472 bytes. The first three are reserved for the dynamic linker.
4474 For static executables, we don't reserve anything. */
4476 if (plt == htab->elf.splt)
4478 got_offset = h->plt.offset / abed->plt_entry_size - 1;
4479 got_offset = (got_offset + 3) * GOT_ENTRY_SIZE;
4483 got_offset = h->plt.offset / abed->plt_entry_size;
4484 got_offset = got_offset * GOT_ENTRY_SIZE;
4487 /* Fill in the entry in the procedure linkage table. */
4488 memcpy (plt->contents + h->plt.offset, abed->plt_entry,
4489 abed->plt_entry_size);
4491 /* Insert the relocation positions of the plt section. */
4493 /* Put offset the PC-relative instruction referring to the GOT entry,
4494 subtracting the size of that instruction. */
4495 bfd_put_32 (output_bfd,
4496 (gotplt->output_section->vma
4497 + gotplt->output_offset
4499 - plt->output_section->vma
4500 - plt->output_offset
4502 - abed->plt_got_insn_size),
4503 plt->contents + h->plt.offset + abed->plt_got_offset);
4505 /* Fill in the entry in the global offset table, initially this
4506 points to the second part of the PLT entry. */
4507 bfd_put_64 (output_bfd, (plt->output_section->vma
4508 + plt->output_offset
4509 + h->plt.offset + abed->plt_lazy_offset),
4510 gotplt->contents + got_offset);
4512 /* Fill in the entry in the .rela.plt section. */
4513 rela.r_offset = (gotplt->output_section->vma
4514 + gotplt->output_offset
4516 if (h->dynindx == -1
4517 || ((info->executable
4518 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4520 && h->type == STT_GNU_IFUNC))
4522 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4523 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
4524 rela.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
4525 rela.r_addend = (h->root.u.def.value
4526 + h->root.u.def.section->output_section->vma
4527 + h->root.u.def.section->output_offset);
4528 /* R_X86_64_IRELATIVE comes last. */
4529 plt_index = htab->next_irelative_index--;
4533 rela.r_info = htab->r_info (h->dynindx, R_X86_64_JUMP_SLOT);
4535 plt_index = htab->next_jump_slot_index++;
4538 /* Don't fill PLT entry for static executables. */
4539 if (plt == htab->elf.splt)
4541 /* Put relocation index. */
4542 bfd_put_32 (output_bfd, plt_index,
4543 plt->contents + h->plt.offset + abed->plt_reloc_offset);
4544 /* Put offset for jmp .PLT0. */
4545 bfd_put_32 (output_bfd, - (h->plt.offset + abed->plt_plt_insn_end),
4546 plt->contents + h->plt.offset + abed->plt_plt_offset);
4549 bed = get_elf_backend_data (output_bfd);
4550 loc = relplt->contents + plt_index * bed->s->sizeof_rela;
4551 bed->s->swap_reloca_out (output_bfd, &rela, loc);
4553 if (!h->def_regular)
4555 /* Mark the symbol as undefined, rather than as defined in
4556 the .plt section. Leave the value if there were any
4557 relocations where pointer equality matters (this is a clue
4558 for the dynamic linker, to make function pointer
4559 comparisons work between an application and shared
4560 library), otherwise set it to zero. If a function is only
4561 called from a binary, there is no need to slow down
4562 shared libraries because of that. */
4563 sym->st_shndx = SHN_UNDEF;
4564 if (!h->pointer_equality_needed)
4569 if (h->got.offset != (bfd_vma) -1
4570 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h)->tls_type)
4571 && elf_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE)
4573 Elf_Internal_Rela rela;
4575 /* This symbol has an entry in the global offset table. Set it
4577 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
4580 rela.r_offset = (htab->elf.sgot->output_section->vma
4581 + htab->elf.sgot->output_offset
4582 + (h->got.offset &~ (bfd_vma) 1));
4584 /* If this is a static link, or it is a -Bsymbolic link and the
4585 symbol is defined locally or was forced to be local because
4586 of a version file, we just want to emit a RELATIVE reloc.
4587 The entry in the global offset table will already have been
4588 initialized in the relocate_section function. */
4590 && h->type == STT_GNU_IFUNC)
4594 /* Generate R_X86_64_GLOB_DAT. */
4601 if (!h->pointer_equality_needed)
4604 /* For non-shared object, we can't use .got.plt, which
4605 contains the real function addres if we need pointer
4606 equality. We load the GOT entry with the PLT entry. */
4607 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4608 bfd_put_64 (output_bfd, (plt->output_section->vma
4609 + plt->output_offset
4611 htab->elf.sgot->contents + h->got.offset);
4615 else if (info->shared
4616 && SYMBOL_REFERENCES_LOCAL (info, h))
4618 if (!h->def_regular)
4620 BFD_ASSERT((h->got.offset & 1) != 0);
4621 rela.r_info = htab->r_info (0, R_X86_64_RELATIVE);
4622 rela.r_addend = (h->root.u.def.value
4623 + h->root.u.def.section->output_section->vma
4624 + h->root.u.def.section->output_offset);
4628 BFD_ASSERT((h->got.offset & 1) == 0);
4630 bfd_put_64 (output_bfd, (bfd_vma) 0,
4631 htab->elf.sgot->contents + h->got.offset);
4632 rela.r_info = htab->r_info (h->dynindx, R_X86_64_GLOB_DAT);
4636 elf_append_rela (output_bfd, htab->elf.srelgot, &rela);
4641 Elf_Internal_Rela rela;
4643 /* This symbol needs a copy reloc. Set it up. */
4645 if (h->dynindx == -1
4646 || (h->root.type != bfd_link_hash_defined
4647 && h->root.type != bfd_link_hash_defweak)
4648 || htab->srelbss == NULL)
4651 rela.r_offset = (h->root.u.def.value
4652 + h->root.u.def.section->output_section->vma
4653 + h->root.u.def.section->output_offset);
4654 rela.r_info = htab->r_info (h->dynindx, R_X86_64_COPY);
4656 elf_append_rela (output_bfd, htab->srelbss, &rela);
4662 /* Finish up local dynamic symbol handling. We set the contents of
4663 various dynamic sections here. */
4666 elf_x86_64_finish_local_dynamic_symbol (void **slot, void *inf)
4668 struct elf_link_hash_entry *h
4669 = (struct elf_link_hash_entry *) *slot;
4670 struct bfd_link_info *info
4671 = (struct bfd_link_info *) inf;
4673 return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
4677 /* Used to decide how to sort relocs in an optimal manner for the
4678 dynamic linker, before writing them out. */
4680 static enum elf_reloc_type_class
4681 elf_x86_64_reloc_type_class (const Elf_Internal_Rela *rela)
4683 switch ((int) ELF32_R_TYPE (rela->r_info))
4685 case R_X86_64_RELATIVE:
4686 case R_X86_64_RELATIVE64:
4687 return reloc_class_relative;
4688 case R_X86_64_JUMP_SLOT:
4689 return reloc_class_plt;
4691 return reloc_class_copy;
4693 return reloc_class_normal;
4697 /* Finish up the dynamic sections. */
4700 elf_x86_64_finish_dynamic_sections (bfd *output_bfd,
4701 struct bfd_link_info *info)
4703 struct elf_x86_64_link_hash_table *htab;
4706 const struct elf_x86_64_backend_data *const abed
4707 = get_elf_x86_64_backend_data (output_bfd);
4709 htab = elf_x86_64_hash_table (info);
4713 dynobj = htab->elf.dynobj;
4714 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4716 if (htab->elf.dynamic_sections_created)
4718 bfd_byte *dyncon, *dynconend;
4719 const struct elf_backend_data *bed;
4720 bfd_size_type sizeof_dyn;
4722 if (sdyn == NULL || htab->elf.sgot == NULL)
4725 bed = get_elf_backend_data (dynobj);
4726 sizeof_dyn = bed->s->sizeof_dyn;
4727 dyncon = sdyn->contents;
4728 dynconend = sdyn->contents + sdyn->size;
4729 for (; dyncon < dynconend; dyncon += sizeof_dyn)
4731 Elf_Internal_Dyn dyn;
4734 (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
4742 s = htab->elf.sgotplt;
4743 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4747 dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
4751 s = htab->elf.srelplt->output_section;
4752 dyn.d_un.d_val = s->size;
4756 /* The procedure linkage table relocs (DT_JMPREL) should
4757 not be included in the overall relocs (DT_RELA).
4758 Therefore, we override the DT_RELASZ entry here to
4759 make it not include the JMPREL relocs. Since the
4760 linker script arranges for .rela.plt to follow all
4761 other relocation sections, we don't have to worry
4762 about changing the DT_RELA entry. */
4763 if (htab->elf.srelplt != NULL)
4765 s = htab->elf.srelplt->output_section;
4766 dyn.d_un.d_val -= s->size;
4770 case DT_TLSDESC_PLT:
4772 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
4773 + htab->tlsdesc_plt;
4776 case DT_TLSDESC_GOT:
4778 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
4779 + htab->tlsdesc_got;
4783 (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
4786 /* Fill in the special first entry in the procedure linkage table. */
4787 if (htab->elf.splt && htab->elf.splt->size > 0)
4789 /* Fill in the first entry in the procedure linkage table. */
4790 memcpy (htab->elf.splt->contents,
4791 abed->plt0_entry, abed->plt_entry_size);
4792 /* Add offset for pushq GOT+8(%rip), since the instruction
4793 uses 6 bytes subtract this value. */
4794 bfd_put_32 (output_bfd,
4795 (htab->elf.sgotplt->output_section->vma
4796 + htab->elf.sgotplt->output_offset
4798 - htab->elf.splt->output_section->vma
4799 - htab->elf.splt->output_offset
4801 htab->elf.splt->contents + abed->plt0_got1_offset);
4802 /* Add offset for the PC-relative instruction accessing GOT+16,
4803 subtracting the offset to the end of that instruction. */
4804 bfd_put_32 (output_bfd,
4805 (htab->elf.sgotplt->output_section->vma
4806 + htab->elf.sgotplt->output_offset
4808 - htab->elf.splt->output_section->vma
4809 - htab->elf.splt->output_offset
4810 - abed->plt0_got2_insn_end),
4811 htab->elf.splt->contents + abed->plt0_got2_offset);
4813 elf_section_data (htab->elf.splt->output_section)
4814 ->this_hdr.sh_entsize = abed->plt_entry_size;
4816 if (htab->tlsdesc_plt)
4818 bfd_put_64 (output_bfd, (bfd_vma) 0,
4819 htab->elf.sgot->contents + htab->tlsdesc_got);
4821 memcpy (htab->elf.splt->contents + htab->tlsdesc_plt,
4822 abed->plt0_entry, abed->plt_entry_size);
4824 /* Add offset for pushq GOT+8(%rip), since the
4825 instruction uses 6 bytes subtract this value. */
4826 bfd_put_32 (output_bfd,
4827 (htab->elf.sgotplt->output_section->vma
4828 + htab->elf.sgotplt->output_offset
4830 - htab->elf.splt->output_section->vma
4831 - htab->elf.splt->output_offset
4834 htab->elf.splt->contents
4835 + htab->tlsdesc_plt + abed->plt0_got1_offset);
4836 /* Add offset for the PC-relative instruction accessing GOT+TDG,
4837 where TGD stands for htab->tlsdesc_got, subtracting the offset
4838 to the end of that instruction. */
4839 bfd_put_32 (output_bfd,
4840 (htab->elf.sgot->output_section->vma
4841 + htab->elf.sgot->output_offset
4843 - htab->elf.splt->output_section->vma
4844 - htab->elf.splt->output_offset
4846 - abed->plt0_got2_insn_end),
4847 htab->elf.splt->contents
4848 + htab->tlsdesc_plt + abed->plt0_got2_offset);
4853 if (htab->elf.sgotplt)
4855 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
4857 (*_bfd_error_handler)
4858 (_("discarded output section: `%A'"), htab->elf.sgotplt);
4862 /* Fill in the first three entries in the global offset table. */
4863 if (htab->elf.sgotplt->size > 0)
4865 /* Set the first entry in the global offset table to the address of
4866 the dynamic section. */
4868 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents);
4870 bfd_put_64 (output_bfd,
4871 sdyn->output_section->vma + sdyn->output_offset,
4872 htab->elf.sgotplt->contents);
4873 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
4874 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
4875 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE*2);
4878 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize =
4882 /* Adjust .eh_frame for .plt section. */
4883 if (htab->plt_eh_frame != NULL
4884 && htab->plt_eh_frame->contents != NULL)
4886 if (htab->elf.splt != NULL
4887 && htab->elf.splt->size != 0
4888 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
4889 && htab->elf.splt->output_section != NULL
4890 && htab->plt_eh_frame->output_section != NULL)
4892 bfd_vma plt_start = htab->elf.splt->output_section->vma;
4893 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
4894 + htab->plt_eh_frame->output_offset
4895 + PLT_FDE_START_OFFSET;
4896 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
4897 htab->plt_eh_frame->contents
4898 + PLT_FDE_START_OFFSET);
4900 if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
4902 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
4904 htab->plt_eh_frame->contents))
4909 if (htab->elf.sgot && htab->elf.sgot->size > 0)
4910 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
4913 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4914 htab_traverse (htab->loc_hash_table,
4915 elf_x86_64_finish_local_dynamic_symbol,
4921 /* Return address for Ith PLT stub in section PLT, for relocation REL
4922 or (bfd_vma) -1 if it should not be included. */
4925 elf_x86_64_plt_sym_val (bfd_vma i, const asection *plt,
4926 const arelent *rel ATTRIBUTE_UNUSED)
4928 return plt->vma + (i + 1) * GET_PLT_ENTRY_SIZE (plt->owner);
4931 /* Handle an x86-64 specific section when reading an object file. This
4932 is called when elfcode.h finds a section with an unknown type. */
4935 elf_x86_64_section_from_shdr (bfd *abfd,
4936 Elf_Internal_Shdr *hdr,
4940 if (hdr->sh_type != SHT_X86_64_UNWIND)
4943 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
4949 /* Hook called by the linker routine which adds symbols from an object
4950 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
4954 elf_x86_64_add_symbol_hook (bfd *abfd,
4955 struct bfd_link_info *info,
4956 Elf_Internal_Sym *sym,
4957 const char **namep ATTRIBUTE_UNUSED,
4958 flagword *flagsp ATTRIBUTE_UNUSED,
4964 switch (sym->st_shndx)
4966 case SHN_X86_64_LCOMMON:
4967 lcomm = bfd_get_section_by_name (abfd, "LARGE_COMMON");
4970 lcomm = bfd_make_section_with_flags (abfd,
4974 | SEC_LINKER_CREATED));
4977 elf_section_flags (lcomm) |= SHF_X86_64_LARGE;
4980 *valp = sym->st_size;
4984 if ((abfd->flags & DYNAMIC) == 0
4985 && (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
4986 || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE))
4987 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4993 /* Given a BFD section, try to locate the corresponding ELF section
4997 elf_x86_64_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
4998 asection *sec, int *index_return)
5000 if (sec == &_bfd_elf_large_com_section)
5002 *index_return = SHN_X86_64_LCOMMON;
5008 /* Process a symbol. */
5011 elf_x86_64_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
5014 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
5016 switch (elfsym->internal_elf_sym.st_shndx)
5018 case SHN_X86_64_LCOMMON:
5019 asym->section = &_bfd_elf_large_com_section;
5020 asym->value = elfsym->internal_elf_sym.st_size;
5021 /* Common symbol doesn't set BSF_GLOBAL. */
5022 asym->flags &= ~BSF_GLOBAL;
5028 elf_x86_64_common_definition (Elf_Internal_Sym *sym)
5030 return (sym->st_shndx == SHN_COMMON
5031 || sym->st_shndx == SHN_X86_64_LCOMMON);
5035 elf_x86_64_common_section_index (asection *sec)
5037 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
5040 return SHN_X86_64_LCOMMON;
5044 elf_x86_64_common_section (asection *sec)
5046 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
5047 return bfd_com_section_ptr;
5049 return &_bfd_elf_large_com_section;
5053 elf_x86_64_merge_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
5054 struct elf_link_hash_entry **sym_hash ATTRIBUTE_UNUSED,
5055 struct elf_link_hash_entry *h,
5056 Elf_Internal_Sym *sym,
5058 bfd_vma *pvalue ATTRIBUTE_UNUSED,
5059 unsigned int *pold_alignment ATTRIBUTE_UNUSED,
5060 bfd_boolean *skip ATTRIBUTE_UNUSED,
5061 bfd_boolean *override ATTRIBUTE_UNUSED,
5062 bfd_boolean *type_change_ok ATTRIBUTE_UNUSED,
5063 bfd_boolean *size_change_ok ATTRIBUTE_UNUSED,
5064 bfd_boolean *newdyn ATTRIBUTE_UNUSED,
5065 bfd_boolean *newdef,
5066 bfd_boolean *newdyncommon ATTRIBUTE_UNUSED,
5067 bfd_boolean *newweak ATTRIBUTE_UNUSED,
5068 bfd *abfd ATTRIBUTE_UNUSED,
5070 bfd_boolean *olddyn ATTRIBUTE_UNUSED,
5071 bfd_boolean *olddef,
5072 bfd_boolean *olddyncommon ATTRIBUTE_UNUSED,
5073 bfd_boolean *oldweak ATTRIBUTE_UNUSED,
5077 /* A normal common symbol and a large common symbol result in a
5078 normal common symbol. We turn the large common symbol into a
5081 && h->root.type == bfd_link_hash_common
5083 && bfd_is_com_section (*sec)
5086 if (sym->st_shndx == SHN_COMMON
5087 && (elf_section_flags (*oldsec) & SHF_X86_64_LARGE) != 0)
5089 h->root.u.c.p->section
5090 = bfd_make_section_old_way (oldbfd, "COMMON");
5091 h->root.u.c.p->section->flags = SEC_ALLOC;
5093 else if (sym->st_shndx == SHN_X86_64_LCOMMON
5094 && (elf_section_flags (*oldsec) & SHF_X86_64_LARGE) == 0)
5095 *psec = *sec = bfd_com_section_ptr;
5102 elf_x86_64_additional_program_headers (bfd *abfd,
5103 struct bfd_link_info *info ATTRIBUTE_UNUSED)
5108 /* Check to see if we need a large readonly segment. */
5109 s = bfd_get_section_by_name (abfd, ".lrodata");
5110 if (s && (s->flags & SEC_LOAD))
5113 /* Check to see if we need a large data segment. Since .lbss sections
5114 is placed right after the .bss section, there should be no need for
5115 a large data segment just because of .lbss. */
5116 s = bfd_get_section_by_name (abfd, ".ldata");
5117 if (s && (s->flags & SEC_LOAD))
5123 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5126 elf_x86_64_hash_symbol (struct elf_link_hash_entry *h)
5128 if (h->plt.offset != (bfd_vma) -1
5130 && !h->pointer_equality_needed)
5133 return _bfd_elf_hash_symbol (h);
5136 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
5139 elf_x86_64_relocs_compatible (const bfd_target *input,
5140 const bfd_target *output)
5142 return ((xvec_get_elf_backend_data (input)->s->elfclass
5143 == xvec_get_elf_backend_data (output)->s->elfclass)
5144 && _bfd_elf_relocs_compatible (input, output));
5147 static const struct bfd_elf_special_section
5148 elf_x86_64_special_sections[]=
5150 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5151 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
5152 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR + SHF_X86_64_LARGE},
5153 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5154 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5155 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
5156 { NULL, 0, 0, 0, 0 }
5159 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_vec
5160 #define TARGET_LITTLE_NAME "elf64-x86-64"
5161 #define ELF_ARCH bfd_arch_i386
5162 #define ELF_TARGET_ID X86_64_ELF_DATA
5163 #define ELF_MACHINE_CODE EM_X86_64
5164 #define ELF_MAXPAGESIZE 0x200000
5165 #define ELF_MINPAGESIZE 0x1000
5166 #define ELF_COMMONPAGESIZE 0x1000
5168 #define elf_backend_can_gc_sections 1
5169 #define elf_backend_can_refcount 1
5170 #define elf_backend_want_got_plt 1
5171 #define elf_backend_plt_readonly 1
5172 #define elf_backend_want_plt_sym 0
5173 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
5174 #define elf_backend_rela_normal 1
5175 #define elf_backend_plt_alignment 4
5177 #define elf_info_to_howto elf_x86_64_info_to_howto
5179 #define bfd_elf64_bfd_link_hash_table_create \
5180 elf_x86_64_link_hash_table_create
5181 #define bfd_elf64_bfd_link_hash_table_free \
5182 elf_x86_64_link_hash_table_free
5183 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
5184 #define bfd_elf64_bfd_reloc_name_lookup \
5185 elf_x86_64_reloc_name_lookup
5187 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
5188 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
5189 #define elf_backend_check_relocs elf_x86_64_check_relocs
5190 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
5191 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
5192 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
5193 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
5194 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
5195 #define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
5196 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
5197 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
5199 #define elf_backend_write_core_note elf_x86_64_write_core_note
5201 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
5202 #define elf_backend_relocate_section elf_x86_64_relocate_section
5203 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
5204 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
5205 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
5206 #define elf_backend_plt_sym_val elf_x86_64_plt_sym_val
5207 #define elf_backend_object_p elf64_x86_64_elf_object_p
5208 #define bfd_elf64_mkobject elf_x86_64_mkobject
5210 #define elf_backend_section_from_shdr \
5211 elf_x86_64_section_from_shdr
5213 #define elf_backend_section_from_bfd_section \
5214 elf_x86_64_elf_section_from_bfd_section
5215 #define elf_backend_add_symbol_hook \
5216 elf_x86_64_add_symbol_hook
5217 #define elf_backend_symbol_processing \
5218 elf_x86_64_symbol_processing
5219 #define elf_backend_common_section_index \
5220 elf_x86_64_common_section_index
5221 #define elf_backend_common_section \
5222 elf_x86_64_common_section
5223 #define elf_backend_common_definition \
5224 elf_x86_64_common_definition
5225 #define elf_backend_merge_symbol \
5226 elf_x86_64_merge_symbol
5227 #define elf_backend_special_sections \
5228 elf_x86_64_special_sections
5229 #define elf_backend_additional_program_headers \
5230 elf_x86_64_additional_program_headers
5231 #define elf_backend_hash_symbol \
5232 elf_x86_64_hash_symbol
5234 #define elf_backend_post_process_headers _bfd_elf_set_osabi
5236 #include "elf64-target.h"
5238 /* FreeBSD support. */
5240 #undef TARGET_LITTLE_SYM
5241 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_freebsd_vec
5242 #undef TARGET_LITTLE_NAME
5243 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
5246 #define ELF_OSABI ELFOSABI_FREEBSD
5249 #define elf64_bed elf64_x86_64_fbsd_bed
5251 #include "elf64-target.h"
5253 /* Solaris 2 support. */
5255 #undef TARGET_LITTLE_SYM
5256 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_sol2_vec
5257 #undef TARGET_LITTLE_NAME
5258 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
5260 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5261 objects won't be recognized. */
5265 #define elf64_bed elf64_x86_64_sol2_bed
5267 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
5269 #undef elf_backend_static_tls_alignment
5270 #define elf_backend_static_tls_alignment 16
5272 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5274 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5276 #undef elf_backend_want_plt_sym
5277 #define elf_backend_want_plt_sym 1
5279 #include "elf64-target.h"
5281 /* Native Client support. */
5283 #undef TARGET_LITTLE_SYM
5284 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_nacl_vec
5285 #undef TARGET_LITTLE_NAME
5286 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
5288 #define elf64_bed elf64_x86_64_nacl_bed
5290 #undef ELF_MAXPAGESIZE
5291 #undef ELF_MINPAGESIZE
5292 #undef ELF_COMMONPAGESIZE
5293 #define ELF_MAXPAGESIZE 0x10000
5294 #define ELF_MINPAGESIZE 0x10000
5295 #define ELF_COMMONPAGESIZE 0x10000
5297 /* Restore defaults. */
5299 #undef elf_backend_static_tls_alignment
5300 #undef elf_backend_want_plt_sym
5301 #define elf_backend_want_plt_sym 0
5303 /* NaCl uses substantially different PLT entries for the same effects. */
5305 #undef elf_backend_plt_alignment
5306 #define elf_backend_plt_alignment 5
5307 #define NACL_PLT_ENTRY_SIZE 64
5308 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
5310 static const bfd_byte elf_x86_64_nacl_plt0_entry[NACL_PLT_ENTRY_SIZE] =
5312 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
5313 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
5314 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */
5315 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5316 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5318 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
5319 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopl %cs:0x0(%rax,%rax,1) */
5321 /* 32 bytes of nop to pad out to the standard size. */
5322 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5323 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5324 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5325 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5326 0x66, /* excess data32 prefix */
5330 static const bfd_byte elf_x86_64_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
5332 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
5333 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */
5334 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5335 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5337 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
5338 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5339 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5341 /* Lazy GOT entries point here (32-byte aligned). */
5342 0x68, /* pushq immediate */
5343 0, 0, 0, 0, /* replaced with index into relocation table. */
5344 0xe9, /* jmp relative */
5345 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
5347 /* 22 bytes of nop to pad out to the standard size. */
5348 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5349 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5350 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
5353 /* .eh_frame covering the .plt section. */
5355 static const bfd_byte elf_x86_64_nacl_eh_frame_plt[] =
5357 #if (PLT_CIE_LENGTH != 20 \
5358 || PLT_FDE_LENGTH != 36 \
5359 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
5360 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
5361 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
5363 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
5364 0, 0, 0, 0, /* CIE ID */
5365 1, /* CIE version */
5366 'z', 'R', 0, /* Augmentation string */
5367 1, /* Code alignment factor */
5368 0x78, /* Data alignment factor */
5369 16, /* Return address column */
5370 1, /* Augmentation size */
5371 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
5372 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
5373 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
5374 DW_CFA_nop, DW_CFA_nop,
5376 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
5377 PLT_CIE_LENGTH + 8, 0, 0, 0,/* CIE pointer */
5378 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
5379 0, 0, 0, 0, /* .plt size goes here */
5380 0, /* Augmentation size */
5381 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
5382 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
5383 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
5384 DW_CFA_advance_loc + 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
5385 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
5386 13, /* Block length */
5387 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
5388 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
5389 DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
5390 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
5391 DW_CFA_nop, DW_CFA_nop
5394 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed =
5396 elf_x86_64_nacl_plt0_entry, /* plt0_entry */
5397 elf_x86_64_nacl_plt_entry, /* plt_entry */
5398 NACL_PLT_ENTRY_SIZE, /* plt_entry_size */
5399 2, /* plt0_got1_offset */
5400 9, /* plt0_got2_offset */
5401 13, /* plt0_got2_insn_end */
5402 3, /* plt_got_offset */
5403 33, /* plt_reloc_offset */
5404 38, /* plt_plt_offset */
5405 7, /* plt_got_insn_size */
5406 42, /* plt_plt_insn_end */
5407 32, /* plt_lazy_offset */
5408 elf_x86_64_nacl_eh_frame_plt, /* eh_frame_plt */
5409 sizeof (elf_x86_64_nacl_eh_frame_plt), /* eh_frame_plt_size */
5412 #undef elf_backend_arch_data
5413 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
5415 #undef elf_backend_modify_segment_map
5416 #define elf_backend_modify_segment_map nacl_modify_segment_map
5417 #undef elf_backend_modify_program_headers
5418 #define elf_backend_modify_program_headers nacl_modify_program_headers
5420 #include "elf64-target.h"
5422 /* Native Client x32 support. */
5424 #undef TARGET_LITTLE_SYM
5425 #define TARGET_LITTLE_SYM bfd_elf32_x86_64_nacl_vec
5426 #undef TARGET_LITTLE_NAME
5427 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
5429 #define elf32_bed elf32_x86_64_nacl_bed
5431 #define bfd_elf32_bfd_link_hash_table_create \
5432 elf_x86_64_link_hash_table_create
5433 #define bfd_elf32_bfd_link_hash_table_free \
5434 elf_x86_64_link_hash_table_free
5435 #define bfd_elf32_bfd_reloc_type_lookup \
5436 elf_x86_64_reloc_type_lookup
5437 #define bfd_elf32_bfd_reloc_name_lookup \
5438 elf_x86_64_reloc_name_lookup
5439 #define bfd_elf32_mkobject \
5442 #undef elf_backend_object_p
5443 #define elf_backend_object_p \
5444 elf32_x86_64_elf_object_p
5446 #undef elf_backend_bfd_from_remote_memory
5447 #define elf_backend_bfd_from_remote_memory \
5448 _bfd_elf32_bfd_from_remote_memory
5450 #undef elf_backend_size_info
5451 #define elf_backend_size_info \
5452 _bfd_elf32_size_info
5454 #include "elf32-target.h"
5456 /* Restore defaults. */
5457 #undef elf_backend_object_p
5458 #define elf_backend_object_p elf64_x86_64_elf_object_p
5459 #undef elf_backend_bfd_from_remote_memory
5460 #undef elf_backend_size_info
5461 #undef elf_backend_modify_segment_map
5462 #undef elf_backend_modify_program_headers
5464 /* Intel L1OM support. */
5467 elf64_l1om_elf_object_p (bfd *abfd)
5469 /* Set the right machine number for an L1OM elf64 file. */
5470 bfd_default_set_arch_mach (abfd, bfd_arch_l1om, bfd_mach_l1om);
5474 #undef TARGET_LITTLE_SYM
5475 #define TARGET_LITTLE_SYM bfd_elf64_l1om_vec
5476 #undef TARGET_LITTLE_NAME
5477 #define TARGET_LITTLE_NAME "elf64-l1om"
5479 #define ELF_ARCH bfd_arch_l1om
5481 #undef ELF_MACHINE_CODE
5482 #define ELF_MACHINE_CODE EM_L1OM
5487 #define elf64_bed elf64_l1om_bed
5489 #undef elf_backend_object_p
5490 #define elf_backend_object_p elf64_l1om_elf_object_p
5492 /* Restore defaults. */
5493 #undef ELF_MAXPAGESIZE
5494 #undef ELF_MINPAGESIZE
5495 #undef ELF_COMMONPAGESIZE
5496 #define ELF_MAXPAGESIZE 0x200000
5497 #define ELF_MINPAGESIZE 0x1000
5498 #define ELF_COMMONPAGESIZE 0x1000
5499 #undef elf_backend_plt_alignment
5500 #define elf_backend_plt_alignment 4
5501 #undef elf_backend_arch_data
5502 #define elf_backend_arch_data &elf_x86_64_arch_bed
5504 #include "elf64-target.h"
5506 /* FreeBSD L1OM support. */
5508 #undef TARGET_LITTLE_SYM
5509 #define TARGET_LITTLE_SYM bfd_elf64_l1om_freebsd_vec
5510 #undef TARGET_LITTLE_NAME
5511 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
5514 #define ELF_OSABI ELFOSABI_FREEBSD
5517 #define elf64_bed elf64_l1om_fbsd_bed
5519 #include "elf64-target.h"
5521 /* Intel K1OM support. */
5524 elf64_k1om_elf_object_p (bfd *abfd)
5526 /* Set the right machine number for an K1OM elf64 file. */
5527 bfd_default_set_arch_mach (abfd, bfd_arch_k1om, bfd_mach_k1om);
5531 #undef TARGET_LITTLE_SYM
5532 #define TARGET_LITTLE_SYM bfd_elf64_k1om_vec
5533 #undef TARGET_LITTLE_NAME
5534 #define TARGET_LITTLE_NAME "elf64-k1om"
5536 #define ELF_ARCH bfd_arch_k1om
5538 #undef ELF_MACHINE_CODE
5539 #define ELF_MACHINE_CODE EM_K1OM
5544 #define elf64_bed elf64_k1om_bed
5546 #undef elf_backend_object_p
5547 #define elf_backend_object_p elf64_k1om_elf_object_p
5549 #undef elf_backend_static_tls_alignment
5551 #undef elf_backend_want_plt_sym
5552 #define elf_backend_want_plt_sym 0
5554 #include "elf64-target.h"
5556 /* FreeBSD K1OM support. */
5558 #undef TARGET_LITTLE_SYM
5559 #define TARGET_LITTLE_SYM bfd_elf64_k1om_freebsd_vec
5560 #undef TARGET_LITTLE_NAME
5561 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
5564 #define ELF_OSABI ELFOSABI_FREEBSD
5567 #define elf64_bed elf64_k1om_fbsd_bed
5569 #include "elf64-target.h"
5571 /* 32bit x86-64 support. */
5573 #undef TARGET_LITTLE_SYM
5574 #define TARGET_LITTLE_SYM bfd_elf32_x86_64_vec
5575 #undef TARGET_LITTLE_NAME
5576 #define TARGET_LITTLE_NAME "elf32-x86-64"
5580 #define ELF_ARCH bfd_arch_i386
5582 #undef ELF_MACHINE_CODE
5583 #define ELF_MACHINE_CODE EM_X86_64
5587 #undef elf_backend_object_p
5588 #define elf_backend_object_p \
5589 elf32_x86_64_elf_object_p
5591 #undef elf_backend_bfd_from_remote_memory
5592 #define elf_backend_bfd_from_remote_memory \
5593 _bfd_elf32_bfd_from_remote_memory
5595 #undef elf_backend_size_info
5596 #define elf_backend_size_info \
5597 _bfd_elf32_size_info
5599 #include "elf32-target.h"