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_arch_data(bed) \
632 ((const struct elf_x86_64_backend_data *) (bed)->arch_data)
634 #define get_elf_x86_64_backend_data(abfd) \
635 get_elf_x86_64_arch_data (get_elf_backend_data (abfd))
637 #define GET_PLT_ENTRY_SIZE(abfd) \
638 get_elf_x86_64_backend_data (abfd)->plt_entry_size
640 /* These are the standard parameters. */
641 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed =
643 elf_x86_64_plt0_entry, /* plt0_entry */
644 elf_x86_64_plt_entry, /* plt_entry */
645 sizeof (elf_x86_64_plt_entry), /* plt_entry_size */
646 2, /* plt0_got1_offset */
647 8, /* plt0_got2_offset */
648 12, /* plt0_got2_insn_end */
649 2, /* plt_got_offset */
650 7, /* plt_reloc_offset */
651 12, /* plt_plt_offset */
652 6, /* plt_got_insn_size */
653 PLT_ENTRY_SIZE, /* plt_plt_insn_end */
654 6, /* plt_lazy_offset */
655 elf_x86_64_eh_frame_plt, /* eh_frame_plt */
656 sizeof (elf_x86_64_eh_frame_plt), /* eh_frame_plt_size */
659 #define elf_backend_arch_data &elf_x86_64_arch_bed
661 /* x86-64 ELF linker hash entry. */
663 struct elf_x86_64_link_hash_entry
665 struct elf_link_hash_entry elf;
667 /* Track dynamic relocs copied for this symbol. */
668 struct elf_dyn_relocs *dyn_relocs;
670 #define GOT_UNKNOWN 0
674 #define GOT_TLS_GDESC 4
675 #define GOT_TLS_GD_BOTH_P(type) \
676 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
677 #define GOT_TLS_GD_P(type) \
678 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
679 #define GOT_TLS_GDESC_P(type) \
680 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
681 #define GOT_TLS_GD_ANY_P(type) \
682 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
683 unsigned char tls_type;
685 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
686 starting at the end of the jump table. */
690 #define elf_x86_64_hash_entry(ent) \
691 ((struct elf_x86_64_link_hash_entry *)(ent))
693 struct elf_x86_64_obj_tdata
695 struct elf_obj_tdata root;
697 /* tls_type for each local got entry. */
698 char *local_got_tls_type;
700 /* GOTPLT entries for TLS descriptors. */
701 bfd_vma *local_tlsdesc_gotent;
704 #define elf_x86_64_tdata(abfd) \
705 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
707 #define elf_x86_64_local_got_tls_type(abfd) \
708 (elf_x86_64_tdata (abfd)->local_got_tls_type)
710 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
711 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
713 #define is_x86_64_elf(bfd) \
714 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
715 && elf_tdata (bfd) != NULL \
716 && elf_object_id (bfd) == X86_64_ELF_DATA)
719 elf_x86_64_mkobject (bfd *abfd)
721 return bfd_elf_allocate_object (abfd, sizeof (struct elf_x86_64_obj_tdata),
725 /* x86-64 ELF linker hash table. */
727 struct elf_x86_64_link_hash_table
729 struct elf_link_hash_table elf;
731 /* Short-cuts to get to dynamic linker sections. */
734 asection *plt_eh_frame;
738 bfd_signed_vma refcount;
742 /* The amount of space used by the jump slots in the GOT. */
743 bfd_vma sgotplt_jump_table_size;
745 /* Small local sym cache. */
746 struct sym_cache sym_cache;
748 bfd_vma (*r_info) (bfd_vma, bfd_vma);
749 bfd_vma (*r_sym) (bfd_vma);
750 unsigned int pointer_r_type;
751 const char *dynamic_interpreter;
752 int dynamic_interpreter_size;
754 /* _TLS_MODULE_BASE_ symbol. */
755 struct bfd_link_hash_entry *tls_module_base;
757 /* Used by local STT_GNU_IFUNC symbols. */
758 htab_t loc_hash_table;
759 void * loc_hash_memory;
761 /* The offset into splt of the PLT entry for the TLS descriptor
762 resolver. Special values are 0, if not necessary (or not found
763 to be necessary yet), and -1 if needed but not determined
766 /* The offset into sgot of the GOT entry used by the PLT entry
770 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
771 bfd_vma next_jump_slot_index;
772 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
773 bfd_vma next_irelative_index;
776 /* Get the x86-64 ELF linker hash table from a link_info structure. */
778 #define elf_x86_64_hash_table(p) \
779 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
780 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
782 #define elf_x86_64_compute_jump_table_size(htab) \
783 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
785 /* Create an entry in an x86-64 ELF linker hash table. */
787 static struct bfd_hash_entry *
788 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry *entry,
789 struct bfd_hash_table *table,
792 /* Allocate the structure if it has not already been allocated by a
796 entry = (struct bfd_hash_entry *)
797 bfd_hash_allocate (table,
798 sizeof (struct elf_x86_64_link_hash_entry));
803 /* Call the allocation method of the superclass. */
804 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
807 struct elf_x86_64_link_hash_entry *eh;
809 eh = (struct elf_x86_64_link_hash_entry *) entry;
810 eh->dyn_relocs = NULL;
811 eh->tls_type = GOT_UNKNOWN;
812 eh->tlsdesc_got = (bfd_vma) -1;
818 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
819 for local symbol so that we can handle local STT_GNU_IFUNC symbols
820 as global symbol. We reuse indx and dynstr_index for local symbol
821 hash since they aren't used by global symbols in this backend. */
824 elf_x86_64_local_htab_hash (const void *ptr)
826 struct elf_link_hash_entry *h
827 = (struct elf_link_hash_entry *) ptr;
828 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
831 /* Compare local hash entries. */
834 elf_x86_64_local_htab_eq (const void *ptr1, const void *ptr2)
836 struct elf_link_hash_entry *h1
837 = (struct elf_link_hash_entry *) ptr1;
838 struct elf_link_hash_entry *h2
839 = (struct elf_link_hash_entry *) ptr2;
841 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
844 /* Find and/or create a hash entry for local symbol. */
846 static struct elf_link_hash_entry *
847 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table *htab,
848 bfd *abfd, const Elf_Internal_Rela *rel,
851 struct elf_x86_64_link_hash_entry e, *ret;
852 asection *sec = abfd->sections;
853 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
854 htab->r_sym (rel->r_info));
857 e.elf.indx = sec->id;
858 e.elf.dynstr_index = htab->r_sym (rel->r_info);
859 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
860 create ? INSERT : NO_INSERT);
867 ret = (struct elf_x86_64_link_hash_entry *) *slot;
871 ret = (struct elf_x86_64_link_hash_entry *)
872 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
873 sizeof (struct elf_x86_64_link_hash_entry));
876 memset (ret, 0, sizeof (*ret));
877 ret->elf.indx = sec->id;
878 ret->elf.dynstr_index = htab->r_sym (rel->r_info);
879 ret->elf.dynindx = -1;
885 /* Create an X86-64 ELF linker hash table. */
887 static struct bfd_link_hash_table *
888 elf_x86_64_link_hash_table_create (bfd *abfd)
890 struct elf_x86_64_link_hash_table *ret;
891 bfd_size_type amt = sizeof (struct elf_x86_64_link_hash_table);
893 ret = (struct elf_x86_64_link_hash_table *) bfd_zmalloc (amt);
897 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
898 elf_x86_64_link_hash_newfunc,
899 sizeof (struct elf_x86_64_link_hash_entry),
908 ret->r_info = elf64_r_info;
909 ret->r_sym = elf64_r_sym;
910 ret->pointer_r_type = R_X86_64_64;
911 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
912 ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
916 ret->r_info = elf32_r_info;
917 ret->r_sym = elf32_r_sym;
918 ret->pointer_r_type = R_X86_64_32;
919 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
920 ret->dynamic_interpreter_size = sizeof ELF32_DYNAMIC_INTERPRETER;
923 ret->loc_hash_table = htab_try_create (1024,
924 elf_x86_64_local_htab_hash,
925 elf_x86_64_local_htab_eq,
927 ret->loc_hash_memory = objalloc_create ();
928 if (!ret->loc_hash_table || !ret->loc_hash_memory)
934 return &ret->elf.root;
937 /* Destroy an X86-64 ELF linker hash table. */
940 elf_x86_64_link_hash_table_free (struct bfd_link_hash_table *hash)
942 struct elf_x86_64_link_hash_table *htab
943 = (struct elf_x86_64_link_hash_table *) hash;
945 if (htab->loc_hash_table)
946 htab_delete (htab->loc_hash_table);
947 if (htab->loc_hash_memory)
948 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
949 _bfd_elf_link_hash_table_free (hash);
952 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
953 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
957 elf_x86_64_create_dynamic_sections (bfd *dynobj,
958 struct bfd_link_info *info)
960 struct elf_x86_64_link_hash_table *htab;
962 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
965 htab = elf_x86_64_hash_table (info);
969 htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
971 htab->srelbss = bfd_get_linker_section (dynobj, ".rela.bss");
974 || (!info->shared && !htab->srelbss))
977 if (!info->no_ld_generated_unwind_info
978 && htab->plt_eh_frame == NULL
979 && htab->elf.splt != NULL)
981 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
982 | SEC_HAS_CONTENTS | SEC_IN_MEMORY
983 | SEC_LINKER_CREATED);
985 = bfd_make_section_anyway_with_flags (dynobj, ".eh_frame", flags);
986 if (htab->plt_eh_frame == NULL
987 || !bfd_set_section_alignment (dynobj, htab->plt_eh_frame, 3))
993 /* Copy the extra info we tack onto an elf_link_hash_entry. */
996 elf_x86_64_copy_indirect_symbol (struct bfd_link_info *info,
997 struct elf_link_hash_entry *dir,
998 struct elf_link_hash_entry *ind)
1000 struct elf_x86_64_link_hash_entry *edir, *eind;
1002 edir = (struct elf_x86_64_link_hash_entry *) dir;
1003 eind = (struct elf_x86_64_link_hash_entry *) ind;
1005 if (eind->dyn_relocs != NULL)
1007 if (edir->dyn_relocs != NULL)
1009 struct elf_dyn_relocs **pp;
1010 struct elf_dyn_relocs *p;
1012 /* Add reloc counts against the indirect sym to the direct sym
1013 list. Merge any entries against the same section. */
1014 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1016 struct elf_dyn_relocs *q;
1018 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1019 if (q->sec == p->sec)
1021 q->pc_count += p->pc_count;
1022 q->count += p->count;
1029 *pp = edir->dyn_relocs;
1032 edir->dyn_relocs = eind->dyn_relocs;
1033 eind->dyn_relocs = NULL;
1036 if (ind->root.type == bfd_link_hash_indirect
1037 && dir->got.refcount <= 0)
1039 edir->tls_type = eind->tls_type;
1040 eind->tls_type = GOT_UNKNOWN;
1043 if (ELIMINATE_COPY_RELOCS
1044 && ind->root.type != bfd_link_hash_indirect
1045 && dir->dynamic_adjusted)
1047 /* If called to transfer flags for a weakdef during processing
1048 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1049 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1050 dir->ref_dynamic |= ind->ref_dynamic;
1051 dir->ref_regular |= ind->ref_regular;
1052 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1053 dir->needs_plt |= ind->needs_plt;
1054 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1057 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1061 elf64_x86_64_elf_object_p (bfd *abfd)
1063 /* Set the right machine number for an x86-64 elf64 file. */
1064 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64);
1069 elf32_x86_64_elf_object_p (bfd *abfd)
1071 /* Set the right machine number for an x86-64 elf32 file. */
1072 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32);
1076 /* Return TRUE if the TLS access code sequence support transition
1080 elf_x86_64_check_tls_transition (bfd *abfd,
1081 struct bfd_link_info *info,
1084 Elf_Internal_Shdr *symtab_hdr,
1085 struct elf_link_hash_entry **sym_hashes,
1086 unsigned int r_type,
1087 const Elf_Internal_Rela *rel,
1088 const Elf_Internal_Rela *relend)
1091 unsigned long r_symndx;
1092 struct elf_link_hash_entry *h;
1094 struct elf_x86_64_link_hash_table *htab;
1096 /* Get the section contents. */
1097 if (contents == NULL)
1099 if (elf_section_data (sec)->this_hdr.contents != NULL)
1100 contents = elf_section_data (sec)->this_hdr.contents;
1103 /* FIXME: How to better handle error condition? */
1104 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1107 /* Cache the section contents for elf_link_input_bfd. */
1108 elf_section_data (sec)->this_hdr.contents = contents;
1112 htab = elf_x86_64_hash_table (info);
1113 offset = rel->r_offset;
1116 case R_X86_64_TLSGD:
1117 case R_X86_64_TLSLD:
1118 if ((rel + 1) >= relend)
1121 if (r_type == R_X86_64_TLSGD)
1123 /* Check transition from GD access model. For 64bit, only
1124 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1125 .word 0x6666; rex64; call __tls_get_addr
1126 can transit to different access model. For 32bit, only
1127 leaq foo@tlsgd(%rip), %rdi
1128 .word 0x6666; rex64; call __tls_get_addr
1129 can transit to different access model. */
1131 static const unsigned char call[] = { 0x66, 0x66, 0x48, 0xe8 };
1132 static const unsigned char leaq[] = { 0x66, 0x48, 0x8d, 0x3d };
1134 if ((offset + 12) > sec->size
1135 || memcmp (contents + offset + 4, call, 4) != 0)
1138 if (ABI_64_P (abfd))
1141 || memcmp (contents + offset - 4, leaq, 4) != 0)
1147 || memcmp (contents + offset - 3, leaq + 1, 3) != 0)
1153 /* Check transition from LD access model. Only
1154 leaq foo@tlsld(%rip), %rdi;
1156 can transit to different access model. */
1158 static const unsigned char lea[] = { 0x48, 0x8d, 0x3d };
1160 if (offset < 3 || (offset + 9) > sec->size)
1163 if (memcmp (contents + offset - 3, lea, 3) != 0
1164 || 0xe8 != *(contents + offset + 4))
1168 r_symndx = htab->r_sym (rel[1].r_info);
1169 if (r_symndx < symtab_hdr->sh_info)
1172 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1173 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1174 may be versioned. */
1176 && h->root.root.string != NULL
1177 && (ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PC32
1178 || ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PLT32)
1179 && (strncmp (h->root.root.string,
1180 "__tls_get_addr", 14) == 0));
1182 case R_X86_64_GOTTPOFF:
1183 /* Check transition from IE access model:
1184 mov foo@gottpoff(%rip), %reg
1185 add foo@gottpoff(%rip), %reg
1188 /* Check REX prefix first. */
1189 if (offset >= 3 && (offset + 4) <= sec->size)
1191 val = bfd_get_8 (abfd, contents + offset - 3);
1192 if (val != 0x48 && val != 0x4c)
1194 /* X32 may have 0x44 REX prefix or no REX prefix. */
1195 if (ABI_64_P (abfd))
1201 /* X32 may not have any REX prefix. */
1202 if (ABI_64_P (abfd))
1204 if (offset < 2 || (offset + 3) > sec->size)
1208 val = bfd_get_8 (abfd, contents + offset - 2);
1209 if (val != 0x8b && val != 0x03)
1212 val = bfd_get_8 (abfd, contents + offset - 1);
1213 return (val & 0xc7) == 5;
1215 case R_X86_64_GOTPC32_TLSDESC:
1216 /* Check transition from GDesc access model:
1217 leaq x@tlsdesc(%rip), %rax
1219 Make sure it's a leaq adding rip to a 32-bit offset
1220 into any register, although it's probably almost always
1223 if (offset < 3 || (offset + 4) > sec->size)
1226 val = bfd_get_8 (abfd, contents + offset - 3);
1227 if ((val & 0xfb) != 0x48)
1230 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1233 val = bfd_get_8 (abfd, contents + offset - 1);
1234 return (val & 0xc7) == 0x05;
1236 case R_X86_64_TLSDESC_CALL:
1237 /* Check transition from GDesc access model:
1238 call *x@tlsdesc(%rax)
1240 if (offset + 2 <= sec->size)
1242 /* Make sure that it's a call *x@tlsdesc(%rax). */
1243 static const unsigned char call[] = { 0xff, 0x10 };
1244 return memcmp (contents + offset, call, 2) == 0;
1254 /* Return TRUE if the TLS access transition is OK or no transition
1255 will be performed. Update R_TYPE if there is a transition. */
1258 elf_x86_64_tls_transition (struct bfd_link_info *info, bfd *abfd,
1259 asection *sec, bfd_byte *contents,
1260 Elf_Internal_Shdr *symtab_hdr,
1261 struct elf_link_hash_entry **sym_hashes,
1262 unsigned int *r_type, int tls_type,
1263 const Elf_Internal_Rela *rel,
1264 const Elf_Internal_Rela *relend,
1265 struct elf_link_hash_entry *h,
1266 unsigned long r_symndx)
1268 unsigned int from_type = *r_type;
1269 unsigned int to_type = from_type;
1270 bfd_boolean check = TRUE;
1272 /* Skip TLS transition for functions. */
1274 && (h->type == STT_FUNC
1275 || h->type == STT_GNU_IFUNC))
1280 case R_X86_64_TLSGD:
1281 case R_X86_64_GOTPC32_TLSDESC:
1282 case R_X86_64_TLSDESC_CALL:
1283 case R_X86_64_GOTTPOFF:
1284 if (info->executable)
1287 to_type = R_X86_64_TPOFF32;
1289 to_type = R_X86_64_GOTTPOFF;
1292 /* When we are called from elf_x86_64_relocate_section,
1293 CONTENTS isn't NULL and there may be additional transitions
1294 based on TLS_TYPE. */
1295 if (contents != NULL)
1297 unsigned int new_to_type = to_type;
1299 if (info->executable
1302 && tls_type == GOT_TLS_IE)
1303 new_to_type = R_X86_64_TPOFF32;
1305 if (to_type == R_X86_64_TLSGD
1306 || to_type == R_X86_64_GOTPC32_TLSDESC
1307 || to_type == R_X86_64_TLSDESC_CALL)
1309 if (tls_type == GOT_TLS_IE)
1310 new_to_type = R_X86_64_GOTTPOFF;
1313 /* We checked the transition before when we were called from
1314 elf_x86_64_check_relocs. We only want to check the new
1315 transition which hasn't been checked before. */
1316 check = new_to_type != to_type && from_type == to_type;
1317 to_type = new_to_type;
1322 case R_X86_64_TLSLD:
1323 if (info->executable)
1324 to_type = R_X86_64_TPOFF32;
1331 /* Return TRUE if there is no transition. */
1332 if (from_type == to_type)
1335 /* Check if the transition can be performed. */
1337 && ! elf_x86_64_check_tls_transition (abfd, info, sec, contents,
1338 symtab_hdr, sym_hashes,
1339 from_type, rel, relend))
1341 reloc_howto_type *from, *to;
1344 from = elf_x86_64_rtype_to_howto (abfd, from_type);
1345 to = elf_x86_64_rtype_to_howto (abfd, to_type);
1348 name = h->root.root.string;
1351 struct elf_x86_64_link_hash_table *htab;
1353 htab = elf_x86_64_hash_table (info);
1358 Elf_Internal_Sym *isym;
1360 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1362 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1366 (*_bfd_error_handler)
1367 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1368 "in section `%A' failed"),
1369 abfd, sec, from->name, to->name, name,
1370 (unsigned long) rel->r_offset);
1371 bfd_set_error (bfd_error_bad_value);
1379 /* Look through the relocs for a section during the first phase, and
1380 calculate needed space in the global offset table, procedure
1381 linkage table, and dynamic reloc sections. */
1384 elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info,
1386 const Elf_Internal_Rela *relocs)
1388 struct elf_x86_64_link_hash_table *htab;
1389 Elf_Internal_Shdr *symtab_hdr;
1390 struct elf_link_hash_entry **sym_hashes;
1391 const Elf_Internal_Rela *rel;
1392 const Elf_Internal_Rela *rel_end;
1395 if (info->relocatable)
1398 BFD_ASSERT (is_x86_64_elf (abfd));
1400 htab = elf_x86_64_hash_table (info);
1404 symtab_hdr = &elf_symtab_hdr (abfd);
1405 sym_hashes = elf_sym_hashes (abfd);
1409 rel_end = relocs + sec->reloc_count;
1410 for (rel = relocs; rel < rel_end; rel++)
1412 unsigned int r_type;
1413 unsigned long r_symndx;
1414 struct elf_link_hash_entry *h;
1415 Elf_Internal_Sym *isym;
1417 bfd_boolean size_reloc;
1419 r_symndx = htab->r_sym (rel->r_info);
1420 r_type = ELF32_R_TYPE (rel->r_info);
1422 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1424 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1429 if (r_symndx < symtab_hdr->sh_info)
1431 /* A local symbol. */
1432 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1437 /* Check relocation against local STT_GNU_IFUNC symbol. */
1438 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1440 h = elf_x86_64_get_local_sym_hash (htab, abfd, rel,
1445 /* Fake a STT_GNU_IFUNC symbol. */
1446 h->type = STT_GNU_IFUNC;
1449 h->forced_local = 1;
1450 h->root.type = bfd_link_hash_defined;
1458 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1459 while (h->root.type == bfd_link_hash_indirect
1460 || h->root.type == bfd_link_hash_warning)
1461 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1464 /* Check invalid x32 relocations. */
1465 if (!ABI_64_P (abfd))
1471 case R_X86_64_DTPOFF64:
1472 case R_X86_64_TPOFF64:
1474 case R_X86_64_GOTOFF64:
1475 case R_X86_64_GOT64:
1476 case R_X86_64_GOTPCREL64:
1477 case R_X86_64_GOTPC64:
1478 case R_X86_64_GOTPLT64:
1479 case R_X86_64_PLTOFF64:
1482 name = h->root.root.string;
1484 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1486 (*_bfd_error_handler)
1487 (_("%B: relocation %s against symbol `%s' isn't "
1488 "supported in x32 mode"), abfd,
1489 x86_64_elf_howto_table[r_type].name, name);
1490 bfd_set_error (bfd_error_bad_value);
1498 /* Create the ifunc sections for static executables. If we
1499 never see an indirect function symbol nor we are building
1500 a static executable, those sections will be empty and
1501 won't appear in output. */
1512 case R_X86_64_PLT32:
1513 case R_X86_64_GOTPCREL:
1514 case R_X86_64_GOTPCREL64:
1515 if (htab->elf.dynobj == NULL)
1516 htab->elf.dynobj = abfd;
1517 if (!_bfd_elf_create_ifunc_sections (htab->elf.dynobj, info))
1522 /* It is referenced by a non-shared object. */
1524 h->root.non_ir_ref = 1;
1527 if (! elf_x86_64_tls_transition (info, abfd, sec, NULL,
1528 symtab_hdr, sym_hashes,
1529 &r_type, GOT_UNKNOWN,
1530 rel, rel_end, h, r_symndx))
1535 case R_X86_64_TLSLD:
1536 htab->tls_ld_got.refcount += 1;
1539 case R_X86_64_TPOFF32:
1540 if (!info->executable && ABI_64_P (abfd))
1543 name = h->root.root.string;
1545 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1547 (*_bfd_error_handler)
1548 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1550 x86_64_elf_howto_table[r_type].name, name);
1551 bfd_set_error (bfd_error_bad_value);
1556 case R_X86_64_GOTTPOFF:
1557 if (!info->executable)
1558 info->flags |= DF_STATIC_TLS;
1561 case R_X86_64_GOT32:
1562 case R_X86_64_GOTPCREL:
1563 case R_X86_64_TLSGD:
1564 case R_X86_64_GOT64:
1565 case R_X86_64_GOTPCREL64:
1566 case R_X86_64_GOTPLT64:
1567 case R_X86_64_GOTPC32_TLSDESC:
1568 case R_X86_64_TLSDESC_CALL:
1569 /* This symbol requires a global offset table entry. */
1571 int tls_type, old_tls_type;
1575 default: tls_type = GOT_NORMAL; break;
1576 case R_X86_64_TLSGD: tls_type = GOT_TLS_GD; break;
1577 case R_X86_64_GOTTPOFF: tls_type = GOT_TLS_IE; break;
1578 case R_X86_64_GOTPC32_TLSDESC:
1579 case R_X86_64_TLSDESC_CALL:
1580 tls_type = GOT_TLS_GDESC; break;
1585 if (r_type == R_X86_64_GOTPLT64)
1587 /* This relocation indicates that we also need
1588 a PLT entry, as this is a function. We don't need
1589 a PLT entry for local symbols. */
1591 h->plt.refcount += 1;
1593 h->got.refcount += 1;
1594 old_tls_type = elf_x86_64_hash_entry (h)->tls_type;
1598 bfd_signed_vma *local_got_refcounts;
1600 /* This is a global offset table entry for a local symbol. */
1601 local_got_refcounts = elf_local_got_refcounts (abfd);
1602 if (local_got_refcounts == NULL)
1606 size = symtab_hdr->sh_info;
1607 size *= sizeof (bfd_signed_vma)
1608 + sizeof (bfd_vma) + sizeof (char);
1609 local_got_refcounts = ((bfd_signed_vma *)
1610 bfd_zalloc (abfd, size));
1611 if (local_got_refcounts == NULL)
1613 elf_local_got_refcounts (abfd) = local_got_refcounts;
1614 elf_x86_64_local_tlsdesc_gotent (abfd)
1615 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
1616 elf_x86_64_local_got_tls_type (abfd)
1617 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
1619 local_got_refcounts[r_symndx] += 1;
1621 = elf_x86_64_local_got_tls_type (abfd) [r_symndx];
1624 /* If a TLS symbol is accessed using IE at least once,
1625 there is no point to use dynamic model for it. */
1626 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1627 && (! GOT_TLS_GD_ANY_P (old_tls_type)
1628 || tls_type != GOT_TLS_IE))
1630 if (old_tls_type == GOT_TLS_IE && GOT_TLS_GD_ANY_P (tls_type))
1631 tls_type = old_tls_type;
1632 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1633 && GOT_TLS_GD_ANY_P (tls_type))
1634 tls_type |= old_tls_type;
1638 name = h->root.root.string;
1640 name = bfd_elf_sym_name (abfd, symtab_hdr,
1642 (*_bfd_error_handler)
1643 (_("%B: '%s' accessed both as normal and thread local symbol"),
1645 bfd_set_error (bfd_error_bad_value);
1650 if (old_tls_type != tls_type)
1653 elf_x86_64_hash_entry (h)->tls_type = tls_type;
1655 elf_x86_64_local_got_tls_type (abfd) [r_symndx] = tls_type;
1660 case R_X86_64_GOTOFF64:
1661 case R_X86_64_GOTPC32:
1662 case R_X86_64_GOTPC64:
1664 if (htab->elf.sgot == NULL)
1666 if (htab->elf.dynobj == NULL)
1667 htab->elf.dynobj = abfd;
1668 if (!_bfd_elf_create_got_section (htab->elf.dynobj,
1674 case R_X86_64_PLT32:
1675 /* This symbol requires a procedure linkage table entry. We
1676 actually build the entry in adjust_dynamic_symbol,
1677 because this might be a case of linking PIC code which is
1678 never referenced by a dynamic object, in which case we
1679 don't need to generate a procedure linkage table entry
1682 /* If this is a local symbol, we resolve it directly without
1683 creating a procedure linkage table entry. */
1688 h->plt.refcount += 1;
1691 case R_X86_64_PLTOFF64:
1692 /* This tries to form the 'address' of a function relative
1693 to GOT. For global symbols we need a PLT entry. */
1697 h->plt.refcount += 1;
1701 case R_X86_64_SIZE32:
1702 case R_X86_64_SIZE64:
1707 if (!ABI_64_P (abfd))
1712 /* Let's help debug shared library creation. These relocs
1713 cannot be used in shared libs. Don't error out for
1714 sections we don't care about, such as debug sections or
1715 non-constant sections. */
1717 && (sec->flags & SEC_ALLOC) != 0
1718 && (sec->flags & SEC_READONLY) != 0)
1721 name = h->root.root.string;
1723 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1724 (*_bfd_error_handler)
1725 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1726 abfd, x86_64_elf_howto_table[r_type].name, name);
1727 bfd_set_error (bfd_error_bad_value);
1738 if (h != NULL && info->executable)
1740 /* If this reloc is in a read-only section, we might
1741 need a copy reloc. We can't check reliably at this
1742 stage whether the section is read-only, as input
1743 sections have not yet been mapped to output sections.
1744 Tentatively set the flag for now, and correct in
1745 adjust_dynamic_symbol. */
1748 /* We may need a .plt entry if the function this reloc
1749 refers to is in a shared lib. */
1750 h->plt.refcount += 1;
1751 if (r_type != R_X86_64_PC32 && r_type != R_X86_64_PC64)
1752 h->pointer_equality_needed = 1;
1757 /* If we are creating a shared library, and this is a reloc
1758 against a global symbol, or a non PC relative reloc
1759 against a local symbol, then we need to copy the reloc
1760 into the shared library. However, if we are linking with
1761 -Bsymbolic, we do not need to copy a reloc against a
1762 global symbol which is defined in an object we are
1763 including in the link (i.e., DEF_REGULAR is set). At
1764 this point we have not seen all the input files, so it is
1765 possible that DEF_REGULAR is not set now but will be set
1766 later (it is never cleared). In case of a weak definition,
1767 DEF_REGULAR may be cleared later by a strong definition in
1768 a shared library. We account for that possibility below by
1769 storing information in the relocs_copied field of the hash
1770 table entry. A similar situation occurs when creating
1771 shared libraries and symbol visibility changes render the
1774 If on the other hand, we are creating an executable, we
1775 may need to keep relocations for symbols satisfied by a
1776 dynamic library if we manage to avoid copy relocs for the
1779 && (sec->flags & SEC_ALLOC) != 0
1780 && (! IS_X86_64_PCREL_TYPE (r_type)
1782 && (! SYMBOLIC_BIND (info, h)
1783 || h->root.type == bfd_link_hash_defweak
1784 || !h->def_regular))))
1785 || (ELIMINATE_COPY_RELOCS
1787 && (sec->flags & SEC_ALLOC) != 0
1789 && (h->root.type == bfd_link_hash_defweak
1790 || !h->def_regular)))
1792 struct elf_dyn_relocs *p;
1793 struct elf_dyn_relocs **head;
1795 /* We must copy these reloc types into the output file.
1796 Create a reloc section in dynobj and make room for
1800 if (htab->elf.dynobj == NULL)
1801 htab->elf.dynobj = abfd;
1803 sreloc = _bfd_elf_make_dynamic_reloc_section
1804 (sec, htab->elf.dynobj, ABI_64_P (abfd) ? 3 : 2,
1805 abfd, /*rela?*/ TRUE);
1811 /* If this is a global symbol, we count the number of
1812 relocations we need for this symbol. */
1815 head = &((struct elf_x86_64_link_hash_entry *) h)->dyn_relocs;
1819 /* Track dynamic relocs needed for local syms too.
1820 We really need local syms available to do this
1825 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1830 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1834 /* Beware of type punned pointers vs strict aliasing
1836 vpp = &(elf_section_data (s)->local_dynrel);
1837 head = (struct elf_dyn_relocs **)vpp;
1841 if (p == NULL || p->sec != sec)
1843 bfd_size_type amt = sizeof *p;
1845 p = ((struct elf_dyn_relocs *)
1846 bfd_alloc (htab->elf.dynobj, amt));
1857 /* Count size relocation as PC-relative relocation. */
1858 if (IS_X86_64_PCREL_TYPE (r_type) || size_reloc)
1863 /* This relocation describes the C++ object vtable hierarchy.
1864 Reconstruct it for later use during GC. */
1865 case R_X86_64_GNU_VTINHERIT:
1866 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1870 /* This relocation describes which C++ vtable entries are actually
1871 used. Record for later use during GC. */
1872 case R_X86_64_GNU_VTENTRY:
1873 BFD_ASSERT (h != NULL);
1875 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1887 /* Return the section that should be marked against GC for a given
1891 elf_x86_64_gc_mark_hook (asection *sec,
1892 struct bfd_link_info *info,
1893 Elf_Internal_Rela *rel,
1894 struct elf_link_hash_entry *h,
1895 Elf_Internal_Sym *sym)
1898 switch (ELF32_R_TYPE (rel->r_info))
1900 case R_X86_64_GNU_VTINHERIT:
1901 case R_X86_64_GNU_VTENTRY:
1905 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1908 /* Update the got entry reference counts for the section being removed. */
1911 elf_x86_64_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1913 const Elf_Internal_Rela *relocs)
1915 struct elf_x86_64_link_hash_table *htab;
1916 Elf_Internal_Shdr *symtab_hdr;
1917 struct elf_link_hash_entry **sym_hashes;
1918 bfd_signed_vma *local_got_refcounts;
1919 const Elf_Internal_Rela *rel, *relend;
1921 if (info->relocatable)
1924 htab = elf_x86_64_hash_table (info);
1928 elf_section_data (sec)->local_dynrel = NULL;
1930 symtab_hdr = &elf_symtab_hdr (abfd);
1931 sym_hashes = elf_sym_hashes (abfd);
1932 local_got_refcounts = elf_local_got_refcounts (abfd);
1934 htab = elf_x86_64_hash_table (info);
1935 relend = relocs + sec->reloc_count;
1936 for (rel = relocs; rel < relend; rel++)
1938 unsigned long r_symndx;
1939 unsigned int r_type;
1940 struct elf_link_hash_entry *h = NULL;
1942 r_symndx = htab->r_sym (rel->r_info);
1943 if (r_symndx >= symtab_hdr->sh_info)
1945 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1946 while (h->root.type == bfd_link_hash_indirect
1947 || h->root.type == bfd_link_hash_warning)
1948 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1952 /* A local symbol. */
1953 Elf_Internal_Sym *isym;
1955 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1958 /* Check relocation against local STT_GNU_IFUNC symbol. */
1960 && ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1962 h = elf_x86_64_get_local_sym_hash (htab, abfd, rel, FALSE);
1970 struct elf_x86_64_link_hash_entry *eh;
1971 struct elf_dyn_relocs **pp;
1972 struct elf_dyn_relocs *p;
1974 eh = (struct elf_x86_64_link_hash_entry *) h;
1976 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1979 /* Everything must go for SEC. */
1985 r_type = ELF32_R_TYPE (rel->r_info);
1986 if (! elf_x86_64_tls_transition (info, abfd, sec, NULL,
1987 symtab_hdr, sym_hashes,
1988 &r_type, GOT_UNKNOWN,
1989 rel, relend, h, r_symndx))
1994 case R_X86_64_TLSLD:
1995 if (htab->tls_ld_got.refcount > 0)
1996 htab->tls_ld_got.refcount -= 1;
1999 case R_X86_64_TLSGD:
2000 case R_X86_64_GOTPC32_TLSDESC:
2001 case R_X86_64_TLSDESC_CALL:
2002 case R_X86_64_GOTTPOFF:
2003 case R_X86_64_GOT32:
2004 case R_X86_64_GOTPCREL:
2005 case R_X86_64_GOT64:
2006 case R_X86_64_GOTPCREL64:
2007 case R_X86_64_GOTPLT64:
2010 if (r_type == R_X86_64_GOTPLT64 && h->plt.refcount > 0)
2011 h->plt.refcount -= 1;
2012 if (h->got.refcount > 0)
2013 h->got.refcount -= 1;
2014 if (h->type == STT_GNU_IFUNC)
2016 if (h->plt.refcount > 0)
2017 h->plt.refcount -= 1;
2020 else if (local_got_refcounts != NULL)
2022 if (local_got_refcounts[r_symndx] > 0)
2023 local_got_refcounts[r_symndx] -= 1;
2036 case R_X86_64_SIZE32:
2037 case R_X86_64_SIZE64:
2039 && (h == NULL || h->type != STT_GNU_IFUNC))
2043 case R_X86_64_PLT32:
2044 case R_X86_64_PLTOFF64:
2047 if (h->plt.refcount > 0)
2048 h->plt.refcount -= 1;
2060 /* Adjust a symbol defined by a dynamic object and referenced by a
2061 regular object. The current definition is in some section of the
2062 dynamic object, but we're not including those sections. We have to
2063 change the definition to something the rest of the link can
2067 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info *info,
2068 struct elf_link_hash_entry *h)
2070 struct elf_x86_64_link_hash_table *htab;
2072 struct elf_x86_64_link_hash_entry *eh;
2073 struct elf_dyn_relocs *p;
2075 /* STT_GNU_IFUNC symbol must go through PLT. */
2076 if (h->type == STT_GNU_IFUNC)
2078 /* All local STT_GNU_IFUNC references must be treate as local
2079 calls via local PLT. */
2081 && SYMBOL_CALLS_LOCAL (info, h))
2083 bfd_size_type pc_count = 0, count = 0;
2084 struct elf_dyn_relocs **pp;
2086 eh = (struct elf_x86_64_link_hash_entry *) h;
2087 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2089 pc_count += p->pc_count;
2090 p->count -= p->pc_count;
2099 if (pc_count || count)
2103 if (h->plt.refcount <= 0)
2104 h->plt.refcount = 1;
2106 h->plt.refcount += 1;
2110 if (h->plt.refcount <= 0)
2112 h->plt.offset = (bfd_vma) -1;
2118 /* If this is a function, put it in the procedure linkage table. We
2119 will fill in the contents of the procedure linkage table later,
2120 when we know the address of the .got section. */
2121 if (h->type == STT_FUNC
2124 if (h->plt.refcount <= 0
2125 || SYMBOL_CALLS_LOCAL (info, h)
2126 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2127 && h->root.type == bfd_link_hash_undefweak))
2129 /* This case can occur if we saw a PLT32 reloc in an input
2130 file, but the symbol was never referred to by a dynamic
2131 object, or if all references were garbage collected. In
2132 such a case, we don't actually need to build a procedure
2133 linkage table, and we can just do a PC32 reloc instead. */
2134 h->plt.offset = (bfd_vma) -1;
2141 /* It's possible that we incorrectly decided a .plt reloc was
2142 needed for an R_X86_64_PC32 reloc to a non-function sym in
2143 check_relocs. We can't decide accurately between function and
2144 non-function syms in check-relocs; Objects loaded later in
2145 the link may change h->type. So fix it now. */
2146 h->plt.offset = (bfd_vma) -1;
2148 /* If this is a weak symbol, and there is a real definition, the
2149 processor independent code will have arranged for us to see the
2150 real definition first, and we can just use the same value. */
2151 if (h->u.weakdef != NULL)
2153 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2154 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2155 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2156 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2157 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
2158 h->non_got_ref = h->u.weakdef->non_got_ref;
2162 /* This is a reference to a symbol defined by a dynamic object which
2163 is not a function. */
2165 /* If we are creating a shared library, we must presume that the
2166 only references to the symbol are via the global offset table.
2167 For such cases we need not do anything here; the relocations will
2168 be handled correctly by relocate_section. */
2172 /* If there are no references to this symbol that do not use the
2173 GOT, we don't need to generate a copy reloc. */
2174 if (!h->non_got_ref)
2177 /* If -z nocopyreloc was given, we won't generate them either. */
2178 if (info->nocopyreloc)
2184 if (ELIMINATE_COPY_RELOCS)
2186 eh = (struct elf_x86_64_link_hash_entry *) h;
2187 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2189 s = p->sec->output_section;
2190 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2194 /* If we didn't find any dynamic relocs in read-only sections, then
2195 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2203 /* We must allocate the symbol in our .dynbss section, which will
2204 become part of the .bss section of the executable. There will be
2205 an entry for this symbol in the .dynsym section. The dynamic
2206 object will contain position independent code, so all references
2207 from the dynamic object to this symbol will go through the global
2208 offset table. The dynamic linker will use the .dynsym entry to
2209 determine the address it must put in the global offset table, so
2210 both the dynamic object and the regular object will refer to the
2211 same memory location for the variable. */
2213 htab = elf_x86_64_hash_table (info);
2217 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2218 to copy the initial value out of the dynamic object and into the
2219 runtime process image. */
2220 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2222 const struct elf_backend_data *bed;
2223 bed = get_elf_backend_data (info->output_bfd);
2224 htab->srelbss->size += bed->s->sizeof_rela;
2230 return _bfd_elf_adjust_dynamic_copy (h, s);
2233 /* Allocate space in .plt, .got and associated reloc sections for
2237 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2239 struct bfd_link_info *info;
2240 struct elf_x86_64_link_hash_table *htab;
2241 struct elf_x86_64_link_hash_entry *eh;
2242 struct elf_dyn_relocs *p;
2243 const struct elf_backend_data *bed;
2244 unsigned int plt_entry_size;
2246 if (h->root.type == bfd_link_hash_indirect)
2249 eh = (struct elf_x86_64_link_hash_entry *) h;
2251 info = (struct bfd_link_info *) inf;
2252 htab = elf_x86_64_hash_table (info);
2255 bed = get_elf_backend_data (info->output_bfd);
2256 plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
2258 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2259 here if it is defined and referenced in a non-shared object. */
2260 if (h->type == STT_GNU_IFUNC
2262 return _bfd_elf_allocate_ifunc_dyn_relocs (info, h,
2267 else if (htab->elf.dynamic_sections_created
2268 && h->plt.refcount > 0)
2270 /* Make sure this symbol is output as a dynamic symbol.
2271 Undefined weak syms won't yet be marked as dynamic. */
2272 if (h->dynindx == -1
2273 && !h->forced_local)
2275 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2280 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2282 asection *s = htab->elf.splt;
2284 /* If this is the first .plt entry, make room for the special
2287 s->size += plt_entry_size;
2289 h->plt.offset = s->size;
2291 /* If this symbol is not defined in a regular file, and we are
2292 not generating a shared library, then set the symbol to this
2293 location in the .plt. This is required to make function
2294 pointers compare as equal between the normal executable and
2295 the shared library. */
2299 h->root.u.def.section = s;
2300 h->root.u.def.value = h->plt.offset;
2303 /* Make room for this entry. */
2304 s->size += plt_entry_size;
2306 /* We also need to make an entry in the .got.plt section, which
2307 will be placed in the .got section by the linker script. */
2308 htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
2310 /* We also need to make an entry in the .rela.plt section. */
2311 htab->elf.srelplt->size += bed->s->sizeof_rela;
2312 htab->elf.srelplt->reloc_count++;
2316 h->plt.offset = (bfd_vma) -1;
2322 h->plt.offset = (bfd_vma) -1;
2326 eh->tlsdesc_got = (bfd_vma) -1;
2328 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2329 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2330 if (h->got.refcount > 0
2333 && elf_x86_64_hash_entry (h)->tls_type == GOT_TLS_IE)
2335 h->got.offset = (bfd_vma) -1;
2337 else if (h->got.refcount > 0)
2341 int tls_type = elf_x86_64_hash_entry (h)->tls_type;
2343 /* Make sure this symbol is output as a dynamic symbol.
2344 Undefined weak syms won't yet be marked as dynamic. */
2345 if (h->dynindx == -1
2346 && !h->forced_local)
2348 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2352 if (GOT_TLS_GDESC_P (tls_type))
2354 eh->tlsdesc_got = htab->elf.sgotplt->size
2355 - elf_x86_64_compute_jump_table_size (htab);
2356 htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
2357 h->got.offset = (bfd_vma) -2;
2359 if (! GOT_TLS_GDESC_P (tls_type)
2360 || GOT_TLS_GD_P (tls_type))
2363 h->got.offset = s->size;
2364 s->size += GOT_ENTRY_SIZE;
2365 if (GOT_TLS_GD_P (tls_type))
2366 s->size += GOT_ENTRY_SIZE;
2368 dyn = htab->elf.dynamic_sections_created;
2369 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2371 R_X86_64_GOTTPOFF needs one dynamic relocation. */
2372 if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
2373 || tls_type == GOT_TLS_IE)
2374 htab->elf.srelgot->size += bed->s->sizeof_rela;
2375 else if (GOT_TLS_GD_P (tls_type))
2376 htab->elf.srelgot->size += 2 * bed->s->sizeof_rela;
2377 else if (! GOT_TLS_GDESC_P (tls_type)
2378 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2379 || h->root.type != bfd_link_hash_undefweak)
2381 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
2382 htab->elf.srelgot->size += bed->s->sizeof_rela;
2383 if (GOT_TLS_GDESC_P (tls_type))
2385 htab->elf.srelplt->size += bed->s->sizeof_rela;
2386 htab->tlsdesc_plt = (bfd_vma) -1;
2390 h->got.offset = (bfd_vma) -1;
2392 if (eh->dyn_relocs == NULL)
2395 /* In the shared -Bsymbolic case, discard space allocated for
2396 dynamic pc-relative relocs against symbols which turn out to be
2397 defined in regular objects. For the normal shared case, discard
2398 space for pc-relative relocs that have become local due to symbol
2399 visibility changes. */
2403 /* Relocs that use pc_count are those that appear on a call
2404 insn, or certain REL relocs that can generated via assembly.
2405 We want calls to protected symbols to resolve directly to the
2406 function rather than going via the plt. If people want
2407 function pointer comparisons to work as expected then they
2408 should avoid writing weird assembly. */
2409 if (SYMBOL_CALLS_LOCAL (info, h))
2411 struct elf_dyn_relocs **pp;
2413 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2415 p->count -= p->pc_count;
2424 /* Also discard relocs on undefined weak syms with non-default
2426 if (eh->dyn_relocs != NULL
2427 && h->root.type == bfd_link_hash_undefweak)
2429 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2430 eh->dyn_relocs = NULL;
2432 /* Make sure undefined weak symbols are output as a dynamic
2434 else if (h->dynindx == -1
2435 && ! h->forced_local
2436 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2441 else if (ELIMINATE_COPY_RELOCS)
2443 /* For the non-shared case, discard space for relocs against
2444 symbols which turn out to need copy relocs or are not
2450 || (htab->elf.dynamic_sections_created
2451 && (h->root.type == bfd_link_hash_undefweak
2452 || h->root.type == bfd_link_hash_undefined))))
2454 /* Make sure this symbol is output as a dynamic symbol.
2455 Undefined weak syms won't yet be marked as dynamic. */
2456 if (h->dynindx == -1
2457 && ! h->forced_local
2458 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2461 /* If that succeeded, we know we'll be keeping all the
2463 if (h->dynindx != -1)
2467 eh->dyn_relocs = NULL;
2472 /* Finally, allocate space. */
2473 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2477 sreloc = elf_section_data (p->sec)->sreloc;
2479 BFD_ASSERT (sreloc != NULL);
2481 sreloc->size += p->count * bed->s->sizeof_rela;
2487 /* Allocate space in .plt, .got and associated reloc sections for
2488 local dynamic relocs. */
2491 elf_x86_64_allocate_local_dynrelocs (void **slot, void *inf)
2493 struct elf_link_hash_entry *h
2494 = (struct elf_link_hash_entry *) *slot;
2496 if (h->type != STT_GNU_IFUNC
2500 || h->root.type != bfd_link_hash_defined)
2503 return elf_x86_64_allocate_dynrelocs (h, inf);
2506 /* Find any dynamic relocs that apply to read-only sections. */
2509 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry *h,
2512 struct elf_x86_64_link_hash_entry *eh;
2513 struct elf_dyn_relocs *p;
2515 /* Skip local IFUNC symbols. */
2516 if (h->forced_local && h->type == STT_GNU_IFUNC)
2519 eh = (struct elf_x86_64_link_hash_entry *) h;
2520 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2522 asection *s = p->sec->output_section;
2524 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2526 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2528 info->flags |= DF_TEXTREL;
2530 if (info->warn_shared_textrel && info->shared)
2531 info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2532 p->sec->owner, h->root.root.string,
2535 /* Not an error, just cut short the traversal. */
2543 mov foo@GOTPCREL(%rip), %reg
2546 with the local symbol, foo. */
2549 elf_x86_64_convert_mov_to_lea (bfd *abfd, asection *sec,
2550 struct bfd_link_info *link_info)
2552 Elf_Internal_Shdr *symtab_hdr;
2553 Elf_Internal_Rela *internal_relocs;
2554 Elf_Internal_Rela *irel, *irelend;
2556 struct elf_x86_64_link_hash_table *htab;
2557 bfd_boolean changed_contents;
2558 bfd_boolean changed_relocs;
2559 bfd_signed_vma *local_got_refcounts;
2561 /* Don't even try to convert non-ELF outputs. */
2562 if (!is_elf_hash_table (link_info->hash))
2565 /* Nothing to do if there are no codes, no relocations or no output. */
2566 if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
2567 || sec->reloc_count == 0
2568 || discarded_section (sec))
2571 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2573 /* Load the relocations for this section. */
2574 internal_relocs = (_bfd_elf_link_read_relocs
2575 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
2576 link_info->keep_memory));
2577 if (internal_relocs == NULL)
2580 htab = elf_x86_64_hash_table (link_info);
2581 changed_contents = FALSE;
2582 changed_relocs = FALSE;
2583 local_got_refcounts = elf_local_got_refcounts (abfd);
2585 /* Get the section contents. */
2586 if (elf_section_data (sec)->this_hdr.contents != NULL)
2587 contents = elf_section_data (sec)->this_hdr.contents;
2590 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
2594 irelend = internal_relocs + sec->reloc_count;
2595 for (irel = internal_relocs; irel < irelend; irel++)
2597 unsigned int r_type = ELF32_R_TYPE (irel->r_info);
2598 unsigned int r_symndx = htab->r_sym (irel->r_info);
2600 struct elf_link_hash_entry *h;
2602 if (r_type != R_X86_64_GOTPCREL)
2605 /* Get the symbol referred to by the reloc. */
2606 if (r_symndx < symtab_hdr->sh_info)
2608 Elf_Internal_Sym *isym;
2610 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2613 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. */
2614 if (ELF_ST_TYPE (isym->st_info) != STT_GNU_IFUNC
2615 && bfd_get_8 (input_bfd,
2616 contents + irel->r_offset - 2) == 0x8b)
2618 bfd_put_8 (output_bfd, 0x8d,
2619 contents + irel->r_offset - 2);
2620 irel->r_info = htab->r_info (r_symndx, R_X86_64_PC32);
2621 if (local_got_refcounts != NULL
2622 && local_got_refcounts[r_symndx] > 0)
2623 local_got_refcounts[r_symndx] -= 1;
2624 changed_contents = TRUE;
2625 changed_relocs = TRUE;
2630 indx = r_symndx - symtab_hdr->sh_info;
2631 h = elf_sym_hashes (abfd)[indx];
2632 BFD_ASSERT (h != NULL);
2634 while (h->root.type == bfd_link_hash_indirect
2635 || h->root.type == bfd_link_hash_warning)
2636 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2638 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. We also
2639 avoid optimizing _DYNAMIC since ld.so may use its link-time
2642 && h->type != STT_GNU_IFUNC
2643 && h != htab->elf.hdynamic
2644 && SYMBOL_REFERENCES_LOCAL (link_info, h)
2645 && bfd_get_8 (input_bfd,
2646 contents + irel->r_offset - 2) == 0x8b)
2648 bfd_put_8 (output_bfd, 0x8d,
2649 contents + irel->r_offset - 2);
2650 irel->r_info = htab->r_info (r_symndx, R_X86_64_PC32);
2651 if (h->got.refcount > 0)
2652 h->got.refcount -= 1;
2653 changed_contents = TRUE;
2654 changed_relocs = TRUE;
2658 if (contents != NULL
2659 && elf_section_data (sec)->this_hdr.contents != contents)
2661 if (!changed_contents && !link_info->keep_memory)
2665 /* Cache the section contents for elf_link_input_bfd. */
2666 elf_section_data (sec)->this_hdr.contents = contents;
2670 if (elf_section_data (sec)->relocs != internal_relocs)
2672 if (!changed_relocs)
2673 free (internal_relocs);
2675 elf_section_data (sec)->relocs = internal_relocs;
2681 if (contents != NULL
2682 && elf_section_data (sec)->this_hdr.contents != contents)
2684 if (internal_relocs != NULL
2685 && elf_section_data (sec)->relocs != internal_relocs)
2686 free (internal_relocs);
2690 /* Set the sizes of the dynamic sections. */
2693 elf_x86_64_size_dynamic_sections (bfd *output_bfd,
2694 struct bfd_link_info *info)
2696 struct elf_x86_64_link_hash_table *htab;
2701 const struct elf_backend_data *bed;
2703 htab = elf_x86_64_hash_table (info);
2706 bed = get_elf_backend_data (output_bfd);
2708 dynobj = htab->elf.dynobj;
2712 if (htab->elf.dynamic_sections_created)
2714 /* Set the contents of the .interp section to the interpreter. */
2715 if (info->executable)
2717 s = bfd_get_linker_section (dynobj, ".interp");
2720 s->size = htab->dynamic_interpreter_size;
2721 s->contents = (unsigned char *) htab->dynamic_interpreter;
2725 /* Set up .got offsets for local syms, and space for local dynamic
2727 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2729 bfd_signed_vma *local_got;
2730 bfd_signed_vma *end_local_got;
2731 char *local_tls_type;
2732 bfd_vma *local_tlsdesc_gotent;
2733 bfd_size_type locsymcount;
2734 Elf_Internal_Shdr *symtab_hdr;
2737 if (! is_x86_64_elf (ibfd))
2740 for (s = ibfd->sections; s != NULL; s = s->next)
2742 struct elf_dyn_relocs *p;
2744 if (!elf_x86_64_convert_mov_to_lea (ibfd, s, info))
2747 for (p = (struct elf_dyn_relocs *)
2748 (elf_section_data (s)->local_dynrel);
2752 if (!bfd_is_abs_section (p->sec)
2753 && bfd_is_abs_section (p->sec->output_section))
2755 /* Input section has been discarded, either because
2756 it is a copy of a linkonce section or due to
2757 linker script /DISCARD/, so we'll be discarding
2760 else if (p->count != 0)
2762 srel = elf_section_data (p->sec)->sreloc;
2763 srel->size += p->count * bed->s->sizeof_rela;
2764 if ((p->sec->output_section->flags & SEC_READONLY) != 0
2765 && (info->flags & DF_TEXTREL) == 0)
2767 info->flags |= DF_TEXTREL;
2768 if (info->warn_shared_textrel && info->shared)
2769 info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
2770 p->sec->owner, p->sec);
2776 local_got = elf_local_got_refcounts (ibfd);
2780 symtab_hdr = &elf_symtab_hdr (ibfd);
2781 locsymcount = symtab_hdr->sh_info;
2782 end_local_got = local_got + locsymcount;
2783 local_tls_type = elf_x86_64_local_got_tls_type (ibfd);
2784 local_tlsdesc_gotent = elf_x86_64_local_tlsdesc_gotent (ibfd);
2786 srel = htab->elf.srelgot;
2787 for (; local_got < end_local_got;
2788 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
2790 *local_tlsdesc_gotent = (bfd_vma) -1;
2793 if (GOT_TLS_GDESC_P (*local_tls_type))
2795 *local_tlsdesc_gotent = htab->elf.sgotplt->size
2796 - elf_x86_64_compute_jump_table_size (htab);
2797 htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
2798 *local_got = (bfd_vma) -2;
2800 if (! GOT_TLS_GDESC_P (*local_tls_type)
2801 || GOT_TLS_GD_P (*local_tls_type))
2803 *local_got = s->size;
2804 s->size += GOT_ENTRY_SIZE;
2805 if (GOT_TLS_GD_P (*local_tls_type))
2806 s->size += GOT_ENTRY_SIZE;
2809 || GOT_TLS_GD_ANY_P (*local_tls_type)
2810 || *local_tls_type == GOT_TLS_IE)
2812 if (GOT_TLS_GDESC_P (*local_tls_type))
2814 htab->elf.srelplt->size
2815 += bed->s->sizeof_rela;
2816 htab->tlsdesc_plt = (bfd_vma) -1;
2818 if (! GOT_TLS_GDESC_P (*local_tls_type)
2819 || GOT_TLS_GD_P (*local_tls_type))
2820 srel->size += bed->s->sizeof_rela;
2824 *local_got = (bfd_vma) -1;
2828 if (htab->tls_ld_got.refcount > 0)
2830 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
2832 htab->tls_ld_got.offset = htab->elf.sgot->size;
2833 htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
2834 htab->elf.srelgot->size += bed->s->sizeof_rela;
2837 htab->tls_ld_got.offset = -1;
2839 /* Allocate global sym .plt and .got entries, and space for global
2840 sym dynamic relocs. */
2841 elf_link_hash_traverse (&htab->elf, elf_x86_64_allocate_dynrelocs,
2844 /* Allocate .plt and .got entries, and space for local symbols. */
2845 htab_traverse (htab->loc_hash_table,
2846 elf_x86_64_allocate_local_dynrelocs,
2849 /* For every jump slot reserved in the sgotplt, reloc_count is
2850 incremented. However, when we reserve space for TLS descriptors,
2851 it's not incremented, so in order to compute the space reserved
2852 for them, it suffices to multiply the reloc count by the jump
2855 PR ld/13302: We start next_irelative_index at the end of .rela.plt
2856 so that R_X86_64_IRELATIVE entries come last. */
2857 if (htab->elf.srelplt)
2859 htab->sgotplt_jump_table_size
2860 = elf_x86_64_compute_jump_table_size (htab);
2861 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
2863 else if (htab->elf.irelplt)
2864 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
2866 if (htab->tlsdesc_plt)
2868 /* If we're not using lazy TLS relocations, don't generate the
2869 PLT and GOT entries they require. */
2870 if ((info->flags & DF_BIND_NOW))
2871 htab->tlsdesc_plt = 0;
2874 htab->tlsdesc_got = htab->elf.sgot->size;
2875 htab->elf.sgot->size += GOT_ENTRY_SIZE;
2876 /* Reserve room for the initial entry.
2877 FIXME: we could probably do away with it in this case. */
2878 if (htab->elf.splt->size == 0)
2879 htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd);
2880 htab->tlsdesc_plt = htab->elf.splt->size;
2881 htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd);
2885 if (htab->elf.sgotplt)
2887 /* Don't allocate .got.plt section if there are no GOT nor PLT
2888 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
2889 if ((htab->elf.hgot == NULL
2890 || !htab->elf.hgot->ref_regular_nonweak)
2891 && (htab->elf.sgotplt->size
2892 == get_elf_backend_data (output_bfd)->got_header_size)
2893 && (htab->elf.splt == NULL
2894 || htab->elf.splt->size == 0)
2895 && (htab->elf.sgot == NULL
2896 || htab->elf.sgot->size == 0)
2897 && (htab->elf.iplt == NULL
2898 || htab->elf.iplt->size == 0)
2899 && (htab->elf.igotplt == NULL
2900 || htab->elf.igotplt->size == 0))
2901 htab->elf.sgotplt->size = 0;
2904 if (htab->plt_eh_frame != NULL
2905 && htab->elf.splt != NULL
2906 && htab->elf.splt->size != 0
2907 && !bfd_is_abs_section (htab->elf.splt->output_section)
2908 && _bfd_elf_eh_frame_present (info))
2910 const struct elf_x86_64_backend_data *arch_data
2911 = get_elf_x86_64_arch_data (bed);
2912 htab->plt_eh_frame->size = arch_data->eh_frame_plt_size;
2915 /* We now have determined the sizes of the various dynamic sections.
2916 Allocate memory for them. */
2918 for (s = dynobj->sections; s != NULL; s = s->next)
2920 if ((s->flags & SEC_LINKER_CREATED) == 0)
2923 if (s == htab->elf.splt
2924 || s == htab->elf.sgot
2925 || s == htab->elf.sgotplt
2926 || s == htab->elf.iplt
2927 || s == htab->elf.igotplt
2928 || s == htab->plt_eh_frame
2929 || s == htab->sdynbss)
2931 /* Strip this section if we don't need it; see the
2934 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2936 if (s->size != 0 && s != htab->elf.srelplt)
2939 /* We use the reloc_count field as a counter if we need
2940 to copy relocs into the output file. */
2941 if (s != htab->elf.srelplt)
2946 /* It's not one of our sections, so don't allocate space. */
2952 /* If we don't need this section, strip it from the
2953 output file. This is mostly to handle .rela.bss and
2954 .rela.plt. We must create both sections in
2955 create_dynamic_sections, because they must be created
2956 before the linker maps input sections to output
2957 sections. The linker does that before
2958 adjust_dynamic_symbol is called, and it is that
2959 function which decides whether anything needs to go
2960 into these sections. */
2962 s->flags |= SEC_EXCLUDE;
2966 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2969 /* Allocate memory for the section contents. We use bfd_zalloc
2970 here in case unused entries are not reclaimed before the
2971 section's contents are written out. This should not happen,
2972 but this way if it does, we get a R_X86_64_NONE reloc instead
2974 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2975 if (s->contents == NULL)
2979 if (htab->plt_eh_frame != NULL
2980 && htab->plt_eh_frame->contents != NULL)
2982 const struct elf_x86_64_backend_data *arch_data
2983 = get_elf_x86_64_arch_data (bed);
2985 memcpy (htab->plt_eh_frame->contents,
2986 arch_data->eh_frame_plt, htab->plt_eh_frame->size);
2987 bfd_put_32 (dynobj, htab->elf.splt->size,
2988 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
2991 if (htab->elf.dynamic_sections_created)
2993 /* Add some entries to the .dynamic section. We fill in the
2994 values later, in elf_x86_64_finish_dynamic_sections, but we
2995 must add the entries now so that we get the correct size for
2996 the .dynamic section. The DT_DEBUG entry is filled in by the
2997 dynamic linker and used by the debugger. */
2998 #define add_dynamic_entry(TAG, VAL) \
2999 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3001 if (info->executable)
3003 if (!add_dynamic_entry (DT_DEBUG, 0))
3007 if (htab->elf.splt->size != 0)
3009 if (!add_dynamic_entry (DT_PLTGOT, 0)
3010 || !add_dynamic_entry (DT_PLTRELSZ, 0)
3011 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3012 || !add_dynamic_entry (DT_JMPREL, 0))
3015 if (htab->tlsdesc_plt
3016 && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
3017 || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
3023 if (!add_dynamic_entry (DT_RELA, 0)
3024 || !add_dynamic_entry (DT_RELASZ, 0)
3025 || !add_dynamic_entry (DT_RELAENT, bed->s->sizeof_rela))
3028 /* If any dynamic relocs apply to a read-only section,
3029 then we need a DT_TEXTREL entry. */
3030 if ((info->flags & DF_TEXTREL) == 0)
3031 elf_link_hash_traverse (&htab->elf,
3032 elf_x86_64_readonly_dynrelocs,
3035 if ((info->flags & DF_TEXTREL) != 0)
3037 if (!add_dynamic_entry (DT_TEXTREL, 0))
3042 #undef add_dynamic_entry
3048 elf_x86_64_always_size_sections (bfd *output_bfd,
3049 struct bfd_link_info *info)
3051 asection *tls_sec = elf_hash_table (info)->tls_sec;
3055 struct elf_link_hash_entry *tlsbase;
3057 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
3058 "_TLS_MODULE_BASE_",
3059 FALSE, FALSE, FALSE);
3061 if (tlsbase && tlsbase->type == STT_TLS)
3063 struct elf_x86_64_link_hash_table *htab;
3064 struct bfd_link_hash_entry *bh = NULL;
3065 const struct elf_backend_data *bed
3066 = get_elf_backend_data (output_bfd);
3068 htab = elf_x86_64_hash_table (info);
3072 if (!(_bfd_generic_link_add_one_symbol
3073 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
3074 tls_sec, 0, NULL, FALSE,
3075 bed->collect, &bh)))
3078 htab->tls_module_base = bh;
3080 tlsbase = (struct elf_link_hash_entry *)bh;
3081 tlsbase->def_regular = 1;
3082 tlsbase->other = STV_HIDDEN;
3083 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
3090 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3091 executables. Rather than setting it to the beginning of the TLS
3092 section, we have to set it to the end. This function may be called
3093 multiple times, it is idempotent. */
3096 elf_x86_64_set_tls_module_base (struct bfd_link_info *info)
3098 struct elf_x86_64_link_hash_table *htab;
3099 struct bfd_link_hash_entry *base;
3101 if (!info->executable)
3104 htab = elf_x86_64_hash_table (info);
3108 base = htab->tls_module_base;
3112 base->u.def.value = htab->elf.tls_size;
3115 /* Return the base VMA address which should be subtracted from real addresses
3116 when resolving @dtpoff relocation.
3117 This is PT_TLS segment p_vaddr. */
3120 elf_x86_64_dtpoff_base (struct bfd_link_info *info)
3122 /* If tls_sec is NULL, we should have signalled an error already. */
3123 if (elf_hash_table (info)->tls_sec == NULL)
3125 return elf_hash_table (info)->tls_sec->vma;
3128 /* Return the relocation value for @tpoff relocation
3129 if STT_TLS virtual address is ADDRESS. */
3132 elf_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address)
3134 struct elf_link_hash_table *htab = elf_hash_table (info);
3135 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3136 bfd_vma static_tls_size;
3138 /* If tls_segment is NULL, we should have signalled an error already. */
3139 if (htab->tls_sec == NULL)
3142 /* Consider special static TLS alignment requirements. */
3143 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3144 return address - static_tls_size - htab->tls_sec->vma;
3147 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
3151 is_32bit_relative_branch (bfd_byte *contents, bfd_vma offset)
3153 /* Opcode Instruction
3156 0x0f 0x8x conditional jump */
3158 && (contents [offset - 1] == 0xe8
3159 || contents [offset - 1] == 0xe9))
3161 && contents [offset - 2] == 0x0f
3162 && (contents [offset - 1] & 0xf0) == 0x80));
3165 /* Relocate an x86_64 ELF section. */
3168 elf_x86_64_relocate_section (bfd *output_bfd,
3169 struct bfd_link_info *info,
3171 asection *input_section,
3173 Elf_Internal_Rela *relocs,
3174 Elf_Internal_Sym *local_syms,
3175 asection **local_sections)
3177 struct elf_x86_64_link_hash_table *htab;
3178 Elf_Internal_Shdr *symtab_hdr;
3179 struct elf_link_hash_entry **sym_hashes;
3180 bfd_vma *local_got_offsets;
3181 bfd_vma *local_tlsdesc_gotents;
3182 Elf_Internal_Rela *rel;
3183 Elf_Internal_Rela *relend;
3184 const unsigned int plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
3186 BFD_ASSERT (is_x86_64_elf (input_bfd));
3188 htab = elf_x86_64_hash_table (info);
3191 symtab_hdr = &elf_symtab_hdr (input_bfd);
3192 sym_hashes = elf_sym_hashes (input_bfd);
3193 local_got_offsets = elf_local_got_offsets (input_bfd);
3194 local_tlsdesc_gotents = elf_x86_64_local_tlsdesc_gotent (input_bfd);
3196 elf_x86_64_set_tls_module_base (info);
3199 relend = relocs + input_section->reloc_count;
3200 for (; rel < relend; rel++)
3202 unsigned int r_type;
3203 reloc_howto_type *howto;
3204 unsigned long r_symndx;
3205 struct elf_link_hash_entry *h;
3206 Elf_Internal_Sym *sym;
3208 bfd_vma off, offplt;
3210 bfd_boolean unresolved_reloc;
3211 bfd_reloc_status_type r;
3216 r_type = ELF32_R_TYPE (rel->r_info);
3217 if (r_type == (int) R_X86_64_GNU_VTINHERIT
3218 || r_type == (int) R_X86_64_GNU_VTENTRY)
3221 if (r_type >= (int) R_X86_64_standard)
3223 (*_bfd_error_handler)
3224 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3225 input_bfd, input_section, r_type);
3226 bfd_set_error (bfd_error_bad_value);
3230 if (r_type != (int) R_X86_64_32
3231 || ABI_64_P (output_bfd))
3232 howto = x86_64_elf_howto_table + r_type;
3234 howto = (x86_64_elf_howto_table
3235 + ARRAY_SIZE (x86_64_elf_howto_table) - 1);
3236 r_symndx = htab->r_sym (rel->r_info);
3240 unresolved_reloc = FALSE;
3241 if (r_symndx < symtab_hdr->sh_info)
3243 sym = local_syms + r_symndx;
3244 sec = local_sections[r_symndx];
3246 relocation = _bfd_elf_rela_local_sym (output_bfd, sym,
3248 st_size = sym->st_size;
3250 /* Relocate against local STT_GNU_IFUNC symbol. */
3251 if (!info->relocatable
3252 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3254 h = elf_x86_64_get_local_sym_hash (htab, input_bfd,
3259 /* Set STT_GNU_IFUNC symbol value. */
3260 h->root.u.def.value = sym->st_value;
3261 h->root.u.def.section = sec;
3266 bfd_boolean warned ATTRIBUTE_UNUSED;
3268 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3269 r_symndx, symtab_hdr, sym_hashes,
3271 unresolved_reloc, warned);
3275 if (sec != NULL && discarded_section (sec))
3276 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3277 rel, 1, relend, howto, 0, contents);
3279 if (info->relocatable)
3282 if (rel->r_addend == 0 && !ABI_64_P (output_bfd))
3284 if (r_type == R_X86_64_64)
3286 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
3287 zero-extend it to 64bit if addend is zero. */
3288 r_type = R_X86_64_32;
3289 memset (contents + rel->r_offset + 4, 0, 4);
3291 else if (r_type == R_X86_64_SIZE64)
3293 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
3294 zero-extend it to 64bit if addend is zero. */
3295 r_type = R_X86_64_SIZE32;
3296 memset (contents + rel->r_offset + 4, 0, 4);
3300 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3301 it here if it is defined in a non-shared object. */
3303 && h->type == STT_GNU_IFUNC
3310 if ((input_section->flags & SEC_ALLOC) == 0
3311 || h->plt.offset == (bfd_vma) -1)
3314 /* STT_GNU_IFUNC symbol must go through PLT. */
3315 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
3316 relocation = (plt->output_section->vma
3317 + plt->output_offset + h->plt.offset);
3322 if (h->root.root.string)
3323 name = h->root.root.string;
3325 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3327 (*_bfd_error_handler)
3328 (_("%B: relocation %s against STT_GNU_IFUNC "
3329 "symbol `%s' isn't handled by %s"), input_bfd,
3330 x86_64_elf_howto_table[r_type].name,
3331 name, __FUNCTION__);
3332 bfd_set_error (bfd_error_bad_value);
3341 if (ABI_64_P (output_bfd))
3345 if (rel->r_addend != 0)
3347 if (h->root.root.string)
3348 name = h->root.root.string;
3350 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
3352 (*_bfd_error_handler)
3353 (_("%B: relocation %s against STT_GNU_IFUNC "
3354 "symbol `%s' has non-zero addend: %d"),
3355 input_bfd, x86_64_elf_howto_table[r_type].name,
3356 name, rel->r_addend);
3357 bfd_set_error (bfd_error_bad_value);
3361 /* Generate dynamic relcoation only when there is a
3362 non-GOT reference in a shared object. */
3363 if (info->shared && h->non_got_ref)
3365 Elf_Internal_Rela outrel;
3368 /* Need a dynamic relocation to get the real function
3370 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
3374 if (outrel.r_offset == (bfd_vma) -1
3375 || outrel.r_offset == (bfd_vma) -2)
3378 outrel.r_offset += (input_section->output_section->vma
3379 + input_section->output_offset);
3381 if (h->dynindx == -1
3383 || info->executable)
3385 /* This symbol is resolved locally. */
3386 outrel.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
3387 outrel.r_addend = (h->root.u.def.value
3388 + h->root.u.def.section->output_section->vma
3389 + h->root.u.def.section->output_offset);
3393 outrel.r_info = htab->r_info (h->dynindx, r_type);
3394 outrel.r_addend = 0;
3397 sreloc = htab->elf.irelifunc;
3398 elf_append_rela (output_bfd, sreloc, &outrel);
3400 /* If this reloc is against an external symbol, we
3401 do not want to fiddle with the addend. Otherwise,
3402 we need to include the symbol value so that it
3403 becomes an addend for the dynamic reloc. For an
3404 internal symbol, we have updated addend. */
3410 case R_X86_64_PLT32:
3413 case R_X86_64_GOTPCREL:
3414 case R_X86_64_GOTPCREL64:
3415 base_got = htab->elf.sgot;
3416 off = h->got.offset;
3418 if (base_got == NULL)
3421 if (off == (bfd_vma) -1)
3423 /* We can't use h->got.offset here to save state, or
3424 even just remember the offset, as finish_dynamic_symbol
3425 would use that as offset into .got. */
3427 if (htab->elf.splt != NULL)
3429 plt_index = h->plt.offset / plt_entry_size - 1;
3430 off = (plt_index + 3) * GOT_ENTRY_SIZE;
3431 base_got = htab->elf.sgotplt;
3435 plt_index = h->plt.offset / plt_entry_size;
3436 off = plt_index * GOT_ENTRY_SIZE;
3437 base_got = htab->elf.igotplt;
3440 if (h->dynindx == -1
3444 /* This references the local defitionion. We must
3445 initialize this entry in the global offset table.
3446 Since the offset must always be a multiple of 8,
3447 we use the least significant bit to record
3448 whether we have initialized it already.
3450 When doing a dynamic link, we create a .rela.got
3451 relocation entry to initialize the value. This
3452 is done in the finish_dynamic_symbol routine. */
3457 bfd_put_64 (output_bfd, relocation,
3458 base_got->contents + off);
3459 /* Note that this is harmless for the GOTPLT64
3460 case, as -1 | 1 still is -1. */
3466 relocation = (base_got->output_section->vma
3467 + base_got->output_offset + off);
3473 /* When generating a shared object, the relocations handled here are
3474 copied into the output file to be resolved at run time. */
3477 case R_X86_64_GOT32:
3478 case R_X86_64_GOT64:
3479 /* Relocation is to the entry for this symbol in the global
3481 case R_X86_64_GOTPCREL:
3482 case R_X86_64_GOTPCREL64:
3483 /* Use global offset table entry as symbol value. */
3484 case R_X86_64_GOTPLT64:
3485 /* This is the same as GOT64 for relocation purposes, but
3486 indicates the existence of a PLT entry. The difficulty is,
3487 that we must calculate the GOT slot offset from the PLT
3488 offset, if this symbol got a PLT entry (it was global).
3489 Additionally if it's computed from the PLT entry, then that
3490 GOT offset is relative to .got.plt, not to .got. */
3491 base_got = htab->elf.sgot;
3493 if (htab->elf.sgot == NULL)
3500 off = h->got.offset;
3502 && h->plt.offset != (bfd_vma)-1
3503 && off == (bfd_vma)-1)
3505 /* We can't use h->got.offset here to save
3506 state, or even just remember the offset, as
3507 finish_dynamic_symbol would use that as offset into
3509 bfd_vma plt_index = h->plt.offset / plt_entry_size - 1;
3510 off = (plt_index + 3) * GOT_ENTRY_SIZE;
3511 base_got = htab->elf.sgotplt;
3514 dyn = htab->elf.dynamic_sections_created;
3516 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3518 && SYMBOL_REFERENCES_LOCAL (info, h))
3519 || (ELF_ST_VISIBILITY (h->other)
3520 && h->root.type == bfd_link_hash_undefweak))
3522 /* This is actually a static link, or it is a -Bsymbolic
3523 link and the symbol is defined locally, or the symbol
3524 was forced to be local because of a version file. We
3525 must initialize this entry in the global offset table.
3526 Since the offset must always be a multiple of 8, we
3527 use the least significant bit to record whether we
3528 have initialized it already.
3530 When doing a dynamic link, we create a .rela.got
3531 relocation entry to initialize the value. This is
3532 done in the finish_dynamic_symbol routine. */
3537 bfd_put_64 (output_bfd, relocation,
3538 base_got->contents + off);
3539 /* Note that this is harmless for the GOTPLT64 case,
3540 as -1 | 1 still is -1. */
3545 unresolved_reloc = FALSE;
3549 if (local_got_offsets == NULL)
3552 off = local_got_offsets[r_symndx];
3554 /* The offset must always be a multiple of 8. We use
3555 the least significant bit to record whether we have
3556 already generated the necessary reloc. */
3561 bfd_put_64 (output_bfd, relocation,
3562 base_got->contents + off);
3567 Elf_Internal_Rela outrel;
3569 /* We need to generate a R_X86_64_RELATIVE reloc
3570 for the dynamic linker. */
3571 s = htab->elf.srelgot;
3575 outrel.r_offset = (base_got->output_section->vma
3576 + base_got->output_offset
3578 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
3579 outrel.r_addend = relocation;
3580 elf_append_rela (output_bfd, s, &outrel);
3583 local_got_offsets[r_symndx] |= 1;
3587 if (off >= (bfd_vma) -2)
3590 relocation = base_got->output_section->vma
3591 + base_got->output_offset + off;
3592 if (r_type != R_X86_64_GOTPCREL && r_type != R_X86_64_GOTPCREL64)
3593 relocation -= htab->elf.sgotplt->output_section->vma
3594 - htab->elf.sgotplt->output_offset;
3598 case R_X86_64_GOTOFF64:
3599 /* Relocation is relative to the start of the global offset
3602 /* Check to make sure it isn't a protected function symbol
3603 for shared library since it may not be local when used
3604 as function address. */
3605 if (!info->executable
3607 && !SYMBOLIC_BIND (info, h)
3609 && h->type == STT_FUNC
3610 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
3612 (*_bfd_error_handler)
3613 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
3614 input_bfd, h->root.root.string);
3615 bfd_set_error (bfd_error_bad_value);
3619 /* Note that sgot is not involved in this
3620 calculation. We always want the start of .got.plt. If we
3621 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3622 permitted by the ABI, we might have to change this
3624 relocation -= htab->elf.sgotplt->output_section->vma
3625 + htab->elf.sgotplt->output_offset;
3628 case R_X86_64_GOTPC32:
3629 case R_X86_64_GOTPC64:
3630 /* Use global offset table as symbol value. */
3631 relocation = htab->elf.sgotplt->output_section->vma
3632 + htab->elf.sgotplt->output_offset;
3633 unresolved_reloc = FALSE;
3636 case R_X86_64_PLTOFF64:
3637 /* Relocation is PLT entry relative to GOT. For local
3638 symbols it's the symbol itself relative to GOT. */
3640 /* See PLT32 handling. */
3641 && h->plt.offset != (bfd_vma) -1
3642 && htab->elf.splt != NULL)
3644 relocation = (htab->elf.splt->output_section->vma
3645 + htab->elf.splt->output_offset
3647 unresolved_reloc = FALSE;
3650 relocation -= htab->elf.sgotplt->output_section->vma
3651 + htab->elf.sgotplt->output_offset;
3654 case R_X86_64_PLT32:
3655 /* Relocation is to the entry for this symbol in the
3656 procedure linkage table. */
3658 /* Resolve a PLT32 reloc against a local symbol directly,
3659 without using the procedure linkage table. */
3663 if (h->plt.offset == (bfd_vma) -1
3664 || htab->elf.splt == NULL)
3666 /* We didn't make a PLT entry for this symbol. This
3667 happens when statically linking PIC code, or when
3668 using -Bsymbolic. */
3672 relocation = (htab->elf.splt->output_section->vma
3673 + htab->elf.splt->output_offset
3675 unresolved_reloc = FALSE;
3678 case R_X86_64_SIZE32:
3679 case R_X86_64_SIZE64:
3680 /* Set to symbol size. */
3681 relocation = st_size;
3688 && (input_section->flags & SEC_ALLOC) != 0
3689 && (input_section->flags & SEC_READONLY) != 0
3692 bfd_boolean fail = FALSE;
3694 = (r_type == R_X86_64_PC32
3695 && is_32bit_relative_branch (contents, rel->r_offset));
3697 if (SYMBOL_REFERENCES_LOCAL (info, h))
3699 /* Symbol is referenced locally. Make sure it is
3700 defined locally or for a branch. */
3701 fail = !h->def_regular && !branch;
3705 /* Symbol isn't referenced locally. We only allow
3706 branch to symbol with non-default visibility. */
3708 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT);
3715 const char *pic = "";
3717 switch (ELF_ST_VISIBILITY (h->other))
3720 v = _("hidden symbol");
3723 v = _("internal symbol");
3726 v = _("protected symbol");
3730 pic = _("; recompile with -fPIC");
3735 fmt = _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
3737 fmt = _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
3739 (*_bfd_error_handler) (fmt, input_bfd,
3740 x86_64_elf_howto_table[r_type].name,
3741 v, h->root.root.string, pic);
3742 bfd_set_error (bfd_error_bad_value);
3753 /* FIXME: The ABI says the linker should make sure the value is
3754 the same when it's zeroextended to 64 bit. */
3757 if ((input_section->flags & SEC_ALLOC) == 0)
3762 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3763 || h->root.type != bfd_link_hash_undefweak)
3764 && ((! IS_X86_64_PCREL_TYPE (r_type)
3765 && r_type != R_X86_64_SIZE32
3766 && r_type != R_X86_64_SIZE64)
3767 || ! SYMBOL_CALLS_LOCAL (info, h)))
3768 || (ELIMINATE_COPY_RELOCS
3775 || h->root.type == bfd_link_hash_undefweak
3776 || h->root.type == bfd_link_hash_undefined)))
3778 Elf_Internal_Rela outrel;
3779 bfd_boolean skip, relocate;
3782 /* When generating a shared object, these relocations
3783 are copied into the output file to be resolved at run
3789 _bfd_elf_section_offset (output_bfd, info, input_section,
3791 if (outrel.r_offset == (bfd_vma) -1)
3793 else if (outrel.r_offset == (bfd_vma) -2)
3794 skip = TRUE, relocate = TRUE;
3796 outrel.r_offset += (input_section->output_section->vma
3797 + input_section->output_offset);
3800 memset (&outrel, 0, sizeof outrel);
3802 /* h->dynindx may be -1 if this symbol was marked to
3806 && (IS_X86_64_PCREL_TYPE (r_type)
3808 || ! SYMBOLIC_BIND (info, h)
3809 || ! h->def_regular))
3811 outrel.r_info = htab->r_info (h->dynindx, r_type);
3812 outrel.r_addend = rel->r_addend;
3816 /* This symbol is local, or marked to become local. */
3817 if (r_type == htab->pointer_r_type)
3820 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
3821 outrel.r_addend = relocation + rel->r_addend;
3823 else if (r_type == R_X86_64_64
3824 && !ABI_64_P (output_bfd))
3827 outrel.r_info = htab->r_info (0,
3828 R_X86_64_RELATIVE64);
3829 outrel.r_addend = relocation + rel->r_addend;
3830 /* Check addend overflow. */
3831 if ((outrel.r_addend & 0x80000000)
3832 != (rel->r_addend & 0x80000000))
3835 int addend = rel->r_addend;
3836 if (h && h->root.root.string)
3837 name = h->root.root.string;
3839 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
3842 (*_bfd_error_handler)
3843 (_("%B: addend -0x%x in relocation %s against "
3844 "symbol `%s' at 0x%lx in section `%A' is "
3846 input_bfd, input_section, addend,
3847 x86_64_elf_howto_table[r_type].name,
3848 name, (unsigned long) rel->r_offset);
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);
3857 bfd_set_error (bfd_error_bad_value);
3865 if (bfd_is_abs_section (sec))
3867 else if (sec == NULL || sec->owner == NULL)
3869 bfd_set_error (bfd_error_bad_value);
3876 /* We are turning this relocation into one
3877 against a section symbol. It would be
3878 proper to subtract the symbol's value,
3879 osec->vma, from the emitted reloc addend,
3880 but ld.so expects buggy relocs. */
3881 osec = sec->output_section;
3882 sindx = elf_section_data (osec)->dynindx;
3885 asection *oi = htab->elf.text_index_section;
3886 sindx = elf_section_data (oi)->dynindx;
3888 BFD_ASSERT (sindx != 0);
3891 outrel.r_info = htab->r_info (sindx, r_type);
3892 outrel.r_addend = relocation + rel->r_addend;
3896 sreloc = elf_section_data (input_section)->sreloc;
3898 if (sreloc == NULL || sreloc->contents == NULL)
3900 r = bfd_reloc_notsupported;
3901 goto check_relocation_error;
3904 elf_append_rela (output_bfd, sreloc, &outrel);
3906 /* If this reloc is against an external symbol, we do
3907 not want to fiddle with the addend. Otherwise, we
3908 need to include the symbol value so that it becomes
3909 an addend for the dynamic reloc. */
3916 case R_X86_64_TLSGD:
3917 case R_X86_64_GOTPC32_TLSDESC:
3918 case R_X86_64_TLSDESC_CALL:
3919 case R_X86_64_GOTTPOFF:
3920 tls_type = GOT_UNKNOWN;
3921 if (h == NULL && local_got_offsets)
3922 tls_type = elf_x86_64_local_got_tls_type (input_bfd) [r_symndx];
3924 tls_type = elf_x86_64_hash_entry (h)->tls_type;
3926 if (! elf_x86_64_tls_transition (info, input_bfd,
3927 input_section, contents,
3928 symtab_hdr, sym_hashes,
3929 &r_type, tls_type, rel,
3930 relend, h, r_symndx))
3933 if (r_type == R_X86_64_TPOFF32)
3935 bfd_vma roff = rel->r_offset;
3937 BFD_ASSERT (! unresolved_reloc);
3939 if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
3941 /* GD->LE transition. For 64bit, change
3942 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3943 .word 0x6666; rex64; call __tls_get_addr
3946 leaq foo@tpoff(%rax), %rax
3948 leaq foo@tlsgd(%rip), %rdi
3949 .word 0x6666; rex64; call __tls_get_addr
3952 leaq foo@tpoff(%rax), %rax */
3953 if (ABI_64_P (output_bfd))
3954 memcpy (contents + roff - 4,
3955 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3958 memcpy (contents + roff - 3,
3959 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3961 bfd_put_32 (output_bfd,
3962 elf_x86_64_tpoff (info, relocation),
3963 contents + roff + 8);
3964 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
3968 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
3970 /* GDesc -> LE transition.
3971 It's originally something like:
3972 leaq x@tlsdesc(%rip), %rax
3975 movl $x@tpoff, %rax. */
3977 unsigned int val, type;
3979 type = bfd_get_8 (input_bfd, contents + roff - 3);
3980 val = bfd_get_8 (input_bfd, contents + roff - 1);
3981 bfd_put_8 (output_bfd, 0x48 | ((type >> 2) & 1),
3982 contents + roff - 3);
3983 bfd_put_8 (output_bfd, 0xc7, contents + roff - 2);
3984 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3985 contents + roff - 1);
3986 bfd_put_32 (output_bfd,
3987 elf_x86_64_tpoff (info, relocation),
3991 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
3993 /* GDesc -> LE transition.
3998 bfd_put_8 (output_bfd, 0x66, contents + roff);
3999 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4002 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTTPOFF)
4004 /* IE->LE transition:
4005 Originally it can be one of:
4006 movq foo@gottpoff(%rip), %reg
4007 addq foo@gottpoff(%rip), %reg
4010 leaq foo(%reg), %reg
4013 unsigned int val, type, reg;
4015 val = bfd_get_8 (input_bfd, contents + roff - 3);
4016 type = bfd_get_8 (input_bfd, contents + roff - 2);
4017 reg = bfd_get_8 (input_bfd, contents + roff - 1);
4023 bfd_put_8 (output_bfd, 0x49,
4024 contents + roff - 3);
4025 else if (!ABI_64_P (output_bfd) && val == 0x44)
4026 bfd_put_8 (output_bfd, 0x41,
4027 contents + roff - 3);
4028 bfd_put_8 (output_bfd, 0xc7,
4029 contents + roff - 2);
4030 bfd_put_8 (output_bfd, 0xc0 | reg,
4031 contents + roff - 1);
4035 /* addq -> addq - addressing with %rsp/%r12 is
4038 bfd_put_8 (output_bfd, 0x49,
4039 contents + roff - 3);
4040 else if (!ABI_64_P (output_bfd) && val == 0x44)
4041 bfd_put_8 (output_bfd, 0x41,
4042 contents + roff - 3);
4043 bfd_put_8 (output_bfd, 0x81,
4044 contents + roff - 2);
4045 bfd_put_8 (output_bfd, 0xc0 | reg,
4046 contents + roff - 1);
4052 bfd_put_8 (output_bfd, 0x4d,
4053 contents + roff - 3);
4054 else if (!ABI_64_P (output_bfd) && val == 0x44)
4055 bfd_put_8 (output_bfd, 0x45,
4056 contents + roff - 3);
4057 bfd_put_8 (output_bfd, 0x8d,
4058 contents + roff - 2);
4059 bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
4060 contents + roff - 1);
4062 bfd_put_32 (output_bfd,
4063 elf_x86_64_tpoff (info, relocation),
4071 if (htab->elf.sgot == NULL)
4076 off = h->got.offset;
4077 offplt = elf_x86_64_hash_entry (h)->tlsdesc_got;
4081 if (local_got_offsets == NULL)
4084 off = local_got_offsets[r_symndx];
4085 offplt = local_tlsdesc_gotents[r_symndx];
4092 Elf_Internal_Rela outrel;
4096 if (htab->elf.srelgot == NULL)
4099 indx = h && h->dynindx != -1 ? h->dynindx : 0;
4101 if (GOT_TLS_GDESC_P (tls_type))
4103 outrel.r_info = htab->r_info (indx, R_X86_64_TLSDESC);
4104 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt
4105 + 2 * GOT_ENTRY_SIZE <= htab->elf.sgotplt->size);
4106 outrel.r_offset = (htab->elf.sgotplt->output_section->vma
4107 + htab->elf.sgotplt->output_offset
4109 + htab->sgotplt_jump_table_size);
4110 sreloc = htab->elf.srelplt;
4112 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
4114 outrel.r_addend = 0;
4115 elf_append_rela (output_bfd, sreloc, &outrel);
4118 sreloc = htab->elf.srelgot;
4120 outrel.r_offset = (htab->elf.sgot->output_section->vma
4121 + htab->elf.sgot->output_offset + off);
4123 if (GOT_TLS_GD_P (tls_type))
4124 dr_type = R_X86_64_DTPMOD64;
4125 else if (GOT_TLS_GDESC_P (tls_type))
4128 dr_type = R_X86_64_TPOFF64;
4130 bfd_put_64 (output_bfd, 0, htab->elf.sgot->contents + off);
4131 outrel.r_addend = 0;
4132 if ((dr_type == R_X86_64_TPOFF64
4133 || dr_type == R_X86_64_TLSDESC) && indx == 0)
4134 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
4135 outrel.r_info = htab->r_info (indx, dr_type);
4137 elf_append_rela (output_bfd, sreloc, &outrel);
4139 if (GOT_TLS_GD_P (tls_type))
4143 BFD_ASSERT (! unresolved_reloc);
4144 bfd_put_64 (output_bfd,
4145 relocation - elf_x86_64_dtpoff_base (info),
4146 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4150 bfd_put_64 (output_bfd, 0,
4151 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4152 outrel.r_info = htab->r_info (indx,
4154 outrel.r_offset += GOT_ENTRY_SIZE;
4155 elf_append_rela (output_bfd, sreloc,
4164 local_got_offsets[r_symndx] |= 1;
4167 if (off >= (bfd_vma) -2
4168 && ! GOT_TLS_GDESC_P (tls_type))
4170 if (r_type == ELF32_R_TYPE (rel->r_info))
4172 if (r_type == R_X86_64_GOTPC32_TLSDESC
4173 || r_type == R_X86_64_TLSDESC_CALL)
4174 relocation = htab->elf.sgotplt->output_section->vma
4175 + htab->elf.sgotplt->output_offset
4176 + offplt + htab->sgotplt_jump_table_size;
4178 relocation = htab->elf.sgot->output_section->vma
4179 + htab->elf.sgot->output_offset + off;
4180 unresolved_reloc = FALSE;
4184 bfd_vma roff = rel->r_offset;
4186 if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
4188 /* GD->IE transition. For 64bit, change
4189 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4190 .word 0x6666; rex64; call __tls_get_addr@plt
4193 addq foo@gottpoff(%rip), %rax
4195 leaq foo@tlsgd(%rip), %rdi
4196 .word 0x6666; rex64; call __tls_get_addr@plt
4199 addq foo@gottpoff(%rip), %rax */
4200 if (ABI_64_P (output_bfd))
4201 memcpy (contents + roff - 4,
4202 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4205 memcpy (contents + roff - 3,
4206 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4209 relocation = (htab->elf.sgot->output_section->vma
4210 + htab->elf.sgot->output_offset + off
4212 - input_section->output_section->vma
4213 - input_section->output_offset
4215 bfd_put_32 (output_bfd, relocation,
4216 contents + roff + 8);
4217 /* Skip R_X86_64_PLT32. */
4221 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
4223 /* GDesc -> IE transition.
4224 It's originally something like:
4225 leaq x@tlsdesc(%rip), %rax
4228 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
4230 /* Now modify the instruction as appropriate. To
4231 turn a leaq into a movq in the form we use it, it
4232 suffices to change the second byte from 0x8d to
4234 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4236 bfd_put_32 (output_bfd,
4237 htab->elf.sgot->output_section->vma
4238 + htab->elf.sgot->output_offset + off
4240 - input_section->output_section->vma
4241 - input_section->output_offset
4246 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
4248 /* GDesc -> IE transition.
4255 bfd_put_8 (output_bfd, 0x66, contents + roff);
4256 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4264 case R_X86_64_TLSLD:
4265 if (! elf_x86_64_tls_transition (info, input_bfd,
4266 input_section, contents,
4267 symtab_hdr, sym_hashes,
4268 &r_type, GOT_UNKNOWN,
4269 rel, relend, h, r_symndx))
4272 if (r_type != R_X86_64_TLSLD)
4274 /* LD->LE transition:
4275 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
4276 For 64bit, we change it into:
4277 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
4278 For 32bit, we change it into:
4279 nopl 0x0(%rax); movl %fs:0, %eax. */
4281 BFD_ASSERT (r_type == R_X86_64_TPOFF32);
4282 if (ABI_64_P (output_bfd))
4283 memcpy (contents + rel->r_offset - 3,
4284 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
4286 memcpy (contents + rel->r_offset - 3,
4287 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
4288 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
4293 if (htab->elf.sgot == NULL)
4296 off = htab->tls_ld_got.offset;
4301 Elf_Internal_Rela outrel;
4303 if (htab->elf.srelgot == NULL)
4306 outrel.r_offset = (htab->elf.sgot->output_section->vma
4307 + htab->elf.sgot->output_offset + off);
4309 bfd_put_64 (output_bfd, 0,
4310 htab->elf.sgot->contents + off);
4311 bfd_put_64 (output_bfd, 0,
4312 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4313 outrel.r_info = htab->r_info (0, R_X86_64_DTPMOD64);
4314 outrel.r_addend = 0;
4315 elf_append_rela (output_bfd, htab->elf.srelgot,
4317 htab->tls_ld_got.offset |= 1;
4319 relocation = htab->elf.sgot->output_section->vma
4320 + htab->elf.sgot->output_offset + off;
4321 unresolved_reloc = FALSE;
4324 case R_X86_64_DTPOFF32:
4325 if (!info->executable|| (input_section->flags & SEC_CODE) == 0)
4326 relocation -= elf_x86_64_dtpoff_base (info);
4328 relocation = elf_x86_64_tpoff (info, relocation);
4331 case R_X86_64_TPOFF32:
4332 case R_X86_64_TPOFF64:
4333 BFD_ASSERT (info->executable);
4334 relocation = elf_x86_64_tpoff (info, relocation);
4337 case R_X86_64_DTPOFF64:
4338 BFD_ASSERT ((input_section->flags & SEC_CODE) == 0);
4339 relocation -= elf_x86_64_dtpoff_base (info);
4346 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4347 because such sections are not SEC_ALLOC and thus ld.so will
4348 not process them. */
4349 if (unresolved_reloc
4350 && !((input_section->flags & SEC_DEBUGGING) != 0
4352 && _bfd_elf_section_offset (output_bfd, info, input_section,
4353 rel->r_offset) != (bfd_vma) -1)
4355 (*_bfd_error_handler)
4356 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4359 (long) rel->r_offset,
4361 h->root.root.string);
4366 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4367 contents, rel->r_offset,
4368 relocation, rel->r_addend);
4370 check_relocation_error:
4371 if (r != bfd_reloc_ok)
4376 name = h->root.root.string;
4379 name = bfd_elf_string_from_elf_section (input_bfd,
4380 symtab_hdr->sh_link,
4385 name = bfd_section_name (input_bfd, sec);
4388 if (r == bfd_reloc_overflow)
4390 if (! ((*info->callbacks->reloc_overflow)
4391 (info, (h ? &h->root : NULL), name, howto->name,
4392 (bfd_vma) 0, input_bfd, input_section,
4398 (*_bfd_error_handler)
4399 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4400 input_bfd, input_section,
4401 (long) rel->r_offset, name, (int) r);
4410 /* Finish up dynamic symbol handling. We set the contents of various
4411 dynamic sections here. */
4414 elf_x86_64_finish_dynamic_symbol (bfd *output_bfd,
4415 struct bfd_link_info *info,
4416 struct elf_link_hash_entry *h,
4417 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
4419 struct elf_x86_64_link_hash_table *htab;
4420 const struct elf_x86_64_backend_data *const abed
4421 = get_elf_x86_64_backend_data (output_bfd);
4423 htab = elf_x86_64_hash_table (info);
4427 if (h->plt.offset != (bfd_vma) -1)
4431 Elf_Internal_Rela rela;
4433 asection *plt, *gotplt, *relplt;
4434 const struct elf_backend_data *bed;
4436 /* When building a static executable, use .iplt, .igot.plt and
4437 .rela.iplt sections for STT_GNU_IFUNC symbols. */
4438 if (htab->elf.splt != NULL)
4440 plt = htab->elf.splt;
4441 gotplt = htab->elf.sgotplt;
4442 relplt = htab->elf.srelplt;
4446 plt = htab->elf.iplt;
4447 gotplt = htab->elf.igotplt;
4448 relplt = htab->elf.irelplt;
4451 /* This symbol has an entry in the procedure linkage table. Set
4453 if ((h->dynindx == -1
4454 && !((h->forced_local || info->executable)
4456 && h->type == STT_GNU_IFUNC))
4462 /* Get the index in the procedure linkage table which
4463 corresponds to this symbol. This is the index of this symbol
4464 in all the symbols for which we are making plt entries. The
4465 first entry in the procedure linkage table is reserved.
4467 Get the offset into the .got table of the entry that
4468 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
4469 bytes. The first three are reserved for the dynamic linker.
4471 For static executables, we don't reserve anything. */
4473 if (plt == htab->elf.splt)
4475 got_offset = h->plt.offset / abed->plt_entry_size - 1;
4476 got_offset = (got_offset + 3) * GOT_ENTRY_SIZE;
4480 got_offset = h->plt.offset / abed->plt_entry_size;
4481 got_offset = got_offset * GOT_ENTRY_SIZE;
4484 /* Fill in the entry in the procedure linkage table. */
4485 memcpy (plt->contents + h->plt.offset, abed->plt_entry,
4486 abed->plt_entry_size);
4488 /* Insert the relocation positions of the plt section. */
4490 /* Put offset the PC-relative instruction referring to the GOT entry,
4491 subtracting the size of that instruction. */
4492 bfd_put_32 (output_bfd,
4493 (gotplt->output_section->vma
4494 + gotplt->output_offset
4496 - plt->output_section->vma
4497 - plt->output_offset
4499 - abed->plt_got_insn_size),
4500 plt->contents + h->plt.offset + abed->plt_got_offset);
4502 /* Fill in the entry in the global offset table, initially this
4503 points to the second part of the PLT entry. */
4504 bfd_put_64 (output_bfd, (plt->output_section->vma
4505 + plt->output_offset
4506 + h->plt.offset + abed->plt_lazy_offset),
4507 gotplt->contents + got_offset);
4509 /* Fill in the entry in the .rela.plt section. */
4510 rela.r_offset = (gotplt->output_section->vma
4511 + gotplt->output_offset
4513 if (h->dynindx == -1
4514 || ((info->executable
4515 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4517 && h->type == STT_GNU_IFUNC))
4519 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4520 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
4521 rela.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
4522 rela.r_addend = (h->root.u.def.value
4523 + h->root.u.def.section->output_section->vma
4524 + h->root.u.def.section->output_offset);
4525 /* R_X86_64_IRELATIVE comes last. */
4526 plt_index = htab->next_irelative_index--;
4530 rela.r_info = htab->r_info (h->dynindx, R_X86_64_JUMP_SLOT);
4532 plt_index = htab->next_jump_slot_index++;
4535 /* Don't fill PLT entry for static executables. */
4536 if (plt == htab->elf.splt)
4538 /* Put relocation index. */
4539 bfd_put_32 (output_bfd, plt_index,
4540 plt->contents + h->plt.offset + abed->plt_reloc_offset);
4541 /* Put offset for jmp .PLT0. */
4542 bfd_put_32 (output_bfd, - (h->plt.offset + abed->plt_plt_insn_end),
4543 plt->contents + h->plt.offset + abed->plt_plt_offset);
4546 bed = get_elf_backend_data (output_bfd);
4547 loc = relplt->contents + plt_index * bed->s->sizeof_rela;
4548 bed->s->swap_reloca_out (output_bfd, &rela, loc);
4550 if (!h->def_regular)
4552 /* Mark the symbol as undefined, rather than as defined in
4553 the .plt section. Leave the value if there were any
4554 relocations where pointer equality matters (this is a clue
4555 for the dynamic linker, to make function pointer
4556 comparisons work between an application and shared
4557 library), otherwise set it to zero. If a function is only
4558 called from a binary, there is no need to slow down
4559 shared libraries because of that. */
4560 sym->st_shndx = SHN_UNDEF;
4561 if (!h->pointer_equality_needed)
4566 if (h->got.offset != (bfd_vma) -1
4567 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h)->tls_type)
4568 && elf_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE)
4570 Elf_Internal_Rela rela;
4572 /* This symbol has an entry in the global offset table. Set it
4574 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
4577 rela.r_offset = (htab->elf.sgot->output_section->vma
4578 + htab->elf.sgot->output_offset
4579 + (h->got.offset &~ (bfd_vma) 1));
4581 /* If this is a static link, or it is a -Bsymbolic link and the
4582 symbol is defined locally or was forced to be local because
4583 of a version file, we just want to emit a RELATIVE reloc.
4584 The entry in the global offset table will already have been
4585 initialized in the relocate_section function. */
4587 && h->type == STT_GNU_IFUNC)
4591 /* Generate R_X86_64_GLOB_DAT. */
4598 if (!h->pointer_equality_needed)
4601 /* For non-shared object, we can't use .got.plt, which
4602 contains the real function addres if we need pointer
4603 equality. We load the GOT entry with the PLT entry. */
4604 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4605 bfd_put_64 (output_bfd, (plt->output_section->vma
4606 + plt->output_offset
4608 htab->elf.sgot->contents + h->got.offset);
4612 else if (info->shared
4613 && SYMBOL_REFERENCES_LOCAL (info, h))
4615 if (!h->def_regular)
4617 BFD_ASSERT((h->got.offset & 1) != 0);
4618 rela.r_info = htab->r_info (0, R_X86_64_RELATIVE);
4619 rela.r_addend = (h->root.u.def.value
4620 + h->root.u.def.section->output_section->vma
4621 + h->root.u.def.section->output_offset);
4625 BFD_ASSERT((h->got.offset & 1) == 0);
4627 bfd_put_64 (output_bfd, (bfd_vma) 0,
4628 htab->elf.sgot->contents + h->got.offset);
4629 rela.r_info = htab->r_info (h->dynindx, R_X86_64_GLOB_DAT);
4633 elf_append_rela (output_bfd, htab->elf.srelgot, &rela);
4638 Elf_Internal_Rela rela;
4640 /* This symbol needs a copy reloc. Set it up. */
4642 if (h->dynindx == -1
4643 || (h->root.type != bfd_link_hash_defined
4644 && h->root.type != bfd_link_hash_defweak)
4645 || htab->srelbss == NULL)
4648 rela.r_offset = (h->root.u.def.value
4649 + h->root.u.def.section->output_section->vma
4650 + h->root.u.def.section->output_offset);
4651 rela.r_info = htab->r_info (h->dynindx, R_X86_64_COPY);
4653 elf_append_rela (output_bfd, htab->srelbss, &rela);
4659 /* Finish up local dynamic symbol handling. We set the contents of
4660 various dynamic sections here. */
4663 elf_x86_64_finish_local_dynamic_symbol (void **slot, void *inf)
4665 struct elf_link_hash_entry *h
4666 = (struct elf_link_hash_entry *) *slot;
4667 struct bfd_link_info *info
4668 = (struct bfd_link_info *) inf;
4670 return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
4674 /* Used to decide how to sort relocs in an optimal manner for the
4675 dynamic linker, before writing them out. */
4677 static enum elf_reloc_type_class
4678 elf_x86_64_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
4679 const asection *rel_sec ATTRIBUTE_UNUSED,
4680 const Elf_Internal_Rela *rela)
4682 switch ((int) ELF32_R_TYPE (rela->r_info))
4684 case R_X86_64_RELATIVE:
4685 case R_X86_64_RELATIVE64:
4686 return reloc_class_relative;
4687 case R_X86_64_JUMP_SLOT:
4688 return reloc_class_plt;
4690 return reloc_class_copy;
4692 return reloc_class_normal;
4696 /* Finish up the dynamic sections. */
4699 elf_x86_64_finish_dynamic_sections (bfd *output_bfd,
4700 struct bfd_link_info *info)
4702 struct elf_x86_64_link_hash_table *htab;
4705 const struct elf_x86_64_backend_data *const abed
4706 = get_elf_x86_64_backend_data (output_bfd);
4708 htab = elf_x86_64_hash_table (info);
4712 dynobj = htab->elf.dynobj;
4713 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4715 if (htab->elf.dynamic_sections_created)
4717 bfd_byte *dyncon, *dynconend;
4718 const struct elf_backend_data *bed;
4719 bfd_size_type sizeof_dyn;
4721 if (sdyn == NULL || htab->elf.sgot == NULL)
4724 bed = get_elf_backend_data (dynobj);
4725 sizeof_dyn = bed->s->sizeof_dyn;
4726 dyncon = sdyn->contents;
4727 dynconend = sdyn->contents + sdyn->size;
4728 for (; dyncon < dynconend; dyncon += sizeof_dyn)
4730 Elf_Internal_Dyn dyn;
4733 (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
4741 s = htab->elf.sgotplt;
4742 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4746 dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
4750 s = htab->elf.srelplt->output_section;
4751 dyn.d_un.d_val = s->size;
4755 /* The procedure linkage table relocs (DT_JMPREL) should
4756 not be included in the overall relocs (DT_RELA).
4757 Therefore, we override the DT_RELASZ entry here to
4758 make it not include the JMPREL relocs. Since the
4759 linker script arranges for .rela.plt to follow all
4760 other relocation sections, we don't have to worry
4761 about changing the DT_RELA entry. */
4762 if (htab->elf.srelplt != NULL)
4764 s = htab->elf.srelplt->output_section;
4765 dyn.d_un.d_val -= s->size;
4769 case DT_TLSDESC_PLT:
4771 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
4772 + htab->tlsdesc_plt;
4775 case DT_TLSDESC_GOT:
4777 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
4778 + htab->tlsdesc_got;
4782 (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
4785 /* Fill in the special first entry in the procedure linkage table. */
4786 if (htab->elf.splt && htab->elf.splt->size > 0)
4788 /* Fill in the first entry in the procedure linkage table. */
4789 memcpy (htab->elf.splt->contents,
4790 abed->plt0_entry, abed->plt_entry_size);
4791 /* Add offset for pushq GOT+8(%rip), since the instruction
4792 uses 6 bytes subtract this value. */
4793 bfd_put_32 (output_bfd,
4794 (htab->elf.sgotplt->output_section->vma
4795 + htab->elf.sgotplt->output_offset
4797 - htab->elf.splt->output_section->vma
4798 - htab->elf.splt->output_offset
4800 htab->elf.splt->contents + abed->plt0_got1_offset);
4801 /* Add offset for the PC-relative instruction accessing GOT+16,
4802 subtracting the offset to the end of that instruction. */
4803 bfd_put_32 (output_bfd,
4804 (htab->elf.sgotplt->output_section->vma
4805 + htab->elf.sgotplt->output_offset
4807 - htab->elf.splt->output_section->vma
4808 - htab->elf.splt->output_offset
4809 - abed->plt0_got2_insn_end),
4810 htab->elf.splt->contents + abed->plt0_got2_offset);
4812 elf_section_data (htab->elf.splt->output_section)
4813 ->this_hdr.sh_entsize = abed->plt_entry_size;
4815 if (htab->tlsdesc_plt)
4817 bfd_put_64 (output_bfd, (bfd_vma) 0,
4818 htab->elf.sgot->contents + htab->tlsdesc_got);
4820 memcpy (htab->elf.splt->contents + htab->tlsdesc_plt,
4821 abed->plt0_entry, abed->plt_entry_size);
4823 /* Add offset for pushq GOT+8(%rip), since the
4824 instruction uses 6 bytes subtract this value. */
4825 bfd_put_32 (output_bfd,
4826 (htab->elf.sgotplt->output_section->vma
4827 + htab->elf.sgotplt->output_offset
4829 - htab->elf.splt->output_section->vma
4830 - htab->elf.splt->output_offset
4833 htab->elf.splt->contents
4834 + htab->tlsdesc_plt + abed->plt0_got1_offset);
4835 /* Add offset for the PC-relative instruction accessing GOT+TDG,
4836 where TGD stands for htab->tlsdesc_got, subtracting the offset
4837 to the end of that instruction. */
4838 bfd_put_32 (output_bfd,
4839 (htab->elf.sgot->output_section->vma
4840 + htab->elf.sgot->output_offset
4842 - htab->elf.splt->output_section->vma
4843 - htab->elf.splt->output_offset
4845 - abed->plt0_got2_insn_end),
4846 htab->elf.splt->contents
4847 + htab->tlsdesc_plt + abed->plt0_got2_offset);
4852 if (htab->elf.sgotplt)
4854 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
4856 (*_bfd_error_handler)
4857 (_("discarded output section: `%A'"), htab->elf.sgotplt);
4861 /* Fill in the first three entries in the global offset table. */
4862 if (htab->elf.sgotplt->size > 0)
4864 /* Set the first entry in the global offset table to the address of
4865 the dynamic section. */
4867 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents);
4869 bfd_put_64 (output_bfd,
4870 sdyn->output_section->vma + sdyn->output_offset,
4871 htab->elf.sgotplt->contents);
4872 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
4873 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
4874 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE*2);
4877 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize =
4881 /* Adjust .eh_frame for .plt section. */
4882 if (htab->plt_eh_frame != NULL
4883 && htab->plt_eh_frame->contents != NULL)
4885 if (htab->elf.splt != NULL
4886 && htab->elf.splt->size != 0
4887 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
4888 && htab->elf.splt->output_section != NULL
4889 && htab->plt_eh_frame->output_section != NULL)
4891 bfd_vma plt_start = htab->elf.splt->output_section->vma;
4892 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
4893 + htab->plt_eh_frame->output_offset
4894 + PLT_FDE_START_OFFSET;
4895 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
4896 htab->plt_eh_frame->contents
4897 + PLT_FDE_START_OFFSET);
4899 if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
4901 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
4903 htab->plt_eh_frame->contents))
4908 if (htab->elf.sgot && htab->elf.sgot->size > 0)
4909 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
4912 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4913 htab_traverse (htab->loc_hash_table,
4914 elf_x86_64_finish_local_dynamic_symbol,
4920 /* Return address for Ith PLT stub in section PLT, for relocation REL
4921 or (bfd_vma) -1 if it should not be included. */
4924 elf_x86_64_plt_sym_val (bfd_vma i, const asection *plt,
4925 const arelent *rel ATTRIBUTE_UNUSED)
4927 return plt->vma + (i + 1) * GET_PLT_ENTRY_SIZE (plt->owner);
4930 /* Handle an x86-64 specific section when reading an object file. This
4931 is called when elfcode.h finds a section with an unknown type. */
4934 elf_x86_64_section_from_shdr (bfd *abfd,
4935 Elf_Internal_Shdr *hdr,
4939 if (hdr->sh_type != SHT_X86_64_UNWIND)
4942 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
4948 /* Hook called by the linker routine which adds symbols from an object
4949 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
4953 elf_x86_64_add_symbol_hook (bfd *abfd,
4954 struct bfd_link_info *info,
4955 Elf_Internal_Sym *sym,
4956 const char **namep ATTRIBUTE_UNUSED,
4957 flagword *flagsp ATTRIBUTE_UNUSED,
4963 switch (sym->st_shndx)
4965 case SHN_X86_64_LCOMMON:
4966 lcomm = bfd_get_section_by_name (abfd, "LARGE_COMMON");
4969 lcomm = bfd_make_section_with_flags (abfd,
4973 | SEC_LINKER_CREATED));
4976 elf_section_flags (lcomm) |= SHF_X86_64_LARGE;
4979 *valp = sym->st_size;
4983 if ((abfd->flags & DYNAMIC) == 0
4984 && (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
4985 || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE))
4986 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4992 /* Given a BFD section, try to locate the corresponding ELF section
4996 elf_x86_64_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
4997 asection *sec, int *index_return)
4999 if (sec == &_bfd_elf_large_com_section)
5001 *index_return = SHN_X86_64_LCOMMON;
5007 /* Process a symbol. */
5010 elf_x86_64_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
5013 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
5015 switch (elfsym->internal_elf_sym.st_shndx)
5017 case SHN_X86_64_LCOMMON:
5018 asym->section = &_bfd_elf_large_com_section;
5019 asym->value = elfsym->internal_elf_sym.st_size;
5020 /* Common symbol doesn't set BSF_GLOBAL. */
5021 asym->flags &= ~BSF_GLOBAL;
5027 elf_x86_64_common_definition (Elf_Internal_Sym *sym)
5029 return (sym->st_shndx == SHN_COMMON
5030 || sym->st_shndx == SHN_X86_64_LCOMMON);
5034 elf_x86_64_common_section_index (asection *sec)
5036 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
5039 return SHN_X86_64_LCOMMON;
5043 elf_x86_64_common_section (asection *sec)
5045 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
5046 return bfd_com_section_ptr;
5048 return &_bfd_elf_large_com_section;
5052 elf_x86_64_merge_symbol (struct elf_link_hash_entry *h,
5053 const Elf_Internal_Sym *sym,
5058 const asection *oldsec)
5060 /* A normal common symbol and a large common symbol result in a
5061 normal common symbol. We turn the large common symbol into a
5064 && h->root.type == bfd_link_hash_common
5066 && bfd_is_com_section (*psec)
5069 if (sym->st_shndx == SHN_COMMON
5070 && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) != 0)
5072 h->root.u.c.p->section
5073 = bfd_make_section_old_way (oldbfd, "COMMON");
5074 h->root.u.c.p->section->flags = SEC_ALLOC;
5076 else if (sym->st_shndx == SHN_X86_64_LCOMMON
5077 && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) == 0)
5078 *psec = bfd_com_section_ptr;
5085 elf_x86_64_additional_program_headers (bfd *abfd,
5086 struct bfd_link_info *info ATTRIBUTE_UNUSED)
5091 /* Check to see if we need a large readonly segment. */
5092 s = bfd_get_section_by_name (abfd, ".lrodata");
5093 if (s && (s->flags & SEC_LOAD))
5096 /* Check to see if we need a large data segment. Since .lbss sections
5097 is placed right after the .bss section, there should be no need for
5098 a large data segment just because of .lbss. */
5099 s = bfd_get_section_by_name (abfd, ".ldata");
5100 if (s && (s->flags & SEC_LOAD))
5106 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5109 elf_x86_64_hash_symbol (struct elf_link_hash_entry *h)
5111 if (h->plt.offset != (bfd_vma) -1
5113 && !h->pointer_equality_needed)
5116 return _bfd_elf_hash_symbol (h);
5119 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
5122 elf_x86_64_relocs_compatible (const bfd_target *input,
5123 const bfd_target *output)
5125 return ((xvec_get_elf_backend_data (input)->s->elfclass
5126 == xvec_get_elf_backend_data (output)->s->elfclass)
5127 && _bfd_elf_relocs_compatible (input, output));
5130 static const struct bfd_elf_special_section
5131 elf_x86_64_special_sections[]=
5133 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5134 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
5135 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR + SHF_X86_64_LARGE},
5136 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5137 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5138 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
5139 { NULL, 0, 0, 0, 0 }
5142 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_vec
5143 #define TARGET_LITTLE_NAME "elf64-x86-64"
5144 #define ELF_ARCH bfd_arch_i386
5145 #define ELF_TARGET_ID X86_64_ELF_DATA
5146 #define ELF_MACHINE_CODE EM_X86_64
5147 #define ELF_MAXPAGESIZE 0x200000
5148 #define ELF_MINPAGESIZE 0x1000
5149 #define ELF_COMMONPAGESIZE 0x1000
5151 #define elf_backend_can_gc_sections 1
5152 #define elf_backend_can_refcount 1
5153 #define elf_backend_want_got_plt 1
5154 #define elf_backend_plt_readonly 1
5155 #define elf_backend_want_plt_sym 0
5156 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
5157 #define elf_backend_rela_normal 1
5158 #define elf_backend_plt_alignment 4
5160 #define elf_info_to_howto elf_x86_64_info_to_howto
5162 #define bfd_elf64_bfd_link_hash_table_create \
5163 elf_x86_64_link_hash_table_create
5164 #define bfd_elf64_bfd_link_hash_table_free \
5165 elf_x86_64_link_hash_table_free
5166 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
5167 #define bfd_elf64_bfd_reloc_name_lookup \
5168 elf_x86_64_reloc_name_lookup
5170 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
5171 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
5172 #define elf_backend_check_relocs elf_x86_64_check_relocs
5173 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
5174 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
5175 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
5176 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
5177 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
5178 #define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
5179 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
5180 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
5182 #define elf_backend_write_core_note elf_x86_64_write_core_note
5184 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
5185 #define elf_backend_relocate_section elf_x86_64_relocate_section
5186 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
5187 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
5188 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
5189 #define elf_backend_plt_sym_val elf_x86_64_plt_sym_val
5190 #define elf_backend_object_p elf64_x86_64_elf_object_p
5191 #define bfd_elf64_mkobject elf_x86_64_mkobject
5193 #define elf_backend_section_from_shdr \
5194 elf_x86_64_section_from_shdr
5196 #define elf_backend_section_from_bfd_section \
5197 elf_x86_64_elf_section_from_bfd_section
5198 #define elf_backend_add_symbol_hook \
5199 elf_x86_64_add_symbol_hook
5200 #define elf_backend_symbol_processing \
5201 elf_x86_64_symbol_processing
5202 #define elf_backend_common_section_index \
5203 elf_x86_64_common_section_index
5204 #define elf_backend_common_section \
5205 elf_x86_64_common_section
5206 #define elf_backend_common_definition \
5207 elf_x86_64_common_definition
5208 #define elf_backend_merge_symbol \
5209 elf_x86_64_merge_symbol
5210 #define elf_backend_special_sections \
5211 elf_x86_64_special_sections
5212 #define elf_backend_additional_program_headers \
5213 elf_x86_64_additional_program_headers
5214 #define elf_backend_hash_symbol \
5215 elf_x86_64_hash_symbol
5217 #define elf_backend_post_process_headers _bfd_elf_set_osabi
5219 #include "elf64-target.h"
5221 /* FreeBSD support. */
5223 #undef TARGET_LITTLE_SYM
5224 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_freebsd_vec
5225 #undef TARGET_LITTLE_NAME
5226 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
5229 #define ELF_OSABI ELFOSABI_FREEBSD
5232 #define elf64_bed elf64_x86_64_fbsd_bed
5234 #include "elf64-target.h"
5236 /* Solaris 2 support. */
5238 #undef TARGET_LITTLE_SYM
5239 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_sol2_vec
5240 #undef TARGET_LITTLE_NAME
5241 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
5243 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5244 objects won't be recognized. */
5248 #define elf64_bed elf64_x86_64_sol2_bed
5250 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
5252 #undef elf_backend_static_tls_alignment
5253 #define elf_backend_static_tls_alignment 16
5255 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5257 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5259 #undef elf_backend_want_plt_sym
5260 #define elf_backend_want_plt_sym 1
5262 #include "elf64-target.h"
5264 /* Native Client support. */
5266 #undef TARGET_LITTLE_SYM
5267 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_nacl_vec
5268 #undef TARGET_LITTLE_NAME
5269 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
5271 #define elf64_bed elf64_x86_64_nacl_bed
5273 #undef ELF_MAXPAGESIZE
5274 #undef ELF_MINPAGESIZE
5275 #undef ELF_COMMONPAGESIZE
5276 #define ELF_MAXPAGESIZE 0x10000
5277 #define ELF_MINPAGESIZE 0x10000
5278 #define ELF_COMMONPAGESIZE 0x10000
5280 /* Restore defaults. */
5282 #undef elf_backend_static_tls_alignment
5283 #undef elf_backend_want_plt_sym
5284 #define elf_backend_want_plt_sym 0
5286 /* NaCl uses substantially different PLT entries for the same effects. */
5288 #undef elf_backend_plt_alignment
5289 #define elf_backend_plt_alignment 5
5290 #define NACL_PLT_ENTRY_SIZE 64
5291 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
5293 static const bfd_byte elf_x86_64_nacl_plt0_entry[NACL_PLT_ENTRY_SIZE] =
5295 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
5296 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
5297 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */
5298 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5299 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5301 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
5302 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopl %cs:0x0(%rax,%rax,1) */
5304 /* 32 bytes of nop to pad out to the standard size. */
5305 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5306 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5307 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5308 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5309 0x66, /* excess data32 prefix */
5313 static const bfd_byte elf_x86_64_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
5315 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
5316 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */
5317 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5318 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5320 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
5321 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5322 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5324 /* Lazy GOT entries point here (32-byte aligned). */
5325 0x68, /* pushq immediate */
5326 0, 0, 0, 0, /* replaced with index into relocation table. */
5327 0xe9, /* jmp relative */
5328 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
5330 /* 22 bytes of nop to pad out to the standard size. */
5331 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5332 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5333 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
5336 /* .eh_frame covering the .plt section. */
5338 static const bfd_byte elf_x86_64_nacl_eh_frame_plt[] =
5340 #if (PLT_CIE_LENGTH != 20 \
5341 || PLT_FDE_LENGTH != 36 \
5342 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
5343 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
5344 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
5346 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
5347 0, 0, 0, 0, /* CIE ID */
5348 1, /* CIE version */
5349 'z', 'R', 0, /* Augmentation string */
5350 1, /* Code alignment factor */
5351 0x78, /* Data alignment factor */
5352 16, /* Return address column */
5353 1, /* Augmentation size */
5354 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
5355 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
5356 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
5357 DW_CFA_nop, DW_CFA_nop,
5359 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
5360 PLT_CIE_LENGTH + 8, 0, 0, 0,/* CIE pointer */
5361 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
5362 0, 0, 0, 0, /* .plt size goes here */
5363 0, /* Augmentation size */
5364 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
5365 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
5366 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
5367 DW_CFA_advance_loc + 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
5368 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
5369 13, /* Block length */
5370 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
5371 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
5372 DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
5373 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
5374 DW_CFA_nop, DW_CFA_nop
5377 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed =
5379 elf_x86_64_nacl_plt0_entry, /* plt0_entry */
5380 elf_x86_64_nacl_plt_entry, /* plt_entry */
5381 NACL_PLT_ENTRY_SIZE, /* plt_entry_size */
5382 2, /* plt0_got1_offset */
5383 9, /* plt0_got2_offset */
5384 13, /* plt0_got2_insn_end */
5385 3, /* plt_got_offset */
5386 33, /* plt_reloc_offset */
5387 38, /* plt_plt_offset */
5388 7, /* plt_got_insn_size */
5389 42, /* plt_plt_insn_end */
5390 32, /* plt_lazy_offset */
5391 elf_x86_64_nacl_eh_frame_plt, /* eh_frame_plt */
5392 sizeof (elf_x86_64_nacl_eh_frame_plt), /* eh_frame_plt_size */
5395 #undef elf_backend_arch_data
5396 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
5398 #undef elf_backend_modify_segment_map
5399 #define elf_backend_modify_segment_map nacl_modify_segment_map
5400 #undef elf_backend_modify_program_headers
5401 #define elf_backend_modify_program_headers nacl_modify_program_headers
5403 #include "elf64-target.h"
5405 /* Native Client x32 support. */
5407 #undef TARGET_LITTLE_SYM
5408 #define TARGET_LITTLE_SYM bfd_elf32_x86_64_nacl_vec
5409 #undef TARGET_LITTLE_NAME
5410 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
5412 #define elf32_bed elf32_x86_64_nacl_bed
5414 #define bfd_elf32_bfd_link_hash_table_create \
5415 elf_x86_64_link_hash_table_create
5416 #define bfd_elf32_bfd_link_hash_table_free \
5417 elf_x86_64_link_hash_table_free
5418 #define bfd_elf32_bfd_reloc_type_lookup \
5419 elf_x86_64_reloc_type_lookup
5420 #define bfd_elf32_bfd_reloc_name_lookup \
5421 elf_x86_64_reloc_name_lookup
5422 #define bfd_elf32_mkobject \
5425 #undef elf_backend_object_p
5426 #define elf_backend_object_p \
5427 elf32_x86_64_elf_object_p
5429 #undef elf_backend_bfd_from_remote_memory
5430 #define elf_backend_bfd_from_remote_memory \
5431 _bfd_elf32_bfd_from_remote_memory
5433 #undef elf_backend_size_info
5434 #define elf_backend_size_info \
5435 _bfd_elf32_size_info
5437 #include "elf32-target.h"
5439 /* Restore defaults. */
5440 #undef elf_backend_object_p
5441 #define elf_backend_object_p elf64_x86_64_elf_object_p
5442 #undef elf_backend_bfd_from_remote_memory
5443 #undef elf_backend_size_info
5444 #undef elf_backend_modify_segment_map
5445 #undef elf_backend_modify_program_headers
5447 /* Intel L1OM support. */
5450 elf64_l1om_elf_object_p (bfd *abfd)
5452 /* Set the right machine number for an L1OM elf64 file. */
5453 bfd_default_set_arch_mach (abfd, bfd_arch_l1om, bfd_mach_l1om);
5457 #undef TARGET_LITTLE_SYM
5458 #define TARGET_LITTLE_SYM bfd_elf64_l1om_vec
5459 #undef TARGET_LITTLE_NAME
5460 #define TARGET_LITTLE_NAME "elf64-l1om"
5462 #define ELF_ARCH bfd_arch_l1om
5464 #undef ELF_MACHINE_CODE
5465 #define ELF_MACHINE_CODE EM_L1OM
5470 #define elf64_bed elf64_l1om_bed
5472 #undef elf_backend_object_p
5473 #define elf_backend_object_p elf64_l1om_elf_object_p
5475 /* Restore defaults. */
5476 #undef ELF_MAXPAGESIZE
5477 #undef ELF_MINPAGESIZE
5478 #undef ELF_COMMONPAGESIZE
5479 #define ELF_MAXPAGESIZE 0x200000
5480 #define ELF_MINPAGESIZE 0x1000
5481 #define ELF_COMMONPAGESIZE 0x1000
5482 #undef elf_backend_plt_alignment
5483 #define elf_backend_plt_alignment 4
5484 #undef elf_backend_arch_data
5485 #define elf_backend_arch_data &elf_x86_64_arch_bed
5487 #include "elf64-target.h"
5489 /* FreeBSD L1OM support. */
5491 #undef TARGET_LITTLE_SYM
5492 #define TARGET_LITTLE_SYM bfd_elf64_l1om_freebsd_vec
5493 #undef TARGET_LITTLE_NAME
5494 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
5497 #define ELF_OSABI ELFOSABI_FREEBSD
5500 #define elf64_bed elf64_l1om_fbsd_bed
5502 #include "elf64-target.h"
5504 /* Intel K1OM support. */
5507 elf64_k1om_elf_object_p (bfd *abfd)
5509 /* Set the right machine number for an K1OM elf64 file. */
5510 bfd_default_set_arch_mach (abfd, bfd_arch_k1om, bfd_mach_k1om);
5514 #undef TARGET_LITTLE_SYM
5515 #define TARGET_LITTLE_SYM bfd_elf64_k1om_vec
5516 #undef TARGET_LITTLE_NAME
5517 #define TARGET_LITTLE_NAME "elf64-k1om"
5519 #define ELF_ARCH bfd_arch_k1om
5521 #undef ELF_MACHINE_CODE
5522 #define ELF_MACHINE_CODE EM_K1OM
5527 #define elf64_bed elf64_k1om_bed
5529 #undef elf_backend_object_p
5530 #define elf_backend_object_p elf64_k1om_elf_object_p
5532 #undef elf_backend_static_tls_alignment
5534 #undef elf_backend_want_plt_sym
5535 #define elf_backend_want_plt_sym 0
5537 #include "elf64-target.h"
5539 /* FreeBSD K1OM support. */
5541 #undef TARGET_LITTLE_SYM
5542 #define TARGET_LITTLE_SYM bfd_elf64_k1om_freebsd_vec
5543 #undef TARGET_LITTLE_NAME
5544 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
5547 #define ELF_OSABI ELFOSABI_FREEBSD
5550 #define elf64_bed elf64_k1om_fbsd_bed
5552 #include "elf64-target.h"
5554 /* 32bit x86-64 support. */
5556 #undef TARGET_LITTLE_SYM
5557 #define TARGET_LITTLE_SYM bfd_elf32_x86_64_vec
5558 #undef TARGET_LITTLE_NAME
5559 #define TARGET_LITTLE_NAME "elf32-x86-64"
5563 #define ELF_ARCH bfd_arch_i386
5565 #undef ELF_MACHINE_CODE
5566 #define ELF_MACHINE_CODE EM_X86_64
5570 #undef elf_backend_object_p
5571 #define elf_backend_object_p \
5572 elf32_x86_64_elf_object_p
5574 #undef elf_backend_bfd_from_remote_memory
5575 #define elf_backend_bfd_from_remote_memory \
5576 _bfd_elf32_bfd_from_remote_memory
5578 #undef elf_backend_size_info
5579 #define elf_backend_size_info \
5580 _bfd_elf32_size_info
5582 #include "elf32-target.h"