1 /* X86-64 specific support for ELF
2 Copyright (C) 2000-2016 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka <jh@suse.cz>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
28 #include "bfd_stdint.h"
32 #include "libiberty.h"
34 #include "opcode/i386.h"
35 #include "elf/x86-64.h"
42 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
43 #define MINUS_ONE (~ (bfd_vma) 0)
45 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
46 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
47 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
48 since they are the same. */
50 #define ABI_64_P(abfd) \
51 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
53 /* The relocation "howto" table. Order of fields:
54 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
55 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
56 static reloc_howto_type x86_64_elf_howto_table[] =
58 HOWTO(R_X86_64_NONE, 0, 3, 0, FALSE, 0, complain_overflow_dont,
59 bfd_elf_generic_reloc, "R_X86_64_NONE", FALSE, 0x00000000, 0x00000000,
61 HOWTO(R_X86_64_64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
62 bfd_elf_generic_reloc, "R_X86_64_64", FALSE, MINUS_ONE, MINUS_ONE,
64 HOWTO(R_X86_64_PC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
65 bfd_elf_generic_reloc, "R_X86_64_PC32", FALSE, 0xffffffff, 0xffffffff,
67 HOWTO(R_X86_64_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
68 bfd_elf_generic_reloc, "R_X86_64_GOT32", FALSE, 0xffffffff, 0xffffffff,
70 HOWTO(R_X86_64_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
71 bfd_elf_generic_reloc, "R_X86_64_PLT32", FALSE, 0xffffffff, 0xffffffff,
73 HOWTO(R_X86_64_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
74 bfd_elf_generic_reloc, "R_X86_64_COPY", FALSE, 0xffffffff, 0xffffffff,
76 HOWTO(R_X86_64_GLOB_DAT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
77 bfd_elf_generic_reloc, "R_X86_64_GLOB_DAT", FALSE, MINUS_ONE,
79 HOWTO(R_X86_64_JUMP_SLOT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
80 bfd_elf_generic_reloc, "R_X86_64_JUMP_SLOT", FALSE, MINUS_ONE,
82 HOWTO(R_X86_64_RELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
83 bfd_elf_generic_reloc, "R_X86_64_RELATIVE", FALSE, MINUS_ONE,
85 HOWTO(R_X86_64_GOTPCREL, 0, 2, 32, TRUE, 0, complain_overflow_signed,
86 bfd_elf_generic_reloc, "R_X86_64_GOTPCREL", FALSE, 0xffffffff,
88 HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
89 bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
91 HOWTO(R_X86_64_32S, 0, 2, 32, FALSE, 0, complain_overflow_signed,
92 bfd_elf_generic_reloc, "R_X86_64_32S", FALSE, 0xffffffff, 0xffffffff,
94 HOWTO(R_X86_64_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
95 bfd_elf_generic_reloc, "R_X86_64_16", FALSE, 0xffff, 0xffff, FALSE),
96 HOWTO(R_X86_64_PC16,0, 1, 16, TRUE, 0, complain_overflow_bitfield,
97 bfd_elf_generic_reloc, "R_X86_64_PC16", FALSE, 0xffff, 0xffff, TRUE),
98 HOWTO(R_X86_64_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
99 bfd_elf_generic_reloc, "R_X86_64_8", FALSE, 0xff, 0xff, FALSE),
100 HOWTO(R_X86_64_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
101 bfd_elf_generic_reloc, "R_X86_64_PC8", FALSE, 0xff, 0xff, TRUE),
102 HOWTO(R_X86_64_DTPMOD64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
103 bfd_elf_generic_reloc, "R_X86_64_DTPMOD64", FALSE, MINUS_ONE,
105 HOWTO(R_X86_64_DTPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
106 bfd_elf_generic_reloc, "R_X86_64_DTPOFF64", FALSE, MINUS_ONE,
108 HOWTO(R_X86_64_TPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
109 bfd_elf_generic_reloc, "R_X86_64_TPOFF64", FALSE, MINUS_ONE,
111 HOWTO(R_X86_64_TLSGD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
112 bfd_elf_generic_reloc, "R_X86_64_TLSGD", FALSE, 0xffffffff,
114 HOWTO(R_X86_64_TLSLD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
115 bfd_elf_generic_reloc, "R_X86_64_TLSLD", FALSE, 0xffffffff,
117 HOWTO(R_X86_64_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
118 bfd_elf_generic_reloc, "R_X86_64_DTPOFF32", FALSE, 0xffffffff,
120 HOWTO(R_X86_64_GOTTPOFF, 0, 2, 32, TRUE, 0, complain_overflow_signed,
121 bfd_elf_generic_reloc, "R_X86_64_GOTTPOFF", FALSE, 0xffffffff,
123 HOWTO(R_X86_64_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
124 bfd_elf_generic_reloc, "R_X86_64_TPOFF32", FALSE, 0xffffffff,
126 HOWTO(R_X86_64_PC64, 0, 4, 64, TRUE, 0, complain_overflow_bitfield,
127 bfd_elf_generic_reloc, "R_X86_64_PC64", FALSE, MINUS_ONE, MINUS_ONE,
129 HOWTO(R_X86_64_GOTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
130 bfd_elf_generic_reloc, "R_X86_64_GOTOFF64",
131 FALSE, MINUS_ONE, MINUS_ONE, FALSE),
132 HOWTO(R_X86_64_GOTPC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
133 bfd_elf_generic_reloc, "R_X86_64_GOTPC32",
134 FALSE, 0xffffffff, 0xffffffff, TRUE),
135 HOWTO(R_X86_64_GOT64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
136 bfd_elf_generic_reloc, "R_X86_64_GOT64", FALSE, MINUS_ONE, MINUS_ONE,
138 HOWTO(R_X86_64_GOTPCREL64, 0, 4, 64, TRUE, 0, complain_overflow_signed,
139 bfd_elf_generic_reloc, "R_X86_64_GOTPCREL64", FALSE, MINUS_ONE,
141 HOWTO(R_X86_64_GOTPC64, 0, 4, 64, TRUE, 0, complain_overflow_signed,
142 bfd_elf_generic_reloc, "R_X86_64_GOTPC64",
143 FALSE, MINUS_ONE, MINUS_ONE, TRUE),
144 HOWTO(R_X86_64_GOTPLT64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
145 bfd_elf_generic_reloc, "R_X86_64_GOTPLT64", FALSE, MINUS_ONE,
147 HOWTO(R_X86_64_PLTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
148 bfd_elf_generic_reloc, "R_X86_64_PLTOFF64", FALSE, MINUS_ONE,
150 HOWTO(R_X86_64_SIZE32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
151 bfd_elf_generic_reloc, "R_X86_64_SIZE32", FALSE, 0xffffffff, 0xffffffff,
153 HOWTO(R_X86_64_SIZE64, 0, 4, 64, FALSE, 0, complain_overflow_unsigned,
154 bfd_elf_generic_reloc, "R_X86_64_SIZE64", FALSE, MINUS_ONE, MINUS_ONE,
156 HOWTO(R_X86_64_GOTPC32_TLSDESC, 0, 2, 32, TRUE, 0,
157 complain_overflow_bitfield, bfd_elf_generic_reloc,
158 "R_X86_64_GOTPC32_TLSDESC",
159 FALSE, 0xffffffff, 0xffffffff, TRUE),
160 HOWTO(R_X86_64_TLSDESC_CALL, 0, 0, 0, FALSE, 0,
161 complain_overflow_dont, bfd_elf_generic_reloc,
162 "R_X86_64_TLSDESC_CALL",
164 HOWTO(R_X86_64_TLSDESC, 0, 4, 64, FALSE, 0,
165 complain_overflow_bitfield, bfd_elf_generic_reloc,
167 FALSE, MINUS_ONE, MINUS_ONE, FALSE),
168 HOWTO(R_X86_64_IRELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
169 bfd_elf_generic_reloc, "R_X86_64_IRELATIVE", FALSE, MINUS_ONE,
171 HOWTO(R_X86_64_RELATIVE64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
172 bfd_elf_generic_reloc, "R_X86_64_RELATIVE64", FALSE, MINUS_ONE,
174 HOWTO(R_X86_64_PC32_BND, 0, 2, 32, TRUE, 0, complain_overflow_signed,
175 bfd_elf_generic_reloc, "R_X86_64_PC32_BND", FALSE, 0xffffffff, 0xffffffff,
177 HOWTO(R_X86_64_PLT32_BND, 0, 2, 32, TRUE, 0, complain_overflow_signed,
178 bfd_elf_generic_reloc, "R_X86_64_PLT32_BND", FALSE, 0xffffffff, 0xffffffff,
180 HOWTO(R_X86_64_GOTPCRELX, 0, 2, 32, TRUE, 0, complain_overflow_signed,
181 bfd_elf_generic_reloc, "R_X86_64_GOTPCRELX", FALSE, 0xffffffff,
183 HOWTO(R_X86_64_REX_GOTPCRELX, 0, 2, 32, TRUE, 0, complain_overflow_signed,
184 bfd_elf_generic_reloc, "R_X86_64_REX_GOTPCRELX", FALSE, 0xffffffff,
187 /* We have a gap in the reloc numbers here.
188 R_X86_64_standard counts the number up to this point, and
189 R_X86_64_vt_offset is the value to subtract from a reloc type of
190 R_X86_64_GNU_VT* to form an index into this table. */
191 #define R_X86_64_standard (R_X86_64_REX_GOTPCRELX + 1)
192 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
194 /* GNU extension to record C++ vtable hierarchy. */
195 HOWTO (R_X86_64_GNU_VTINHERIT, 0, 4, 0, FALSE, 0, complain_overflow_dont,
196 NULL, "R_X86_64_GNU_VTINHERIT", FALSE, 0, 0, FALSE),
198 /* GNU extension to record C++ vtable member usage. */
199 HOWTO (R_X86_64_GNU_VTENTRY, 0, 4, 0, FALSE, 0, complain_overflow_dont,
200 _bfd_elf_rel_vtable_reloc_fn, "R_X86_64_GNU_VTENTRY", FALSE, 0, 0,
203 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
204 HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
205 bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
209 #define IS_X86_64_PCREL_TYPE(TYPE) \
210 ( ((TYPE) == R_X86_64_PC8) \
211 || ((TYPE) == R_X86_64_PC16) \
212 || ((TYPE) == R_X86_64_PC32) \
213 || ((TYPE) == R_X86_64_PC32_BND) \
214 || ((TYPE) == R_X86_64_PC64))
216 /* Map BFD relocs to the x86_64 elf relocs. */
219 bfd_reloc_code_real_type bfd_reloc_val;
220 unsigned char elf_reloc_val;
223 static const struct elf_reloc_map x86_64_reloc_map[] =
225 { BFD_RELOC_NONE, R_X86_64_NONE, },
226 { BFD_RELOC_64, R_X86_64_64, },
227 { BFD_RELOC_32_PCREL, R_X86_64_PC32, },
228 { BFD_RELOC_X86_64_GOT32, R_X86_64_GOT32,},
229 { BFD_RELOC_X86_64_PLT32, R_X86_64_PLT32,},
230 { BFD_RELOC_X86_64_COPY, R_X86_64_COPY, },
231 { BFD_RELOC_X86_64_GLOB_DAT, R_X86_64_GLOB_DAT, },
232 { BFD_RELOC_X86_64_JUMP_SLOT, R_X86_64_JUMP_SLOT, },
233 { BFD_RELOC_X86_64_RELATIVE, R_X86_64_RELATIVE, },
234 { BFD_RELOC_X86_64_GOTPCREL, R_X86_64_GOTPCREL, },
235 { BFD_RELOC_32, R_X86_64_32, },
236 { BFD_RELOC_X86_64_32S, R_X86_64_32S, },
237 { BFD_RELOC_16, R_X86_64_16, },
238 { BFD_RELOC_16_PCREL, R_X86_64_PC16, },
239 { BFD_RELOC_8, R_X86_64_8, },
240 { BFD_RELOC_8_PCREL, R_X86_64_PC8, },
241 { BFD_RELOC_X86_64_DTPMOD64, R_X86_64_DTPMOD64, },
242 { BFD_RELOC_X86_64_DTPOFF64, R_X86_64_DTPOFF64, },
243 { BFD_RELOC_X86_64_TPOFF64, R_X86_64_TPOFF64, },
244 { BFD_RELOC_X86_64_TLSGD, R_X86_64_TLSGD, },
245 { BFD_RELOC_X86_64_TLSLD, R_X86_64_TLSLD, },
246 { BFD_RELOC_X86_64_DTPOFF32, R_X86_64_DTPOFF32, },
247 { BFD_RELOC_X86_64_GOTTPOFF, R_X86_64_GOTTPOFF, },
248 { BFD_RELOC_X86_64_TPOFF32, R_X86_64_TPOFF32, },
249 { BFD_RELOC_64_PCREL, R_X86_64_PC64, },
250 { BFD_RELOC_X86_64_GOTOFF64, R_X86_64_GOTOFF64, },
251 { BFD_RELOC_X86_64_GOTPC32, R_X86_64_GOTPC32, },
252 { BFD_RELOC_X86_64_GOT64, R_X86_64_GOT64, },
253 { BFD_RELOC_X86_64_GOTPCREL64,R_X86_64_GOTPCREL64, },
254 { BFD_RELOC_X86_64_GOTPC64, R_X86_64_GOTPC64, },
255 { BFD_RELOC_X86_64_GOTPLT64, R_X86_64_GOTPLT64, },
256 { BFD_RELOC_X86_64_PLTOFF64, R_X86_64_PLTOFF64, },
257 { BFD_RELOC_SIZE32, R_X86_64_SIZE32, },
258 { BFD_RELOC_SIZE64, R_X86_64_SIZE64, },
259 { BFD_RELOC_X86_64_GOTPC32_TLSDESC, R_X86_64_GOTPC32_TLSDESC, },
260 { BFD_RELOC_X86_64_TLSDESC_CALL, R_X86_64_TLSDESC_CALL, },
261 { BFD_RELOC_X86_64_TLSDESC, R_X86_64_TLSDESC, },
262 { BFD_RELOC_X86_64_IRELATIVE, R_X86_64_IRELATIVE, },
263 { BFD_RELOC_X86_64_PC32_BND, R_X86_64_PC32_BND, },
264 { BFD_RELOC_X86_64_PLT32_BND, R_X86_64_PLT32_BND, },
265 { BFD_RELOC_X86_64_GOTPCRELX, R_X86_64_GOTPCRELX, },
266 { BFD_RELOC_X86_64_REX_GOTPCRELX, R_X86_64_REX_GOTPCRELX, },
267 { BFD_RELOC_VTABLE_INHERIT, R_X86_64_GNU_VTINHERIT, },
268 { BFD_RELOC_VTABLE_ENTRY, R_X86_64_GNU_VTENTRY, },
271 static reloc_howto_type *
272 elf_x86_64_rtype_to_howto (bfd *abfd, unsigned r_type)
276 if (r_type == (unsigned int) R_X86_64_32)
281 i = ARRAY_SIZE (x86_64_elf_howto_table) - 1;
283 else if (r_type < (unsigned int) R_X86_64_GNU_VTINHERIT
284 || r_type >= (unsigned int) R_X86_64_max)
286 if (r_type >= (unsigned int) R_X86_64_standard)
288 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
290 r_type = R_X86_64_NONE;
295 i = r_type - (unsigned int) R_X86_64_vt_offset;
296 BFD_ASSERT (x86_64_elf_howto_table[i].type == r_type);
297 return &x86_64_elf_howto_table[i];
300 /* Given a BFD reloc type, return a HOWTO structure. */
301 static reloc_howto_type *
302 elf_x86_64_reloc_type_lookup (bfd *abfd,
303 bfd_reloc_code_real_type code)
307 for (i = 0; i < sizeof (x86_64_reloc_map) / sizeof (struct elf_reloc_map);
310 if (x86_64_reloc_map[i].bfd_reloc_val == code)
311 return elf_x86_64_rtype_to_howto (abfd,
312 x86_64_reloc_map[i].elf_reloc_val);
317 static reloc_howto_type *
318 elf_x86_64_reloc_name_lookup (bfd *abfd,
323 if (!ABI_64_P (abfd) && strcasecmp (r_name, "R_X86_64_32") == 0)
325 /* Get x32 R_X86_64_32. */
326 reloc_howto_type *reloc
327 = &x86_64_elf_howto_table[ARRAY_SIZE (x86_64_elf_howto_table) - 1];
328 BFD_ASSERT (reloc->type == (unsigned int) R_X86_64_32);
332 for (i = 0; i < ARRAY_SIZE (x86_64_elf_howto_table); i++)
333 if (x86_64_elf_howto_table[i].name != NULL
334 && strcasecmp (x86_64_elf_howto_table[i].name, r_name) == 0)
335 return &x86_64_elf_howto_table[i];
340 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
343 elf_x86_64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
344 Elf_Internal_Rela *dst)
348 r_type = ELF32_R_TYPE (dst->r_info);
349 cache_ptr->howto = elf_x86_64_rtype_to_howto (abfd, r_type);
350 BFD_ASSERT (r_type == cache_ptr->howto->type);
353 /* Support for core dump NOTE sections. */
355 elf_x86_64_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
360 switch (note->descsz)
365 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
367 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
370 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
378 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
380 elf_tdata (abfd)->core->signal
381 = bfd_get_16 (abfd, note->descdata + 12);
384 elf_tdata (abfd)->core->lwpid
385 = bfd_get_32 (abfd, note->descdata + 32);
394 /* Make a ".reg/999" section. */
395 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
396 size, note->descpos + offset);
400 elf_x86_64_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
402 switch (note->descsz)
407 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
408 elf_tdata (abfd)->core->pid
409 = bfd_get_32 (abfd, note->descdata + 12);
410 elf_tdata (abfd)->core->program
411 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
412 elf_tdata (abfd)->core->command
413 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
416 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
417 elf_tdata (abfd)->core->pid
418 = bfd_get_32 (abfd, note->descdata + 24);
419 elf_tdata (abfd)->core->program
420 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
421 elf_tdata (abfd)->core->command
422 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
425 /* Note that for some reason, a spurious space is tacked
426 onto the end of the args in some (at least one anyway)
427 implementations, so strip it off if it exists. */
430 char *command = elf_tdata (abfd)->core->command;
431 int n = strlen (command);
433 if (0 < n && command[n - 1] == ' ')
434 command[n - 1] = '\0';
442 elf_x86_64_write_core_note (bfd *abfd, char *buf, int *bufsiz,
445 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
447 const char *fname, *psargs;
458 va_start (ap, note_type);
459 fname = va_arg (ap, const char *);
460 psargs = va_arg (ap, const char *);
463 if (bed->s->elfclass == ELFCLASS32)
466 memset (&data, 0, sizeof (data));
467 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
468 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
469 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
470 &data, sizeof (data));
475 memset (&data, 0, sizeof (data));
476 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
477 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
478 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
479 &data, sizeof (data));
484 va_start (ap, note_type);
485 pid = va_arg (ap, long);
486 cursig = va_arg (ap, int);
487 gregs = va_arg (ap, const void *);
490 if (bed->s->elfclass == ELFCLASS32)
492 if (bed->elf_machine_code == EM_X86_64)
494 prstatusx32_t prstat;
495 memset (&prstat, 0, sizeof (prstat));
497 prstat.pr_cursig = cursig;
498 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
499 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
500 &prstat, sizeof (prstat));
505 memset (&prstat, 0, sizeof (prstat));
507 prstat.pr_cursig = cursig;
508 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
509 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
510 &prstat, sizeof (prstat));
516 memset (&prstat, 0, sizeof (prstat));
518 prstat.pr_cursig = cursig;
519 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
520 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
521 &prstat, sizeof (prstat));
528 /* Functions for the x86-64 ELF linker. */
530 /* The name of the dynamic interpreter. This is put in the .interp
533 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
534 #define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
536 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
537 copying dynamic variables from a shared lib into an app's dynbss
538 section, and instead use a dynamic relocation to point into the
540 #define ELIMINATE_COPY_RELOCS 1
542 /* The size in bytes of an entry in the global offset table. */
544 #define GOT_ENTRY_SIZE 8
546 /* The size in bytes of an entry in the procedure linkage table. */
548 #define PLT_ENTRY_SIZE 16
550 /* The first entry in a procedure linkage table looks like this. See the
551 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
553 static const bfd_byte elf_x86_64_plt0_entry[PLT_ENTRY_SIZE] =
555 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
556 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
557 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
560 /* Subsequent entries in a procedure linkage table look like this. */
562 static const bfd_byte elf_x86_64_plt_entry[PLT_ENTRY_SIZE] =
564 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
565 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
566 0x68, /* pushq immediate */
567 0, 0, 0, 0, /* replaced with index into relocation table. */
568 0xe9, /* jmp relative */
569 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
572 /* The first entry in a procedure linkage table with BND relocations
575 static const bfd_byte elf_x86_64_bnd_plt0_entry[PLT_ENTRY_SIZE] =
577 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
578 0xf2, 0xff, 0x25, 16, 0, 0, 0, /* bnd jmpq *GOT+16(%rip) */
579 0x0f, 0x1f, 0 /* nopl (%rax) */
582 /* Subsequent entries for legacy branches in a procedure linkage table
583 with BND relocations look like this. */
585 static const bfd_byte elf_x86_64_legacy_plt_entry[PLT_ENTRY_SIZE] =
587 0x68, 0, 0, 0, 0, /* pushq immediate */
588 0xe9, 0, 0, 0, 0, /* jmpq relative */
589 0x66, 0x0f, 0x1f, 0x44, 0, 0 /* nopw (%rax,%rax,1) */
592 /* Subsequent entries for branches with BND prefx in a procedure linkage
593 table with BND relocations look like this. */
595 static const bfd_byte elf_x86_64_bnd_plt_entry[PLT_ENTRY_SIZE] =
597 0x68, 0, 0, 0, 0, /* pushq immediate */
598 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
599 0x0f, 0x1f, 0x44, 0, 0 /* nopl 0(%rax,%rax,1) */
602 /* Entries for legacy branches in the second procedure linkage table
605 static const bfd_byte elf_x86_64_legacy_plt2_entry[8] =
607 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
608 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
609 0x66, 0x90 /* xchg %ax,%ax */
612 /* Entries for branches with BND prefix in the second procedure linkage
613 table look like this. */
615 static const bfd_byte elf_x86_64_bnd_plt2_entry[8] =
617 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
618 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
622 /* .eh_frame covering the .plt section. */
624 static const bfd_byte elf_x86_64_eh_frame_plt[] =
626 #define PLT_CIE_LENGTH 20
627 #define PLT_FDE_LENGTH 36
628 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
629 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
630 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
631 0, 0, 0, 0, /* CIE ID */
633 'z', 'R', 0, /* Augmentation string */
634 1, /* Code alignment factor */
635 0x78, /* Data alignment factor */
636 16, /* Return address column */
637 1, /* Augmentation size */
638 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
639 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
640 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
641 DW_CFA_nop, DW_CFA_nop,
643 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
644 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
645 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
646 0, 0, 0, 0, /* .plt size goes here */
647 0, /* Augmentation size */
648 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
649 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
650 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
651 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
652 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
653 11, /* Block length */
654 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
655 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
656 DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
657 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
658 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
661 /* Architecture-specific backend data for x86-64. */
663 struct elf_x86_64_backend_data
665 /* Templates for the initial PLT entry and for subsequent entries. */
666 const bfd_byte *plt0_entry;
667 const bfd_byte *plt_entry;
668 unsigned int plt_entry_size; /* Size of each PLT entry. */
670 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
671 unsigned int plt0_got1_offset;
672 unsigned int plt0_got2_offset;
674 /* Offset of the end of the PC-relative instruction containing
676 unsigned int plt0_got2_insn_end;
678 /* Offsets into plt_entry that are to be replaced with... */
679 unsigned int plt_got_offset; /* ... address of this symbol in .got. */
680 unsigned int plt_reloc_offset; /* ... offset into relocation table. */
681 unsigned int plt_plt_offset; /* ... offset to start of .plt. */
683 /* Length of the PC-relative instruction containing plt_got_offset. */
684 unsigned int plt_got_insn_size;
686 /* Offset of the end of the PC-relative jump to plt0_entry. */
687 unsigned int plt_plt_insn_end;
689 /* Offset into plt_entry where the initial value of the GOT entry points. */
690 unsigned int plt_lazy_offset;
692 /* .eh_frame covering the .plt section. */
693 const bfd_byte *eh_frame_plt;
694 unsigned int eh_frame_plt_size;
697 #define get_elf_x86_64_arch_data(bed) \
698 ((const struct elf_x86_64_backend_data *) (bed)->arch_data)
700 #define get_elf_x86_64_backend_data(abfd) \
701 get_elf_x86_64_arch_data (get_elf_backend_data (abfd))
703 #define GET_PLT_ENTRY_SIZE(abfd) \
704 get_elf_x86_64_backend_data (abfd)->plt_entry_size
706 /* These are the standard parameters. */
707 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed =
709 elf_x86_64_plt0_entry, /* plt0_entry */
710 elf_x86_64_plt_entry, /* plt_entry */
711 sizeof (elf_x86_64_plt_entry), /* plt_entry_size */
712 2, /* plt0_got1_offset */
713 8, /* plt0_got2_offset */
714 12, /* plt0_got2_insn_end */
715 2, /* plt_got_offset */
716 7, /* plt_reloc_offset */
717 12, /* plt_plt_offset */
718 6, /* plt_got_insn_size */
719 PLT_ENTRY_SIZE, /* plt_plt_insn_end */
720 6, /* plt_lazy_offset */
721 elf_x86_64_eh_frame_plt, /* eh_frame_plt */
722 sizeof (elf_x86_64_eh_frame_plt), /* eh_frame_plt_size */
725 static const struct elf_x86_64_backend_data elf_x86_64_bnd_arch_bed =
727 elf_x86_64_bnd_plt0_entry, /* plt0_entry */
728 elf_x86_64_bnd_plt_entry, /* plt_entry */
729 sizeof (elf_x86_64_bnd_plt_entry), /* plt_entry_size */
730 2, /* plt0_got1_offset */
731 1+8, /* plt0_got2_offset */
732 1+12, /* plt0_got2_insn_end */
733 1+2, /* plt_got_offset */
734 1, /* plt_reloc_offset */
735 7, /* plt_plt_offset */
736 1+6, /* plt_got_insn_size */
737 11, /* plt_plt_insn_end */
738 0, /* plt_lazy_offset */
739 elf_x86_64_eh_frame_plt, /* eh_frame_plt */
740 sizeof (elf_x86_64_eh_frame_plt), /* eh_frame_plt_size */
743 #define elf_backend_arch_data &elf_x86_64_arch_bed
745 /* Is a undefined weak symbol which is resolved to 0. Reference to an
746 undefined weak symbol is resolved to 0 when building executable if
748 1. Has non-GOT/non-PLT relocations in text section. Or
749 2. Has no GOT/PLT relocation.
751 #define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, EH) \
752 ((EH)->elf.root.type == bfd_link_hash_undefweak \
753 && bfd_link_executable (INFO) \
754 && (elf_x86_64_hash_table (INFO)->interp == NULL \
755 || !(EH)->has_got_reloc \
756 || (EH)->has_non_got_reloc \
757 || !(INFO)->dynamic_undefined_weak))
759 /* x86-64 ELF linker hash entry. */
761 struct elf_x86_64_link_hash_entry
763 struct elf_link_hash_entry elf;
765 /* Track dynamic relocs copied for this symbol. */
766 struct elf_dyn_relocs *dyn_relocs;
768 #define GOT_UNKNOWN 0
772 #define GOT_TLS_GDESC 4
773 #define GOT_TLS_GD_BOTH_P(type) \
774 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
775 #define GOT_TLS_GD_P(type) \
776 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
777 #define GOT_TLS_GDESC_P(type) \
778 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
779 #define GOT_TLS_GD_ANY_P(type) \
780 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
781 unsigned char tls_type;
783 /* TRUE if a weak symbol with a real definition needs a copy reloc.
784 When there is a weak symbol with a real definition, the processor
785 independent code will have arranged for us to see the real
786 definition first. We need to copy the needs_copy bit from the
787 real definition and check it when allowing copy reloc in PIE. */
788 unsigned int needs_copy : 1;
790 /* TRUE if symbol has at least one BND relocation. */
791 unsigned int has_bnd_reloc : 1;
793 /* TRUE if symbol has GOT or PLT relocations. */
794 unsigned int has_got_reloc : 1;
796 /* TRUE if symbol has non-GOT/non-PLT relocations in text sections. */
797 unsigned int has_non_got_reloc : 1;
799 /* Reference count of C/C++ function pointer relocations in read-write
800 section which can be resolved at run-time. */
801 bfd_signed_vma func_pointer_refcount;
803 /* Information about the GOT PLT entry. Filled when there are both
804 GOT and PLT relocations against the same function. */
805 union gotplt_union plt_got;
807 /* Information about the second PLT entry. Filled when has_bnd_reloc is
809 union gotplt_union plt_bnd;
811 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
812 starting at the end of the jump table. */
816 #define elf_x86_64_hash_entry(ent) \
817 ((struct elf_x86_64_link_hash_entry *)(ent))
819 struct elf_x86_64_obj_tdata
821 struct elf_obj_tdata root;
823 /* tls_type for each local got entry. */
824 char *local_got_tls_type;
826 /* GOTPLT entries for TLS descriptors. */
827 bfd_vma *local_tlsdesc_gotent;
830 #define elf_x86_64_tdata(abfd) \
831 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
833 #define elf_x86_64_local_got_tls_type(abfd) \
834 (elf_x86_64_tdata (abfd)->local_got_tls_type)
836 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
837 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
839 #define is_x86_64_elf(bfd) \
840 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
841 && elf_tdata (bfd) != NULL \
842 && elf_object_id (bfd) == X86_64_ELF_DATA)
845 elf_x86_64_mkobject (bfd *abfd)
847 return bfd_elf_allocate_object (abfd, sizeof (struct elf_x86_64_obj_tdata),
851 /* x86-64 ELF linker hash table. */
853 struct elf_x86_64_link_hash_table
855 struct elf_link_hash_table elf;
857 /* Short-cuts to get to dynamic linker sections. */
861 asection *plt_eh_frame;
867 bfd_signed_vma refcount;
871 /* The amount of space used by the jump slots in the GOT. */
872 bfd_vma sgotplt_jump_table_size;
874 /* Small local sym cache. */
875 struct sym_cache sym_cache;
877 bfd_vma (*r_info) (bfd_vma, bfd_vma);
878 bfd_vma (*r_sym) (bfd_vma);
879 unsigned int pointer_r_type;
880 const char *dynamic_interpreter;
881 int dynamic_interpreter_size;
883 /* _TLS_MODULE_BASE_ symbol. */
884 struct bfd_link_hash_entry *tls_module_base;
886 /* Used by local STT_GNU_IFUNC symbols. */
887 htab_t loc_hash_table;
888 void * loc_hash_memory;
890 /* The offset into splt of the PLT entry for the TLS descriptor
891 resolver. Special values are 0, if not necessary (or not found
892 to be necessary yet), and -1 if needed but not determined
895 /* The offset into sgot of the GOT entry used by the PLT entry
899 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
900 bfd_vma next_jump_slot_index;
901 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
902 bfd_vma next_irelative_index;
905 /* Get the x86-64 ELF linker hash table from a link_info structure. */
907 #define elf_x86_64_hash_table(p) \
908 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
909 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
911 #define elf_x86_64_compute_jump_table_size(htab) \
912 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
914 /* Create an entry in an x86-64 ELF linker hash table. */
916 static struct bfd_hash_entry *
917 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry *entry,
918 struct bfd_hash_table *table,
921 /* Allocate the structure if it has not already been allocated by a
925 entry = (struct bfd_hash_entry *)
926 bfd_hash_allocate (table,
927 sizeof (struct elf_x86_64_link_hash_entry));
932 /* Call the allocation method of the superclass. */
933 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
936 struct elf_x86_64_link_hash_entry *eh;
938 eh = (struct elf_x86_64_link_hash_entry *) entry;
939 eh->dyn_relocs = NULL;
940 eh->tls_type = GOT_UNKNOWN;
942 eh->has_bnd_reloc = 0;
943 eh->has_got_reloc = 0;
944 eh->has_non_got_reloc = 0;
945 eh->func_pointer_refcount = 0;
946 eh->plt_bnd.offset = (bfd_vma) -1;
947 eh->plt_got.offset = (bfd_vma) -1;
948 eh->tlsdesc_got = (bfd_vma) -1;
954 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
955 for local symbol so that we can handle local STT_GNU_IFUNC symbols
956 as global symbol. We reuse indx and dynstr_index for local symbol
957 hash since they aren't used by global symbols in this backend. */
960 elf_x86_64_local_htab_hash (const void *ptr)
962 struct elf_link_hash_entry *h
963 = (struct elf_link_hash_entry *) ptr;
964 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
967 /* Compare local hash entries. */
970 elf_x86_64_local_htab_eq (const void *ptr1, const void *ptr2)
972 struct elf_link_hash_entry *h1
973 = (struct elf_link_hash_entry *) ptr1;
974 struct elf_link_hash_entry *h2
975 = (struct elf_link_hash_entry *) ptr2;
977 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
980 /* Find and/or create a hash entry for local symbol. */
982 static struct elf_link_hash_entry *
983 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table *htab,
984 bfd *abfd, const Elf_Internal_Rela *rel,
987 struct elf_x86_64_link_hash_entry e, *ret;
988 asection *sec = abfd->sections;
989 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
990 htab->r_sym (rel->r_info));
993 e.elf.indx = sec->id;
994 e.elf.dynstr_index = htab->r_sym (rel->r_info);
995 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
996 create ? INSERT : NO_INSERT);
1003 ret = (struct elf_x86_64_link_hash_entry *) *slot;
1007 ret = (struct elf_x86_64_link_hash_entry *)
1008 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
1009 sizeof (struct elf_x86_64_link_hash_entry));
1012 memset (ret, 0, sizeof (*ret));
1013 ret->elf.indx = sec->id;
1014 ret->elf.dynstr_index = htab->r_sym (rel->r_info);
1015 ret->elf.dynindx = -1;
1016 ret->func_pointer_refcount = 0;
1017 ret->plt_got.offset = (bfd_vma) -1;
1023 /* Destroy an X86-64 ELF linker hash table. */
1026 elf_x86_64_link_hash_table_free (bfd *obfd)
1028 struct elf_x86_64_link_hash_table *htab
1029 = (struct elf_x86_64_link_hash_table *) obfd->link.hash;
1031 if (htab->loc_hash_table)
1032 htab_delete (htab->loc_hash_table);
1033 if (htab->loc_hash_memory)
1034 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
1035 _bfd_elf_link_hash_table_free (obfd);
1038 /* Create an X86-64 ELF linker hash table. */
1040 static struct bfd_link_hash_table *
1041 elf_x86_64_link_hash_table_create (bfd *abfd)
1043 struct elf_x86_64_link_hash_table *ret;
1044 bfd_size_type amt = sizeof (struct elf_x86_64_link_hash_table);
1046 ret = (struct elf_x86_64_link_hash_table *) bfd_zmalloc (amt);
1050 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
1051 elf_x86_64_link_hash_newfunc,
1052 sizeof (struct elf_x86_64_link_hash_entry),
1059 if (ABI_64_P (abfd))
1061 ret->r_info = elf64_r_info;
1062 ret->r_sym = elf64_r_sym;
1063 ret->pointer_r_type = R_X86_64_64;
1064 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
1065 ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
1069 ret->r_info = elf32_r_info;
1070 ret->r_sym = elf32_r_sym;
1071 ret->pointer_r_type = R_X86_64_32;
1072 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
1073 ret->dynamic_interpreter_size = sizeof ELF32_DYNAMIC_INTERPRETER;
1076 ret->loc_hash_table = htab_try_create (1024,
1077 elf_x86_64_local_htab_hash,
1078 elf_x86_64_local_htab_eq,
1080 ret->loc_hash_memory = objalloc_create ();
1081 if (!ret->loc_hash_table || !ret->loc_hash_memory)
1083 elf_x86_64_link_hash_table_free (abfd);
1086 ret->elf.root.hash_table_free = elf_x86_64_link_hash_table_free;
1088 return &ret->elf.root;
1091 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1092 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1096 elf_x86_64_create_dynamic_sections (bfd *dynobj,
1097 struct bfd_link_info *info)
1099 struct elf_x86_64_link_hash_table *htab;
1101 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1104 htab = elf_x86_64_hash_table (info);
1108 htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
1112 if (bfd_link_executable (info))
1114 /* Always allow copy relocs for building executables. */
1115 asection *s = bfd_get_linker_section (dynobj, ".rela.bss");
1118 const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
1119 s = bfd_make_section_anyway_with_flags (dynobj,
1121 (bed->dynamic_sec_flags
1124 || ! bfd_set_section_alignment (dynobj, s,
1125 bed->s->log_file_align))
1131 if (!info->no_ld_generated_unwind_info
1132 && htab->plt_eh_frame == NULL
1133 && htab->elf.splt != NULL)
1135 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
1136 | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1137 | SEC_LINKER_CREATED);
1139 = bfd_make_section_anyway_with_flags (dynobj, ".eh_frame", flags);
1140 if (htab->plt_eh_frame == NULL
1141 || !bfd_set_section_alignment (dynobj, htab->plt_eh_frame, 3))
1147 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1150 elf_x86_64_copy_indirect_symbol (struct bfd_link_info *info,
1151 struct elf_link_hash_entry *dir,
1152 struct elf_link_hash_entry *ind)
1154 struct elf_x86_64_link_hash_entry *edir, *eind;
1156 edir = (struct elf_x86_64_link_hash_entry *) dir;
1157 eind = (struct elf_x86_64_link_hash_entry *) ind;
1159 if (!edir->has_bnd_reloc)
1160 edir->has_bnd_reloc = eind->has_bnd_reloc;
1162 if (!edir->has_got_reloc)
1163 edir->has_got_reloc = eind->has_got_reloc;
1165 if (!edir->has_non_got_reloc)
1166 edir->has_non_got_reloc = eind->has_non_got_reloc;
1168 if (eind->dyn_relocs != NULL)
1170 if (edir->dyn_relocs != NULL)
1172 struct elf_dyn_relocs **pp;
1173 struct elf_dyn_relocs *p;
1175 /* Add reloc counts against the indirect sym to the direct sym
1176 list. Merge any entries against the same section. */
1177 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1179 struct elf_dyn_relocs *q;
1181 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1182 if (q->sec == p->sec)
1184 q->pc_count += p->pc_count;
1185 q->count += p->count;
1192 *pp = edir->dyn_relocs;
1195 edir->dyn_relocs = eind->dyn_relocs;
1196 eind->dyn_relocs = NULL;
1199 if (ind->root.type == bfd_link_hash_indirect
1200 && dir->got.refcount <= 0)
1202 edir->tls_type = eind->tls_type;
1203 eind->tls_type = GOT_UNKNOWN;
1206 if (ELIMINATE_COPY_RELOCS
1207 && ind->root.type != bfd_link_hash_indirect
1208 && dir->dynamic_adjusted)
1210 /* If called to transfer flags for a weakdef during processing
1211 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1212 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1213 dir->ref_dynamic |= ind->ref_dynamic;
1214 dir->ref_regular |= ind->ref_regular;
1215 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1216 dir->needs_plt |= ind->needs_plt;
1217 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1221 if (eind->func_pointer_refcount > 0)
1223 edir->func_pointer_refcount += eind->func_pointer_refcount;
1224 eind->func_pointer_refcount = 0;
1227 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1232 elf64_x86_64_elf_object_p (bfd *abfd)
1234 /* Set the right machine number for an x86-64 elf64 file. */
1235 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64);
1240 elf32_x86_64_elf_object_p (bfd *abfd)
1242 /* Set the right machine number for an x86-64 elf32 file. */
1243 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32);
1247 /* Return TRUE if the TLS access code sequence support transition
1251 elf_x86_64_check_tls_transition (bfd *abfd,
1252 struct bfd_link_info *info,
1255 Elf_Internal_Shdr *symtab_hdr,
1256 struct elf_link_hash_entry **sym_hashes,
1257 unsigned int r_type,
1258 const Elf_Internal_Rela *rel,
1259 const Elf_Internal_Rela *relend)
1262 unsigned long r_symndx;
1263 bfd_boolean largepic = FALSE;
1264 struct elf_link_hash_entry *h;
1266 struct elf_x86_64_link_hash_table *htab;
1268 /* Get the section contents. */
1269 if (contents == NULL)
1271 if (elf_section_data (sec)->this_hdr.contents != NULL)
1272 contents = elf_section_data (sec)->this_hdr.contents;
1275 /* FIXME: How to better handle error condition? */
1276 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1279 /* Cache the section contents for elf_link_input_bfd. */
1280 elf_section_data (sec)->this_hdr.contents = contents;
1284 htab = elf_x86_64_hash_table (info);
1285 offset = rel->r_offset;
1288 case R_X86_64_TLSGD:
1289 case R_X86_64_TLSLD:
1290 if ((rel + 1) >= relend)
1293 if (r_type == R_X86_64_TLSGD)
1295 /* Check transition from GD access model. For 64bit, only
1296 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1297 .word 0x6666; rex64; call __tls_get_addr
1298 can transit to different access model. For 32bit, only
1299 leaq foo@tlsgd(%rip), %rdi
1300 .word 0x6666; rex64; call __tls_get_addr
1301 can transit to different access model. For largepic
1303 leaq foo@tlsgd(%rip), %rdi
1304 movabsq $__tls_get_addr@pltoff, %rax
1308 static const unsigned char call[] = { 0x66, 0x66, 0x48, 0xe8 };
1309 static const unsigned char leaq[] = { 0x66, 0x48, 0x8d, 0x3d };
1311 if ((offset + 12) > sec->size)
1314 if (memcmp (contents + offset + 4, call, 4) != 0)
1316 if (!ABI_64_P (abfd)
1317 || (offset + 19) > sec->size
1319 || memcmp (contents + offset - 3, leaq + 1, 3) != 0
1320 || memcmp (contents + offset + 4, "\x48\xb8", 2) != 0
1321 || memcmp (contents + offset + 14, "\x48\x01\xd8\xff\xd0", 5)
1326 else if (ABI_64_P (abfd))
1329 || memcmp (contents + offset - 4, leaq, 4) != 0)
1335 || memcmp (contents + offset - 3, leaq + 1, 3) != 0)
1341 /* Check transition from LD access model. Only
1342 leaq foo@tlsld(%rip), %rdi;
1344 can transit to different access model. For largepic
1346 leaq foo@tlsld(%rip), %rdi
1347 movabsq $__tls_get_addr@pltoff, %rax
1351 static const unsigned char lea[] = { 0x48, 0x8d, 0x3d };
1353 if (offset < 3 || (offset + 9) > sec->size)
1356 if (memcmp (contents + offset - 3, lea, 3) != 0)
1359 if (0xe8 != *(contents + offset + 4))
1361 if (!ABI_64_P (abfd)
1362 || (offset + 19) > sec->size
1363 || memcmp (contents + offset + 4, "\x48\xb8", 2) != 0
1364 || memcmp (contents + offset + 14, "\x48\x01\xd8\xff\xd0", 5)
1371 r_symndx = htab->r_sym (rel[1].r_info);
1372 if (r_symndx < symtab_hdr->sh_info)
1375 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1376 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1377 may be versioned. */
1379 && h->root.root.string != NULL
1381 ? ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PLTOFF64
1382 : (ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PC32
1383 || ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PLT32))
1384 && (strncmp (h->root.root.string,
1385 "__tls_get_addr", 14) == 0));
1387 case R_X86_64_GOTTPOFF:
1388 /* Check transition from IE access model:
1389 mov foo@gottpoff(%rip), %reg
1390 add foo@gottpoff(%rip), %reg
1393 /* Check REX prefix first. */
1394 if (offset >= 3 && (offset + 4) <= sec->size)
1396 val = bfd_get_8 (abfd, contents + offset - 3);
1397 if (val != 0x48 && val != 0x4c)
1399 /* X32 may have 0x44 REX prefix or no REX prefix. */
1400 if (ABI_64_P (abfd))
1406 /* X32 may not have any REX prefix. */
1407 if (ABI_64_P (abfd))
1409 if (offset < 2 || (offset + 3) > sec->size)
1413 val = bfd_get_8 (abfd, contents + offset - 2);
1414 if (val != 0x8b && val != 0x03)
1417 val = bfd_get_8 (abfd, contents + offset - 1);
1418 return (val & 0xc7) == 5;
1420 case R_X86_64_GOTPC32_TLSDESC:
1421 /* Check transition from GDesc access model:
1422 leaq x@tlsdesc(%rip), %rax
1424 Make sure it's a leaq adding rip to a 32-bit offset
1425 into any register, although it's probably almost always
1428 if (offset < 3 || (offset + 4) > sec->size)
1431 val = bfd_get_8 (abfd, contents + offset - 3);
1432 if ((val & 0xfb) != 0x48)
1435 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1438 val = bfd_get_8 (abfd, contents + offset - 1);
1439 return (val & 0xc7) == 0x05;
1441 case R_X86_64_TLSDESC_CALL:
1442 /* Check transition from GDesc access model:
1443 call *x@tlsdesc(%rax)
1445 if (offset + 2 <= sec->size)
1447 /* Make sure that it's a call *x@tlsdesc(%rax). */
1448 static const unsigned char call[] = { 0xff, 0x10 };
1449 return memcmp (contents + offset, call, 2) == 0;
1459 /* Return TRUE if the TLS access transition is OK or no transition
1460 will be performed. Update R_TYPE if there is a transition. */
1463 elf_x86_64_tls_transition (struct bfd_link_info *info, bfd *abfd,
1464 asection *sec, bfd_byte *contents,
1465 Elf_Internal_Shdr *symtab_hdr,
1466 struct elf_link_hash_entry **sym_hashes,
1467 unsigned int *r_type, int tls_type,
1468 const Elf_Internal_Rela *rel,
1469 const Elf_Internal_Rela *relend,
1470 struct elf_link_hash_entry *h,
1471 unsigned long r_symndx)
1473 unsigned int from_type = *r_type;
1474 unsigned int to_type = from_type;
1475 bfd_boolean check = TRUE;
1477 /* Skip TLS transition for functions. */
1479 && (h->type == STT_FUNC
1480 || h->type == STT_GNU_IFUNC))
1485 case R_X86_64_TLSGD:
1486 case R_X86_64_GOTPC32_TLSDESC:
1487 case R_X86_64_TLSDESC_CALL:
1488 case R_X86_64_GOTTPOFF:
1489 if (bfd_link_executable (info))
1492 to_type = R_X86_64_TPOFF32;
1494 to_type = R_X86_64_GOTTPOFF;
1497 /* When we are called from elf_x86_64_relocate_section,
1498 CONTENTS isn't NULL and there may be additional transitions
1499 based on TLS_TYPE. */
1500 if (contents != NULL)
1502 unsigned int new_to_type = to_type;
1504 if (bfd_link_executable (info)
1507 && tls_type == GOT_TLS_IE)
1508 new_to_type = R_X86_64_TPOFF32;
1510 if (to_type == R_X86_64_TLSGD
1511 || to_type == R_X86_64_GOTPC32_TLSDESC
1512 || to_type == R_X86_64_TLSDESC_CALL)
1514 if (tls_type == GOT_TLS_IE)
1515 new_to_type = R_X86_64_GOTTPOFF;
1518 /* We checked the transition before when we were called from
1519 elf_x86_64_check_relocs. We only want to check the new
1520 transition which hasn't been checked before. */
1521 check = new_to_type != to_type && from_type == to_type;
1522 to_type = new_to_type;
1527 case R_X86_64_TLSLD:
1528 if (bfd_link_executable (info))
1529 to_type = R_X86_64_TPOFF32;
1536 /* Return TRUE if there is no transition. */
1537 if (from_type == to_type)
1540 /* Check if the transition can be performed. */
1542 && ! elf_x86_64_check_tls_transition (abfd, info, sec, contents,
1543 symtab_hdr, sym_hashes,
1544 from_type, rel, relend))
1546 reloc_howto_type *from, *to;
1549 from = elf_x86_64_rtype_to_howto (abfd, from_type);
1550 to = elf_x86_64_rtype_to_howto (abfd, to_type);
1553 name = h->root.root.string;
1556 struct elf_x86_64_link_hash_table *htab;
1558 htab = elf_x86_64_hash_table (info);
1563 Elf_Internal_Sym *isym;
1565 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1567 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1571 (*_bfd_error_handler)
1572 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1573 "in section `%A' failed"),
1574 abfd, sec, from->name, to->name, name,
1575 (unsigned long) rel->r_offset);
1576 bfd_set_error (bfd_error_bad_value);
1584 /* Rename some of the generic section flags to better document how they
1586 #define need_convert_load sec_flg0
1588 /* Look through the relocs for a section during the first phase, and
1589 calculate needed space in the global offset table, procedure
1590 linkage table, and dynamic reloc sections. */
1593 elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info,
1595 const Elf_Internal_Rela *relocs)
1597 struct elf_x86_64_link_hash_table *htab;
1598 Elf_Internal_Shdr *symtab_hdr;
1599 struct elf_link_hash_entry **sym_hashes;
1600 const Elf_Internal_Rela *rel;
1601 const Elf_Internal_Rela *rel_end;
1603 bfd_boolean use_plt_got;
1605 if (bfd_link_relocatable (info))
1608 BFD_ASSERT (is_x86_64_elf (abfd));
1610 htab = elf_x86_64_hash_table (info);
1614 use_plt_got = get_elf_x86_64_backend_data (abfd) == &elf_x86_64_arch_bed;
1616 symtab_hdr = &elf_symtab_hdr (abfd);
1617 sym_hashes = elf_sym_hashes (abfd);
1621 rel_end = relocs + sec->reloc_count;
1622 for (rel = relocs; rel < rel_end; rel++)
1624 unsigned int r_type;
1625 unsigned long r_symndx;
1626 struct elf_link_hash_entry *h;
1627 struct elf_x86_64_link_hash_entry *eh;
1628 Elf_Internal_Sym *isym;
1630 bfd_boolean size_reloc;
1632 r_symndx = htab->r_sym (rel->r_info);
1633 r_type = ELF32_R_TYPE (rel->r_info);
1635 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1637 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1642 if (r_symndx < symtab_hdr->sh_info)
1644 /* A local symbol. */
1645 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1650 /* Check relocation against local STT_GNU_IFUNC symbol. */
1651 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1653 h = elf_x86_64_get_local_sym_hash (htab, abfd, rel,
1658 /* Fake a STT_GNU_IFUNC symbol. */
1659 h->type = STT_GNU_IFUNC;
1662 h->forced_local = 1;
1663 h->root.type = bfd_link_hash_defined;
1671 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1672 while (h->root.type == bfd_link_hash_indirect
1673 || h->root.type == bfd_link_hash_warning)
1674 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1677 /* Check invalid x32 relocations. */
1678 if (!ABI_64_P (abfd))
1684 case R_X86_64_DTPOFF64:
1685 case R_X86_64_TPOFF64:
1687 case R_X86_64_GOTOFF64:
1688 case R_X86_64_GOT64:
1689 case R_X86_64_GOTPCREL64:
1690 case R_X86_64_GOTPC64:
1691 case R_X86_64_GOTPLT64:
1692 case R_X86_64_PLTOFF64:
1695 name = h->root.root.string;
1697 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1699 (*_bfd_error_handler)
1700 (_("%B: relocation %s against symbol `%s' isn't "
1701 "supported in x32 mode"), abfd,
1702 x86_64_elf_howto_table[r_type].name, name);
1703 bfd_set_error (bfd_error_bad_value);
1711 /* Create the ifunc sections for static executables. If we
1712 never see an indirect function symbol nor we are building
1713 a static executable, those sections will be empty and
1714 won't appear in output. */
1720 case R_X86_64_PC32_BND:
1721 case R_X86_64_PLT32_BND:
1723 case R_X86_64_PLT32:
1726 /* MPX PLT is supported only if elf_x86_64_arch_bed
1727 is used in 64-bit mode. */
1730 && (get_elf_x86_64_backend_data (abfd)
1731 == &elf_x86_64_arch_bed))
1733 elf_x86_64_hash_entry (h)->has_bnd_reloc = 1;
1735 /* Create the second PLT for Intel MPX support. */
1736 if (htab->plt_bnd == NULL)
1738 unsigned int plt_bnd_align;
1739 const struct elf_backend_data *bed;
1741 bed = get_elf_backend_data (info->output_bfd);
1742 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry) == 8
1743 && (sizeof (elf_x86_64_bnd_plt2_entry)
1744 == sizeof (elf_x86_64_legacy_plt2_entry)));
1747 if (htab->elf.dynobj == NULL)
1748 htab->elf.dynobj = abfd;
1750 = bfd_make_section_anyway_with_flags (htab->elf.dynobj,
1752 (bed->dynamic_sec_flags
1757 if (htab->plt_bnd == NULL
1758 || !bfd_set_section_alignment (htab->elf.dynobj,
1767 case R_X86_64_GOTPCREL:
1768 case R_X86_64_GOTPCRELX:
1769 case R_X86_64_REX_GOTPCRELX:
1770 case R_X86_64_GOTPCREL64:
1771 if (htab->elf.dynobj == NULL)
1772 htab->elf.dynobj = abfd;
1773 if (!_bfd_elf_create_ifunc_sections (htab->elf.dynobj, info))
1778 /* It is referenced by a non-shared object. */
1780 h->root.non_ir_ref = 1;
1782 if (h->type == STT_GNU_IFUNC)
1783 elf_tdata (info->output_bfd)->has_gnu_symbols
1784 |= elf_gnu_symbol_ifunc;
1787 if (! elf_x86_64_tls_transition (info, abfd, sec, NULL,
1788 symtab_hdr, sym_hashes,
1789 &r_type, GOT_UNKNOWN,
1790 rel, rel_end, h, r_symndx))
1793 eh = (struct elf_x86_64_link_hash_entry *) h;
1796 case R_X86_64_TLSLD:
1797 htab->tls_ld_got.refcount += 1;
1800 case R_X86_64_TPOFF32:
1801 if (!bfd_link_executable (info) && ABI_64_P (abfd))
1804 name = h->root.root.string;
1806 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1808 (*_bfd_error_handler)
1809 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1811 x86_64_elf_howto_table[r_type].name, name);
1812 bfd_set_error (bfd_error_bad_value);
1816 eh->has_got_reloc = 1;
1819 case R_X86_64_GOTTPOFF:
1820 if (!bfd_link_executable (info))
1821 info->flags |= DF_STATIC_TLS;
1824 case R_X86_64_GOT32:
1825 case R_X86_64_GOTPCREL:
1826 case R_X86_64_GOTPCRELX:
1827 case R_X86_64_REX_GOTPCRELX:
1828 case R_X86_64_TLSGD:
1829 case R_X86_64_GOT64:
1830 case R_X86_64_GOTPCREL64:
1831 case R_X86_64_GOTPLT64:
1832 case R_X86_64_GOTPC32_TLSDESC:
1833 case R_X86_64_TLSDESC_CALL:
1834 /* This symbol requires a global offset table entry. */
1836 int tls_type, old_tls_type;
1840 default: tls_type = GOT_NORMAL; break;
1841 case R_X86_64_TLSGD: tls_type = GOT_TLS_GD; break;
1842 case R_X86_64_GOTTPOFF: tls_type = GOT_TLS_IE; break;
1843 case R_X86_64_GOTPC32_TLSDESC:
1844 case R_X86_64_TLSDESC_CALL:
1845 tls_type = GOT_TLS_GDESC; break;
1850 h->got.refcount += 1;
1851 old_tls_type = eh->tls_type;
1855 bfd_signed_vma *local_got_refcounts;
1857 /* This is a global offset table entry for a local symbol. */
1858 local_got_refcounts = elf_local_got_refcounts (abfd);
1859 if (local_got_refcounts == NULL)
1863 size = symtab_hdr->sh_info;
1864 size *= sizeof (bfd_signed_vma)
1865 + sizeof (bfd_vma) + sizeof (char);
1866 local_got_refcounts = ((bfd_signed_vma *)
1867 bfd_zalloc (abfd, size));
1868 if (local_got_refcounts == NULL)
1870 elf_local_got_refcounts (abfd) = local_got_refcounts;
1871 elf_x86_64_local_tlsdesc_gotent (abfd)
1872 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
1873 elf_x86_64_local_got_tls_type (abfd)
1874 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
1876 local_got_refcounts[r_symndx] += 1;
1878 = elf_x86_64_local_got_tls_type (abfd) [r_symndx];
1881 /* If a TLS symbol is accessed using IE at least once,
1882 there is no point to use dynamic model for it. */
1883 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1884 && (! GOT_TLS_GD_ANY_P (old_tls_type)
1885 || tls_type != GOT_TLS_IE))
1887 if (old_tls_type == GOT_TLS_IE && GOT_TLS_GD_ANY_P (tls_type))
1888 tls_type = old_tls_type;
1889 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1890 && GOT_TLS_GD_ANY_P (tls_type))
1891 tls_type |= old_tls_type;
1895 name = h->root.root.string;
1897 name = bfd_elf_sym_name (abfd, symtab_hdr,
1899 (*_bfd_error_handler)
1900 (_("%B: '%s' accessed both as normal and thread local symbol"),
1902 bfd_set_error (bfd_error_bad_value);
1907 if (old_tls_type != tls_type)
1910 eh->tls_type = tls_type;
1912 elf_x86_64_local_got_tls_type (abfd) [r_symndx] = tls_type;
1917 case R_X86_64_GOTOFF64:
1918 case R_X86_64_GOTPC32:
1919 case R_X86_64_GOTPC64:
1922 eh->has_got_reloc = 1;
1923 if (htab->elf.sgot == NULL)
1925 if (htab->elf.dynobj == NULL)
1926 htab->elf.dynobj = abfd;
1927 if (!_bfd_elf_create_got_section (htab->elf.dynobj,
1933 case R_X86_64_PLT32:
1934 case R_X86_64_PLT32_BND:
1935 /* This symbol requires a procedure linkage table entry. We
1936 actually build the entry in adjust_dynamic_symbol,
1937 because this might be a case of linking PIC code which is
1938 never referenced by a dynamic object, in which case we
1939 don't need to generate a procedure linkage table entry
1942 /* If this is a local symbol, we resolve it directly without
1943 creating a procedure linkage table entry. */
1947 eh->has_got_reloc = 1;
1949 h->plt.refcount += 1;
1952 case R_X86_64_PLTOFF64:
1953 /* This tries to form the 'address' of a function relative
1954 to GOT. For global symbols we need a PLT entry. */
1958 h->plt.refcount += 1;
1962 case R_X86_64_SIZE32:
1963 case R_X86_64_SIZE64:
1968 if (!ABI_64_P (abfd))
1973 /* Let's help debug shared library creation. These relocs
1974 cannot be used in shared libs. Don't error out for
1975 sections we don't care about, such as debug sections or
1976 non-constant sections. */
1977 if (bfd_link_pic (info)
1978 && (sec->flags & SEC_ALLOC) != 0
1979 && (sec->flags & SEC_READONLY) != 0)
1982 name = h->root.root.string;
1984 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1985 (*_bfd_error_handler)
1986 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1987 abfd, x86_64_elf_howto_table[r_type].name, name);
1988 bfd_set_error (bfd_error_bad_value);
1996 case R_X86_64_PC32_BND:
2000 if (eh != NULL && (sec->flags & SEC_CODE) != 0)
2001 eh->has_non_got_reloc = 1;
2002 if (h != NULL && bfd_link_executable (info))
2004 /* If this reloc is in a read-only section, we might
2005 need a copy reloc. We can't check reliably at this
2006 stage whether the section is read-only, as input
2007 sections have not yet been mapped to output sections.
2008 Tentatively set the flag for now, and correct in
2009 adjust_dynamic_symbol. */
2012 /* We may need a .plt entry if the function this reloc
2013 refers to is in a shared lib. */
2014 h->plt.refcount += 1;
2015 if (r_type == R_X86_64_PC32)
2017 /* Since something like ".long foo - ." may be used
2018 as pointer, make sure that PLT is used if foo is
2019 a function defined in a shared library. */
2020 if ((sec->flags & SEC_CODE) == 0)
2021 h->pointer_equality_needed = 1;
2023 else if (r_type != R_X86_64_PC32_BND
2024 && r_type != R_X86_64_PC64)
2026 h->pointer_equality_needed = 1;
2027 /* At run-time, R_X86_64_64 can be resolved for both
2028 x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2029 can only be resolved for x32. */
2030 if ((sec->flags & SEC_READONLY) == 0
2031 && (r_type == R_X86_64_64
2032 || (!ABI_64_P (abfd)
2033 && (r_type == R_X86_64_32
2034 || r_type == R_X86_64_32S))))
2035 eh->func_pointer_refcount += 1;
2041 /* If we are creating a shared library, and this is a reloc
2042 against a global symbol, or a non PC relative reloc
2043 against a local symbol, then we need to copy the reloc
2044 into the shared library. However, if we are linking with
2045 -Bsymbolic, we do not need to copy a reloc against a
2046 global symbol which is defined in an object we are
2047 including in the link (i.e., DEF_REGULAR is set). At
2048 this point we have not seen all the input files, so it is
2049 possible that DEF_REGULAR is not set now but will be set
2050 later (it is never cleared). In case of a weak definition,
2051 DEF_REGULAR may be cleared later by a strong definition in
2052 a shared library. We account for that possibility below by
2053 storing information in the relocs_copied field of the hash
2054 table entry. A similar situation occurs when creating
2055 shared libraries and symbol visibility changes render the
2058 If on the other hand, we are creating an executable, we
2059 may need to keep relocations for symbols satisfied by a
2060 dynamic library if we manage to avoid copy relocs for the
2062 if ((bfd_link_pic (info)
2063 && (sec->flags & SEC_ALLOC) != 0
2064 && (! IS_X86_64_PCREL_TYPE (r_type)
2066 && (! SYMBOLIC_BIND (info, h)
2067 || h->root.type == bfd_link_hash_defweak
2068 || !h->def_regular))))
2069 || (ELIMINATE_COPY_RELOCS
2070 && !bfd_link_pic (info)
2071 && (sec->flags & SEC_ALLOC) != 0
2073 && (h->root.type == bfd_link_hash_defweak
2074 || !h->def_regular)))
2076 struct elf_dyn_relocs *p;
2077 struct elf_dyn_relocs **head;
2079 /* We must copy these reloc types into the output file.
2080 Create a reloc section in dynobj and make room for
2084 if (htab->elf.dynobj == NULL)
2085 htab->elf.dynobj = abfd;
2087 sreloc = _bfd_elf_make_dynamic_reloc_section
2088 (sec, htab->elf.dynobj, ABI_64_P (abfd) ? 3 : 2,
2089 abfd, /*rela?*/ TRUE);
2095 /* If this is a global symbol, we count the number of
2096 relocations we need for this symbol. */
2098 head = &eh->dyn_relocs;
2101 /* Track dynamic relocs needed for local syms too.
2102 We really need local syms available to do this
2107 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2112 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
2116 /* Beware of type punned pointers vs strict aliasing
2118 vpp = &(elf_section_data (s)->local_dynrel);
2119 head = (struct elf_dyn_relocs **)vpp;
2123 if (p == NULL || p->sec != sec)
2125 bfd_size_type amt = sizeof *p;
2127 p = ((struct elf_dyn_relocs *)
2128 bfd_alloc (htab->elf.dynobj, amt));
2139 /* Count size relocation as PC-relative relocation. */
2140 if (IS_X86_64_PCREL_TYPE (r_type) || size_reloc)
2145 /* This relocation describes the C++ object vtable hierarchy.
2146 Reconstruct it for later use during GC. */
2147 case R_X86_64_GNU_VTINHERIT:
2148 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2152 /* This relocation describes which C++ vtable entries are actually
2153 used. Record for later use during GC. */
2154 case R_X86_64_GNU_VTENTRY:
2155 BFD_ASSERT (h != NULL);
2157 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2167 && h->plt.refcount > 0
2168 && (((info->flags & DF_BIND_NOW) && !h->pointer_equality_needed)
2169 || h->got.refcount > 0)
2170 && htab->plt_got == NULL)
2172 /* Create the GOT procedure linkage table. */
2173 unsigned int plt_got_align;
2174 const struct elf_backend_data *bed;
2176 bed = get_elf_backend_data (info->output_bfd);
2177 BFD_ASSERT (sizeof (elf_x86_64_legacy_plt2_entry) == 8
2178 && (sizeof (elf_x86_64_bnd_plt2_entry)
2179 == sizeof (elf_x86_64_legacy_plt2_entry)));
2182 if (htab->elf.dynobj == NULL)
2183 htab->elf.dynobj = abfd;
2185 = bfd_make_section_anyway_with_flags (htab->elf.dynobj,
2187 (bed->dynamic_sec_flags
2192 if (htab->plt_got == NULL
2193 || !bfd_set_section_alignment (htab->elf.dynobj,
2199 if ((r_type == R_X86_64_GOTPCREL
2200 || r_type == R_X86_64_GOTPCRELX
2201 || r_type == R_X86_64_REX_GOTPCRELX)
2202 && (h == NULL || h->type != STT_GNU_IFUNC))
2203 sec->need_convert_load = 1;
2209 /* Return the section that should be marked against GC for a given
2213 elf_x86_64_gc_mark_hook (asection *sec,
2214 struct bfd_link_info *info,
2215 Elf_Internal_Rela *rel,
2216 struct elf_link_hash_entry *h,
2217 Elf_Internal_Sym *sym)
2220 switch (ELF32_R_TYPE (rel->r_info))
2222 case R_X86_64_GNU_VTINHERIT:
2223 case R_X86_64_GNU_VTENTRY:
2227 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2230 /* Update the got entry reference counts for the section being removed. */
2233 elf_x86_64_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
2235 const Elf_Internal_Rela *relocs)
2237 struct elf_x86_64_link_hash_table *htab;
2238 Elf_Internal_Shdr *symtab_hdr;
2239 struct elf_link_hash_entry **sym_hashes;
2240 bfd_signed_vma *local_got_refcounts;
2241 const Elf_Internal_Rela *rel, *relend;
2243 if (bfd_link_relocatable (info))
2246 htab = elf_x86_64_hash_table (info);
2250 elf_section_data (sec)->local_dynrel = NULL;
2252 symtab_hdr = &elf_symtab_hdr (abfd);
2253 sym_hashes = elf_sym_hashes (abfd);
2254 local_got_refcounts = elf_local_got_refcounts (abfd);
2256 htab = elf_x86_64_hash_table (info);
2257 relend = relocs + sec->reloc_count;
2258 for (rel = relocs; rel < relend; rel++)
2260 unsigned long r_symndx;
2261 unsigned int r_type;
2262 struct elf_link_hash_entry *h = NULL;
2263 bfd_boolean pointer_reloc;
2265 r_symndx = htab->r_sym (rel->r_info);
2266 if (r_symndx >= symtab_hdr->sh_info)
2268 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2269 while (h->root.type == bfd_link_hash_indirect
2270 || h->root.type == bfd_link_hash_warning)
2271 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2275 /* A local symbol. */
2276 Elf_Internal_Sym *isym;
2278 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2281 /* Check relocation against local STT_GNU_IFUNC symbol. */
2283 && ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
2285 h = elf_x86_64_get_local_sym_hash (htab, abfd, rel, FALSE);
2293 struct elf_x86_64_link_hash_entry *eh;
2294 struct elf_dyn_relocs **pp;
2295 struct elf_dyn_relocs *p;
2297 eh = (struct elf_x86_64_link_hash_entry *) h;
2299 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
2302 /* Everything must go for SEC. */
2308 r_type = ELF32_R_TYPE (rel->r_info);
2309 if (! elf_x86_64_tls_transition (info, abfd, sec, NULL,
2310 symtab_hdr, sym_hashes,
2311 &r_type, GOT_UNKNOWN,
2312 rel, relend, h, r_symndx))
2315 pointer_reloc = FALSE;
2318 case R_X86_64_TLSLD:
2319 if (htab->tls_ld_got.refcount > 0)
2320 htab->tls_ld_got.refcount -= 1;
2323 case R_X86_64_TLSGD:
2324 case R_X86_64_GOTPC32_TLSDESC:
2325 case R_X86_64_TLSDESC_CALL:
2326 case R_X86_64_GOTTPOFF:
2327 case R_X86_64_GOT32:
2328 case R_X86_64_GOTPCREL:
2329 case R_X86_64_GOTPCRELX:
2330 case R_X86_64_REX_GOTPCRELX:
2331 case R_X86_64_GOT64:
2332 case R_X86_64_GOTPCREL64:
2333 case R_X86_64_GOTPLT64:
2336 if (h->got.refcount > 0)
2337 h->got.refcount -= 1;
2338 if (h->type == STT_GNU_IFUNC)
2340 if (h->plt.refcount > 0)
2341 h->plt.refcount -= 1;
2344 else if (local_got_refcounts != NULL)
2346 if (local_got_refcounts[r_symndx] > 0)
2347 local_got_refcounts[r_symndx] -= 1;
2353 pointer_reloc = !ABI_64_P (abfd);
2357 pointer_reloc = TRUE;
2363 case R_X86_64_PC32_BND:
2365 case R_X86_64_SIZE32:
2366 case R_X86_64_SIZE64:
2368 if (bfd_link_pic (info)
2369 && (h == NULL || h->type != STT_GNU_IFUNC))
2373 case R_X86_64_PLT32:
2374 case R_X86_64_PLT32_BND:
2375 case R_X86_64_PLTOFF64:
2378 if (h->plt.refcount > 0)
2379 h->plt.refcount -= 1;
2380 if (pointer_reloc && (sec->flags & SEC_READONLY) == 0)
2382 struct elf_x86_64_link_hash_entry *eh
2383 = (struct elf_x86_64_link_hash_entry *) h;
2384 if (eh->func_pointer_refcount > 0)
2385 eh->func_pointer_refcount -= 1;
2398 /* Remove undefined weak symbol from the dynamic symbol table if it
2399 is resolved to 0. */
2402 elf_x86_64_fixup_symbol (struct bfd_link_info *info,
2403 struct elf_link_hash_entry *h)
2405 if (h->dynindx != -1
2406 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
2407 elf_x86_64_hash_entry (h)))
2410 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
2416 /* Adjust a symbol defined by a dynamic object and referenced by a
2417 regular object. The current definition is in some section of the
2418 dynamic object, but we're not including those sections. We have to
2419 change the definition to something the rest of the link can
2423 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info *info,
2424 struct elf_link_hash_entry *h)
2426 struct elf_x86_64_link_hash_table *htab;
2428 struct elf_x86_64_link_hash_entry *eh;
2429 struct elf_dyn_relocs *p;
2431 /* STT_GNU_IFUNC symbol must go through PLT. */
2432 if (h->type == STT_GNU_IFUNC)
2434 /* All local STT_GNU_IFUNC references must be treate as local
2435 calls via local PLT. */
2437 && SYMBOL_CALLS_LOCAL (info, h))
2439 bfd_size_type pc_count = 0, count = 0;
2440 struct elf_dyn_relocs **pp;
2442 eh = (struct elf_x86_64_link_hash_entry *) h;
2443 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2445 pc_count += p->pc_count;
2446 p->count -= p->pc_count;
2455 if (pc_count || count)
2459 if (h->plt.refcount <= 0)
2460 h->plt.refcount = 1;
2462 h->plt.refcount += 1;
2466 if (h->plt.refcount <= 0)
2468 h->plt.offset = (bfd_vma) -1;
2474 /* If this is a function, put it in the procedure linkage table. We
2475 will fill in the contents of the procedure linkage table later,
2476 when we know the address of the .got section. */
2477 if (h->type == STT_FUNC
2480 if (h->plt.refcount <= 0
2481 || SYMBOL_CALLS_LOCAL (info, h)
2482 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2483 && h->root.type == bfd_link_hash_undefweak))
2485 /* This case can occur if we saw a PLT32 reloc in an input
2486 file, but the symbol was never referred to by a dynamic
2487 object, or if all references were garbage collected. In
2488 such a case, we don't actually need to build a procedure
2489 linkage table, and we can just do a PC32 reloc instead. */
2490 h->plt.offset = (bfd_vma) -1;
2497 /* It's possible that we incorrectly decided a .plt reloc was
2498 needed for an R_X86_64_PC32 reloc to a non-function sym in
2499 check_relocs. We can't decide accurately between function and
2500 non-function syms in check-relocs; Objects loaded later in
2501 the link may change h->type. So fix it now. */
2502 h->plt.offset = (bfd_vma) -1;
2504 /* If this is a weak symbol, and there is a real definition, the
2505 processor independent code will have arranged for us to see the
2506 real definition first, and we can just use the same value. */
2507 if (h->u.weakdef != NULL)
2509 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2510 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2511 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2512 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2513 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
2515 eh = (struct elf_x86_64_link_hash_entry *) h;
2516 h->non_got_ref = h->u.weakdef->non_got_ref;
2517 eh->needs_copy = h->u.weakdef->needs_copy;
2522 /* This is a reference to a symbol defined by a dynamic object which
2523 is not a function. */
2525 /* If we are creating a shared library, we must presume that the
2526 only references to the symbol are via the global offset table.
2527 For such cases we need not do anything here; the relocations will
2528 be handled correctly by relocate_section. */
2529 if (!bfd_link_executable (info))
2532 /* If there are no references to this symbol that do not use the
2533 GOT, we don't need to generate a copy reloc. */
2534 if (!h->non_got_ref)
2537 /* If -z nocopyreloc was given, we won't generate them either. */
2538 if (info->nocopyreloc)
2544 if (ELIMINATE_COPY_RELOCS)
2546 eh = (struct elf_x86_64_link_hash_entry *) h;
2547 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2549 s = p->sec->output_section;
2550 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2554 /* If we didn't find any dynamic relocs in read-only sections, then
2555 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2563 /* We must allocate the symbol in our .dynbss section, which will
2564 become part of the .bss section of the executable. There will be
2565 an entry for this symbol in the .dynsym section. The dynamic
2566 object will contain position independent code, so all references
2567 from the dynamic object to this symbol will go through the global
2568 offset table. The dynamic linker will use the .dynsym entry to
2569 determine the address it must put in the global offset table, so
2570 both the dynamic object and the regular object will refer to the
2571 same memory location for the variable. */
2573 htab = elf_x86_64_hash_table (info);
2577 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2578 to copy the initial value out of the dynamic object and into the
2579 runtime process image. */
2580 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2582 const struct elf_backend_data *bed;
2583 bed = get_elf_backend_data (info->output_bfd);
2584 htab->srelbss->size += bed->s->sizeof_rela;
2590 return _bfd_elf_adjust_dynamic_copy (info, h, s);
2593 /* Allocate space in .plt, .got and associated reloc sections for
2597 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2599 struct bfd_link_info *info;
2600 struct elf_x86_64_link_hash_table *htab;
2601 struct elf_x86_64_link_hash_entry *eh;
2602 struct elf_dyn_relocs *p;
2603 const struct elf_backend_data *bed;
2604 unsigned int plt_entry_size;
2605 bfd_boolean resolved_to_zero;
2607 if (h->root.type == bfd_link_hash_indirect)
2610 eh = (struct elf_x86_64_link_hash_entry *) h;
2612 info = (struct bfd_link_info *) inf;
2613 htab = elf_x86_64_hash_table (info);
2616 bed = get_elf_backend_data (info->output_bfd);
2617 plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
2619 resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh);
2621 /* We can't use the GOT PLT if pointer equality is needed since
2622 finish_dynamic_symbol won't clear symbol value and the dynamic
2623 linker won't update the GOT slot. We will get into an infinite
2624 loop at run-time. */
2625 if (htab->plt_got != NULL
2626 && h->type != STT_GNU_IFUNC
2627 && !h->pointer_equality_needed
2628 && h->plt.refcount > 0
2629 && h->got.refcount > 0)
2631 /* Don't use the regular PLT if there are both GOT and GOTPLT
2633 h->plt.offset = (bfd_vma) -1;
2635 /* Use the GOT PLT. */
2636 eh->plt_got.refcount = 1;
2639 /* Clear the reference count of function pointer relocations if
2640 symbol isn't a normal function. */
2641 if (h->type != STT_FUNC)
2642 eh->func_pointer_refcount = 0;
2644 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2645 here if it is defined and referenced in a non-shared object. */
2646 if (h->type == STT_GNU_IFUNC
2649 if (_bfd_elf_allocate_ifunc_dyn_relocs (info, h,
2655 asection *s = htab->plt_bnd;
2656 if (h->plt.offset != (bfd_vma) -1 && s != NULL)
2658 /* Use the .plt.bnd section if it is created. */
2659 eh->plt_bnd.offset = s->size;
2661 /* Make room for this entry in the .plt.bnd section. */
2662 s->size += sizeof (elf_x86_64_legacy_plt2_entry);
2670 /* Don't create the PLT entry if there are only function pointer
2671 relocations which can be resolved at run-time. */
2672 else if (htab->elf.dynamic_sections_created
2673 && (h->plt.refcount > eh->func_pointer_refcount
2674 || eh->plt_got.refcount > 0))
2676 bfd_boolean use_plt_got;
2678 /* Clear the reference count of function pointer relocations
2680 eh->func_pointer_refcount = 0;
2682 if ((info->flags & DF_BIND_NOW) && !h->pointer_equality_needed)
2684 /* Don't use the regular PLT for DF_BIND_NOW. */
2685 h->plt.offset = (bfd_vma) -1;
2687 /* Use the GOT PLT. */
2688 h->got.refcount = 1;
2689 eh->plt_got.refcount = 1;
2692 use_plt_got = eh->plt_got.refcount > 0;
2694 /* Make sure this symbol is output as a dynamic symbol.
2695 Undefined weak syms won't yet be marked as dynamic. */
2696 if (h->dynindx == -1
2698 && !resolved_to_zero)
2700 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2704 if (bfd_link_pic (info)
2705 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2707 asection *s = htab->elf.splt;
2708 asection *bnd_s = htab->plt_bnd;
2709 asection *got_s = htab->plt_got;
2711 /* If this is the first .plt entry, make room for the special
2712 first entry. The .plt section is used by prelink to undo
2713 prelinking for dynamic relocations. */
2715 s->size = plt_entry_size;
2718 eh->plt_got.offset = got_s->size;
2721 h->plt.offset = s->size;
2723 eh->plt_bnd.offset = bnd_s->size;
2726 /* If this symbol is not defined in a regular file, and we are
2727 not generating a shared library, then set the symbol to this
2728 location in the .plt. This is required to make function
2729 pointers compare as equal between the normal executable and
2730 the shared library. */
2731 if (! bfd_link_pic (info)
2736 /* We need to make a call to the entry of the GOT PLT
2737 instead of regular PLT entry. */
2738 h->root.u.def.section = got_s;
2739 h->root.u.def.value = eh->plt_got.offset;
2745 /* We need to make a call to the entry of the second
2746 PLT instead of regular PLT entry. */
2747 h->root.u.def.section = bnd_s;
2748 h->root.u.def.value = eh->plt_bnd.offset;
2752 h->root.u.def.section = s;
2753 h->root.u.def.value = h->plt.offset;
2758 /* Make room for this entry. */
2760 got_s->size += sizeof (elf_x86_64_legacy_plt2_entry);
2763 s->size += plt_entry_size;
2765 bnd_s->size += sizeof (elf_x86_64_legacy_plt2_entry);
2767 /* We also need to make an entry in the .got.plt section,
2768 which will be placed in the .got section by the linker
2770 htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
2772 /* There should be no PLT relocation against resolved
2773 undefined weak symbol in executable. */
2774 if (!resolved_to_zero)
2776 /* We also need to make an entry in the .rela.plt
2778 htab->elf.srelplt->size += bed->s->sizeof_rela;
2779 htab->elf.srelplt->reloc_count++;
2785 eh->plt_got.offset = (bfd_vma) -1;
2786 h->plt.offset = (bfd_vma) -1;
2792 eh->plt_got.offset = (bfd_vma) -1;
2793 h->plt.offset = (bfd_vma) -1;
2797 eh->tlsdesc_got = (bfd_vma) -1;
2799 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2800 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2801 if (h->got.refcount > 0
2802 && bfd_link_executable (info)
2804 && elf_x86_64_hash_entry (h)->tls_type == GOT_TLS_IE)
2806 h->got.offset = (bfd_vma) -1;
2808 else if (h->got.refcount > 0)
2812 int tls_type = elf_x86_64_hash_entry (h)->tls_type;
2814 /* Make sure this symbol is output as a dynamic symbol.
2815 Undefined weak syms won't yet be marked as dynamic. */
2816 if (h->dynindx == -1
2818 && !resolved_to_zero)
2820 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2824 if (GOT_TLS_GDESC_P (tls_type))
2826 eh->tlsdesc_got = htab->elf.sgotplt->size
2827 - elf_x86_64_compute_jump_table_size (htab);
2828 htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
2829 h->got.offset = (bfd_vma) -2;
2831 if (! GOT_TLS_GDESC_P (tls_type)
2832 || GOT_TLS_GD_P (tls_type))
2835 h->got.offset = s->size;
2836 s->size += GOT_ENTRY_SIZE;
2837 if (GOT_TLS_GD_P (tls_type))
2838 s->size += GOT_ENTRY_SIZE;
2840 dyn = htab->elf.dynamic_sections_created;
2841 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2842 and two if global. R_X86_64_GOTTPOFF needs one dynamic
2843 relocation. No dynamic relocation against resolved undefined
2844 weak symbol in executable. */
2845 if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
2846 || tls_type == GOT_TLS_IE)
2847 htab->elf.srelgot->size += bed->s->sizeof_rela;
2848 else if (GOT_TLS_GD_P (tls_type))
2849 htab->elf.srelgot->size += 2 * bed->s->sizeof_rela;
2850 else if (! GOT_TLS_GDESC_P (tls_type)
2851 && ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2852 && !resolved_to_zero)
2853 || h->root.type != bfd_link_hash_undefweak)
2854 && (bfd_link_pic (info)
2855 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
2856 htab->elf.srelgot->size += bed->s->sizeof_rela;
2857 if (GOT_TLS_GDESC_P (tls_type))
2859 htab->elf.srelplt->size += bed->s->sizeof_rela;
2860 htab->tlsdesc_plt = (bfd_vma) -1;
2864 h->got.offset = (bfd_vma) -1;
2866 if (eh->dyn_relocs == NULL)
2869 /* In the shared -Bsymbolic case, discard space allocated for
2870 dynamic pc-relative relocs against symbols which turn out to be
2871 defined in regular objects. For the normal shared case, discard
2872 space for pc-relative relocs that have become local due to symbol
2873 visibility changes. */
2875 if (bfd_link_pic (info))
2877 /* Relocs that use pc_count are those that appear on a call
2878 insn, or certain REL relocs that can generated via assembly.
2879 We want calls to protected symbols to resolve directly to the
2880 function rather than going via the plt. If people want
2881 function pointer comparisons to work as expected then they
2882 should avoid writing weird assembly. */
2883 if (SYMBOL_CALLS_LOCAL (info, h))
2885 struct elf_dyn_relocs **pp;
2887 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2889 p->count -= p->pc_count;
2898 /* Also discard relocs on undefined weak syms with non-default
2899 visibility or in PIE. */
2900 if (eh->dyn_relocs != NULL)
2902 if (h->root.type == bfd_link_hash_undefweak)
2904 /* Undefined weak symbol is never bound locally in shared
2906 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2907 || resolved_to_zero)
2908 eh->dyn_relocs = NULL;
2909 else if (h->dynindx == -1
2910 && ! h->forced_local
2911 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2914 /* For PIE, discard space for pc-relative relocs against
2915 symbols which turn out to need copy relocs. */
2916 else if (bfd_link_executable (info)
2917 && (h->needs_copy || eh->needs_copy)
2921 struct elf_dyn_relocs **pp;
2923 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2925 if (p->pc_count != 0)
2933 else if (ELIMINATE_COPY_RELOCS)
2935 /* For the non-shared case, discard space for relocs against
2936 symbols which turn out to need copy relocs or are not
2937 dynamic. Keep dynamic relocations for run-time function
2938 pointer initialization. */
2940 if ((!h->non_got_ref
2941 || eh->func_pointer_refcount > 0
2942 || (h->root.type == bfd_link_hash_undefweak
2943 && !resolved_to_zero))
2946 || (htab->elf.dynamic_sections_created
2947 && (h->root.type == bfd_link_hash_undefweak
2948 || h->root.type == bfd_link_hash_undefined))))
2950 /* Make sure this symbol is output as a dynamic symbol.
2951 Undefined weak syms won't yet be marked as dynamic. */
2952 if (h->dynindx == -1
2953 && ! h->forced_local
2954 && ! resolved_to_zero
2955 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2958 /* If that succeeded, we know we'll be keeping all the
2960 if (h->dynindx != -1)
2964 eh->dyn_relocs = NULL;
2965 eh->func_pointer_refcount = 0;
2970 /* Finally, allocate space. */
2971 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2975 sreloc = elf_section_data (p->sec)->sreloc;
2977 BFD_ASSERT (sreloc != NULL);
2979 sreloc->size += p->count * bed->s->sizeof_rela;
2985 /* Allocate space in .plt, .got and associated reloc sections for
2986 local dynamic relocs. */
2989 elf_x86_64_allocate_local_dynrelocs (void **slot, void *inf)
2991 struct elf_link_hash_entry *h
2992 = (struct elf_link_hash_entry *) *slot;
2994 if (h->type != STT_GNU_IFUNC
2998 || h->root.type != bfd_link_hash_defined)
3001 return elf_x86_64_allocate_dynrelocs (h, inf);
3004 /* Find any dynamic relocs that apply to read-only sections. */
3007 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry *h,
3010 struct elf_x86_64_link_hash_entry *eh;
3011 struct elf_dyn_relocs *p;
3013 /* Skip local IFUNC symbols. */
3014 if (h->forced_local && h->type == STT_GNU_IFUNC)
3017 eh = (struct elf_x86_64_link_hash_entry *) h;
3018 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3020 asection *s = p->sec->output_section;
3022 if (s != NULL && (s->flags & SEC_READONLY) != 0)
3024 struct bfd_link_info *info = (struct bfd_link_info *) inf;
3026 info->flags |= DF_TEXTREL;
3028 if ((info->warn_shared_textrel && bfd_link_pic (info))
3029 || info->error_textrel)
3030 info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
3031 p->sec->owner, h->root.root.string,
3034 /* Not an error, just cut short the traversal. */
3041 /* With the local symbol, foo, we convert
3042 mov foo@GOTPCREL(%rip), %reg
3046 call/jmp *foo@GOTPCREL(%rip)
3048 nop call foo/jmp foo nop
3049 When PIC is false, convert
3050 test %reg, foo@GOTPCREL(%rip)
3054 binop foo@GOTPCREL(%rip), %reg
3057 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
3061 elf_x86_64_convert_load (bfd *abfd, asection *sec,
3062 struct bfd_link_info *link_info)
3064 Elf_Internal_Shdr *symtab_hdr;
3065 Elf_Internal_Rela *internal_relocs;
3066 Elf_Internal_Rela *irel, *irelend;
3068 struct elf_x86_64_link_hash_table *htab;
3069 bfd_boolean changed_contents;
3070 bfd_boolean changed_relocs;
3071 bfd_signed_vma *local_got_refcounts;
3072 bfd_vma maxpagesize;
3074 bfd_boolean require_reloc_pc32;
3076 /* Don't even try to convert non-ELF outputs. */
3077 if (!is_elf_hash_table (link_info->hash))
3080 /* Nothing to do if there is no need or no output. */
3081 if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
3082 || sec->need_convert_load == 0
3083 || bfd_is_abs_section (sec->output_section))
3086 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3088 /* Load the relocations for this section. */
3089 internal_relocs = (_bfd_elf_link_read_relocs
3090 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
3091 link_info->keep_memory));
3092 if (internal_relocs == NULL)
3095 htab = elf_x86_64_hash_table (link_info);
3096 changed_contents = FALSE;
3097 changed_relocs = FALSE;
3098 local_got_refcounts = elf_local_got_refcounts (abfd);
3099 maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
3101 /* Get the section contents. */
3102 if (elf_section_data (sec)->this_hdr.contents != NULL)
3103 contents = elf_section_data (sec)->this_hdr.contents;
3106 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
3110 is_pic = bfd_link_pic (link_info);
3112 /* TRUE if we can convert only to R_X86_64_PC32. Enable it for
3115 = link_info->disable_target_specific_optimizations > 1;
3117 irelend = internal_relocs + sec->reloc_count;
3118 for (irel = internal_relocs; irel < irelend; irel++)
3120 unsigned int r_type = ELF32_R_TYPE (irel->r_info);
3121 unsigned int r_symndx = htab->r_sym (irel->r_info);
3123 struct elf_link_hash_entry *h;
3127 bfd_signed_vma raddend;
3128 unsigned int opcode;
3131 bfd_boolean to_reloc_pc32;
3133 relocx = (r_type == R_X86_64_GOTPCRELX
3134 || r_type == R_X86_64_REX_GOTPCRELX);
3135 if (!relocx && r_type != R_X86_64_GOTPCREL)
3138 roff = irel->r_offset;
3139 if (roff < (r_type == R_X86_64_REX_GOTPCRELX ? 3 : 2))
3142 raddend = irel->r_addend;
3143 /* Addend for 32-bit PC-relative relocation must be -4. */
3147 opcode = bfd_get_8 (abfd, contents + roff - 2);
3149 /* Convert mov to lea since it has been done for a while. */
3152 /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
3153 for call, jmp or one of adc, add, and, cmp, or, sbb, sub,
3154 test, xor instructions. */
3159 /* We convert only to R_X86_64_PC32:
3161 2. R_X86_64_GOTPCREL since we can't modify REX byte.
3162 3. require_reloc_pc32 is true.
3165 to_reloc_pc32 = (opcode == 0xff
3167 || require_reloc_pc32
3170 /* Get the symbol referred to by the reloc. */
3171 if (r_symndx < symtab_hdr->sh_info)
3173 Elf_Internal_Sym *isym;
3175 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
3178 symtype = ELF_ST_TYPE (isym->st_info);
3180 /* STT_GNU_IFUNC must keep GOTPCREL relocations and skip
3181 relocation against undefined symbols. */
3182 if (symtype == STT_GNU_IFUNC || isym->st_shndx == SHN_UNDEF)
3185 if (isym->st_shndx == SHN_ABS)
3186 tsec = bfd_abs_section_ptr;
3187 else if (isym->st_shndx == SHN_COMMON)
3188 tsec = bfd_com_section_ptr;
3189 else if (isym->st_shndx == SHN_X86_64_LCOMMON)
3190 tsec = &_bfd_elf_large_com_section;
3192 tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3195 toff = isym->st_value;
3199 indx = r_symndx - symtab_hdr->sh_info;
3200 h = elf_sym_hashes (abfd)[indx];
3201 BFD_ASSERT (h != NULL);
3203 while (h->root.type == bfd_link_hash_indirect
3204 || h->root.type == bfd_link_hash_warning)
3205 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3207 /* STT_GNU_IFUNC must keep GOTPCREL relocations. We also
3208 avoid optimizing GOTPCREL relocations againt _DYNAMIC
3209 since ld.so may use its link-time address. */
3210 if (h->type == STT_GNU_IFUNC)
3213 /* Undefined weak symbol is only bound locally in executable
3214 and its reference is resolved as 0 without relocation
3215 overflow. We can only perform this optimization for
3216 GOTPCRELX relocations since we need to modify REX byte.
3217 It is OK convert mov with R_X86_64_GOTPCREL to
3219 if ((relocx || opcode == 0x8b)
3220 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info,
3221 elf_x86_64_hash_entry (h)))
3225 /* Skip for branch instructions since R_X86_64_PC32
3227 if (require_reloc_pc32)
3232 /* For non-branch instructions, we can convert to
3233 R_X86_64_32/R_X86_64_32S since we know if there
3235 to_reloc_pc32 = FALSE;
3238 /* Since we don't know the current PC when PIC is true,
3239 we can't convert to R_X86_64_PC32. */
3240 if (to_reloc_pc32 && is_pic)
3245 else if ((h->def_regular
3246 || h->root.type == bfd_link_hash_defined
3247 || h->root.type == bfd_link_hash_defweak)
3248 && h != htab->elf.hdynamic
3249 && SYMBOL_REFERENCES_LOCAL (link_info, h))
3251 /* bfd_link_hash_new or bfd_link_hash_undefined is
3252 set by an assignment in a linker script in
3253 bfd_elf_record_link_assignment. */
3255 && (h->root.type == bfd_link_hash_new
3256 || h->root.type == bfd_link_hash_undefined))
3258 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */
3259 if (require_reloc_pc32)
3263 tsec = h->root.u.def.section;
3264 toff = h->root.u.def.value;
3271 /* We can only estimate relocation overflow for R_X86_64_PC32. */
3275 if (tsec->sec_info_type == SEC_INFO_TYPE_MERGE)
3277 /* At this stage in linking, no SEC_MERGE symbol has been
3278 adjusted, so all references to such symbols need to be
3279 passed through _bfd_merged_section_offset. (Later, in
3280 relocate_section, all SEC_MERGE symbols *except* for
3281 section symbols have been adjusted.)
3283 gas may reduce relocations against symbols in SEC_MERGE
3284 sections to a relocation against the section symbol when
3285 the original addend was zero. When the reloc is against
3286 a section symbol we should include the addend in the
3287 offset passed to _bfd_merged_section_offset, since the
3288 location of interest is the original symbol. On the
3289 other hand, an access to "sym+addend" where "sym" is not
3290 a section symbol should not include the addend; Such an
3291 access is presumed to be an offset from "sym"; The
3292 location of interest is just "sym". */
3293 if (symtype == STT_SECTION)
3296 toff = _bfd_merged_section_offset (abfd, &tsec,
3297 elf_section_data (tsec)->sec_info,
3300 if (symtype != STT_SECTION)
3306 /* Don't convert if R_X86_64_PC32 relocation overflows. */
3307 if (tsec->output_section == sec->output_section)
3309 if ((toff - roff + 0x80000000) > 0xffffffff)
3314 bfd_signed_vma distance;
3316 /* At this point, we don't know the load addresses of TSEC
3317 section nor SEC section. We estimate the distrance between
3318 SEC and TSEC. We store the estimated distances in the
3319 compressed_size field of the output section, which is only
3320 used to decompress the compressed input section. */
3321 if (sec->output_section->compressed_size == 0)
3324 bfd_size_type size = 0;
3325 for (asect = link_info->output_bfd->sections;
3327 asect = asect->next)
3330 for (i = asect->map_head.s;
3334 size = align_power (size, i->alignment_power);
3337 asect->compressed_size = size;
3341 /* Don't convert GOTPCREL relocations if TSEC isn't placed
3343 distance = (tsec->output_section->compressed_size
3344 - sec->output_section->compressed_size);
3348 /* Take PT_GNU_RELRO segment into account by adding
3350 if ((toff + distance + maxpagesize - roff + 0x80000000)
3358 /* We have "call/jmp *foo@GOTPCREL(%rip)". */
3363 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
3365 modrm = bfd_get_8 (abfd, contents + roff - 1);
3368 /* Convert to "jmp foo nop". */
3371 nop_offset = irel->r_offset + 3;
3372 disp = bfd_get_32 (abfd, contents + irel->r_offset);
3373 irel->r_offset -= 1;
3374 bfd_put_32 (abfd, disp, contents + irel->r_offset);
3378 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
3381 nop = link_info->call_nop_byte;
3382 if (link_info->call_nop_as_suffix)
3384 nop_offset = irel->r_offset + 3;
3385 disp = bfd_get_32 (abfd, contents + irel->r_offset);
3386 irel->r_offset -= 1;
3387 bfd_put_32 (abfd, disp, contents + irel->r_offset);
3390 nop_offset = irel->r_offset - 2;
3392 bfd_put_8 (abfd, nop, contents + nop_offset);
3393 bfd_put_8 (abfd, modrm, contents + irel->r_offset - 1);
3394 r_type = R_X86_64_PC32;
3399 unsigned int rex_mask = REX_R;
3401 if (r_type == R_X86_64_REX_GOTPCRELX)
3402 rex = bfd_get_8 (abfd, contents + roff - 3);
3410 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
3411 "lea foo(%rip), %reg". */
3413 r_type = R_X86_64_PC32;
3417 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
3418 "mov $foo, %reg". */
3420 modrm = bfd_get_8 (abfd, contents + roff - 1);
3421 modrm = 0xc0 | (modrm & 0x38) >> 3;
3422 if ((rex & REX_W) != 0
3423 && ABI_64_P (link_info->output_bfd))
3425 /* Keep the REX_W bit in REX byte for LP64. */
3426 r_type = R_X86_64_32S;
3427 goto rewrite_modrm_rex;
3431 /* If the REX_W bit in REX byte isn't needed,
3432 use R_X86_64_32 and clear the W bit to avoid
3433 sign-extend imm32 to imm64. */
3434 r_type = R_X86_64_32;
3435 /* Clear the W bit in REX byte. */
3437 goto rewrite_modrm_rex;
3443 /* R_X86_64_PC32 isn't supported. */
3447 modrm = bfd_get_8 (abfd, contents + roff - 1);
3450 /* Convert "test %reg, foo@GOTPCREL(%rip)" to
3451 "test $foo, %reg". */
3452 modrm = 0xc0 | (modrm & 0x38) >> 3;
3457 /* Convert "binop foo@GOTPCREL(%rip), %reg" to
3458 "binop $foo, %reg". */
3459 modrm = 0xc0 | (modrm & 0x38) >> 3 | (opcode & 0x3c);
3463 /* Use R_X86_64_32 with 32-bit operand to avoid relocation
3464 overflow when sign-extending imm32 to imm64. */
3465 r_type = (rex & REX_W) != 0 ? R_X86_64_32S : R_X86_64_32;
3468 bfd_put_8 (abfd, modrm, contents + roff - 1);
3472 /* Move the R bit to the B bit in REX byte. */
3473 rex = (rex & ~rex_mask) | (rex & REX_R) >> 2;
3474 bfd_put_8 (abfd, rex, contents + roff - 3);
3477 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */
3481 bfd_put_8 (abfd, opcode, contents + roff - 2);
3484 irel->r_info = htab->r_info (r_symndx, r_type);
3485 changed_contents = TRUE;
3486 changed_relocs = TRUE;
3490 if (h->got.refcount > 0)
3491 h->got.refcount -= 1;
3495 if (local_got_refcounts != NULL
3496 && local_got_refcounts[r_symndx] > 0)
3497 local_got_refcounts[r_symndx] -= 1;
3501 if (contents != NULL
3502 && elf_section_data (sec)->this_hdr.contents != contents)
3504 if (!changed_contents && !link_info->keep_memory)
3508 /* Cache the section contents for elf_link_input_bfd. */
3509 elf_section_data (sec)->this_hdr.contents = contents;
3513 if (elf_section_data (sec)->relocs != internal_relocs)
3515 if (!changed_relocs)
3516 free (internal_relocs);
3518 elf_section_data (sec)->relocs = internal_relocs;
3524 if (contents != NULL
3525 && elf_section_data (sec)->this_hdr.contents != contents)
3527 if (internal_relocs != NULL
3528 && elf_section_data (sec)->relocs != internal_relocs)
3529 free (internal_relocs);
3533 /* Set the sizes of the dynamic sections. */
3536 elf_x86_64_size_dynamic_sections (bfd *output_bfd,
3537 struct bfd_link_info *info)
3539 struct elf_x86_64_link_hash_table *htab;
3544 const struct elf_backend_data *bed;
3546 htab = elf_x86_64_hash_table (info);
3549 bed = get_elf_backend_data (output_bfd);
3551 dynobj = htab->elf.dynobj;
3555 if (htab->elf.dynamic_sections_created)
3557 /* Set the contents of the .interp section to the interpreter. */
3558 if (bfd_link_executable (info) && !info->nointerp)
3560 s = bfd_get_linker_section (dynobj, ".interp");
3563 s->size = htab->dynamic_interpreter_size;
3564 s->contents = (unsigned char *) htab->dynamic_interpreter;
3569 /* Set up .got offsets for local syms, and space for local dynamic
3571 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3573 bfd_signed_vma *local_got;
3574 bfd_signed_vma *end_local_got;
3575 char *local_tls_type;
3576 bfd_vma *local_tlsdesc_gotent;
3577 bfd_size_type locsymcount;
3578 Elf_Internal_Shdr *symtab_hdr;
3581 if (! is_x86_64_elf (ibfd))
3584 for (s = ibfd->sections; s != NULL; s = s->next)
3586 struct elf_dyn_relocs *p;
3588 if (!elf_x86_64_convert_load (ibfd, s, info))
3591 for (p = (struct elf_dyn_relocs *)
3592 (elf_section_data (s)->local_dynrel);
3596 if (!bfd_is_abs_section (p->sec)
3597 && bfd_is_abs_section (p->sec->output_section))
3599 /* Input section has been discarded, either because
3600 it is a copy of a linkonce section or due to
3601 linker script /DISCARD/, so we'll be discarding
3604 else if (p->count != 0)
3606 srel = elf_section_data (p->sec)->sreloc;
3607 srel->size += p->count * bed->s->sizeof_rela;
3608 if ((p->sec->output_section->flags & SEC_READONLY) != 0
3609 && (info->flags & DF_TEXTREL) == 0)
3611 info->flags |= DF_TEXTREL;
3612 if ((info->warn_shared_textrel && bfd_link_pic (info))
3613 || info->error_textrel)
3614 info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3615 p->sec->owner, p->sec);
3621 local_got = elf_local_got_refcounts (ibfd);
3625 symtab_hdr = &elf_symtab_hdr (ibfd);
3626 locsymcount = symtab_hdr->sh_info;
3627 end_local_got = local_got + locsymcount;
3628 local_tls_type = elf_x86_64_local_got_tls_type (ibfd);
3629 local_tlsdesc_gotent = elf_x86_64_local_tlsdesc_gotent (ibfd);
3631 srel = htab->elf.srelgot;
3632 for (; local_got < end_local_got;
3633 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
3635 *local_tlsdesc_gotent = (bfd_vma) -1;
3638 if (GOT_TLS_GDESC_P (*local_tls_type))
3640 *local_tlsdesc_gotent = htab->elf.sgotplt->size
3641 - elf_x86_64_compute_jump_table_size (htab);
3642 htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
3643 *local_got = (bfd_vma) -2;
3645 if (! GOT_TLS_GDESC_P (*local_tls_type)
3646 || GOT_TLS_GD_P (*local_tls_type))
3648 *local_got = s->size;
3649 s->size += GOT_ENTRY_SIZE;
3650 if (GOT_TLS_GD_P (*local_tls_type))
3651 s->size += GOT_ENTRY_SIZE;
3653 if (bfd_link_pic (info)
3654 || GOT_TLS_GD_ANY_P (*local_tls_type)
3655 || *local_tls_type == GOT_TLS_IE)
3657 if (GOT_TLS_GDESC_P (*local_tls_type))
3659 htab->elf.srelplt->size
3660 += bed->s->sizeof_rela;
3661 htab->tlsdesc_plt = (bfd_vma) -1;
3663 if (! GOT_TLS_GDESC_P (*local_tls_type)
3664 || GOT_TLS_GD_P (*local_tls_type))
3665 srel->size += bed->s->sizeof_rela;
3669 *local_got = (bfd_vma) -1;
3673 if (htab->tls_ld_got.refcount > 0)
3675 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3677 htab->tls_ld_got.offset = htab->elf.sgot->size;
3678 htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
3679 htab->elf.srelgot->size += bed->s->sizeof_rela;
3682 htab->tls_ld_got.offset = -1;
3684 /* Allocate global sym .plt and .got entries, and space for global
3685 sym dynamic relocs. */
3686 elf_link_hash_traverse (&htab->elf, elf_x86_64_allocate_dynrelocs,
3689 /* Allocate .plt and .got entries, and space for local symbols. */
3690 htab_traverse (htab->loc_hash_table,
3691 elf_x86_64_allocate_local_dynrelocs,
3694 /* For every jump slot reserved in the sgotplt, reloc_count is
3695 incremented. However, when we reserve space for TLS descriptors,
3696 it's not incremented, so in order to compute the space reserved
3697 for them, it suffices to multiply the reloc count by the jump
3700 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3701 so that R_X86_64_IRELATIVE entries come last. */
3702 if (htab->elf.srelplt)
3704 htab->sgotplt_jump_table_size
3705 = elf_x86_64_compute_jump_table_size (htab);
3706 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
3708 else if (htab->elf.irelplt)
3709 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
3711 if (htab->tlsdesc_plt)
3713 /* If we're not using lazy TLS relocations, don't generate the
3714 PLT and GOT entries they require. */
3715 if ((info->flags & DF_BIND_NOW))
3716 htab->tlsdesc_plt = 0;
3719 htab->tlsdesc_got = htab->elf.sgot->size;
3720 htab->elf.sgot->size += GOT_ENTRY_SIZE;
3721 /* Reserve room for the initial entry.
3722 FIXME: we could probably do away with it in this case. */
3723 if (htab->elf.splt->size == 0)
3724 htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd);
3725 htab->tlsdesc_plt = htab->elf.splt->size;
3726 htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd);
3730 if (htab->elf.sgotplt)
3732 /* Don't allocate .got.plt section if there are no GOT nor PLT
3733 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3734 if ((htab->elf.hgot == NULL
3735 || !htab->elf.hgot->ref_regular_nonweak)
3736 && (htab->elf.sgotplt->size
3737 == get_elf_backend_data (output_bfd)->got_header_size)
3738 && (htab->elf.splt == NULL
3739 || htab->elf.splt->size == 0)
3740 && (htab->elf.sgot == NULL
3741 || htab->elf.sgot->size == 0)
3742 && (htab->elf.iplt == NULL
3743 || htab->elf.iplt->size == 0)
3744 && (htab->elf.igotplt == NULL
3745 || htab->elf.igotplt->size == 0))
3746 htab->elf.sgotplt->size = 0;
3749 if (htab->plt_eh_frame != NULL
3750 && htab->elf.splt != NULL
3751 && htab->elf.splt->size != 0
3752 && !bfd_is_abs_section (htab->elf.splt->output_section)
3753 && _bfd_elf_eh_frame_present (info))
3755 const struct elf_x86_64_backend_data *arch_data
3756 = get_elf_x86_64_arch_data (bed);
3757 htab->plt_eh_frame->size = arch_data->eh_frame_plt_size;
3760 /* We now have determined the sizes of the various dynamic sections.
3761 Allocate memory for them. */
3763 for (s = dynobj->sections; s != NULL; s = s->next)
3765 if ((s->flags & SEC_LINKER_CREATED) == 0)
3768 if (s == htab->elf.splt
3769 || s == htab->elf.sgot
3770 || s == htab->elf.sgotplt
3771 || s == htab->elf.iplt
3772 || s == htab->elf.igotplt
3773 || s == htab->plt_bnd
3774 || s == htab->plt_got
3775 || s == htab->plt_eh_frame
3776 || s == htab->sdynbss)
3778 /* Strip this section if we don't need it; see the
3781 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
3783 if (s->size != 0 && s != htab->elf.srelplt)
3786 /* We use the reloc_count field as a counter if we need
3787 to copy relocs into the output file. */
3788 if (s != htab->elf.srelplt)
3793 /* It's not one of our sections, so don't allocate space. */
3799 /* If we don't need this section, strip it from the
3800 output file. This is mostly to handle .rela.bss and
3801 .rela.plt. We must create both sections in
3802 create_dynamic_sections, because they must be created
3803 before the linker maps input sections to output
3804 sections. The linker does that before
3805 adjust_dynamic_symbol is called, and it is that
3806 function which decides whether anything needs to go
3807 into these sections. */
3809 s->flags |= SEC_EXCLUDE;
3813 if ((s->flags & SEC_HAS_CONTENTS) == 0)
3816 /* Allocate memory for the section contents. We use bfd_zalloc
3817 here in case unused entries are not reclaimed before the
3818 section's contents are written out. This should not happen,
3819 but this way if it does, we get a R_X86_64_NONE reloc instead
3821 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3822 if (s->contents == NULL)
3826 if (htab->plt_eh_frame != NULL
3827 && htab->plt_eh_frame->contents != NULL)
3829 const struct elf_x86_64_backend_data *arch_data
3830 = get_elf_x86_64_arch_data (bed);
3832 memcpy (htab->plt_eh_frame->contents,
3833 arch_data->eh_frame_plt, htab->plt_eh_frame->size);
3834 bfd_put_32 (dynobj, htab->elf.splt->size,
3835 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
3838 if (htab->elf.dynamic_sections_created)
3840 /* Add some entries to the .dynamic section. We fill in the
3841 values later, in elf_x86_64_finish_dynamic_sections, but we
3842 must add the entries now so that we get the correct size for
3843 the .dynamic section. The DT_DEBUG entry is filled in by the
3844 dynamic linker and used by the debugger. */
3845 #define add_dynamic_entry(TAG, VAL) \
3846 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3848 if (bfd_link_executable (info))
3850 if (!add_dynamic_entry (DT_DEBUG, 0))
3854 if (htab->elf.splt->size != 0)
3856 /* DT_PLTGOT is used by prelink even if there is no PLT
3858 if (!add_dynamic_entry (DT_PLTGOT, 0))
3861 if (htab->elf.srelplt->size != 0)
3863 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3864 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3865 || !add_dynamic_entry (DT_JMPREL, 0))
3869 if (htab->tlsdesc_plt
3870 && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
3871 || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
3877 if (!add_dynamic_entry (DT_RELA, 0)
3878 || !add_dynamic_entry (DT_RELASZ, 0)
3879 || !add_dynamic_entry (DT_RELAENT, bed->s->sizeof_rela))
3882 /* If any dynamic relocs apply to a read-only section,
3883 then we need a DT_TEXTREL entry. */
3884 if ((info->flags & DF_TEXTREL) == 0)
3885 elf_link_hash_traverse (&htab->elf,
3886 elf_x86_64_readonly_dynrelocs,
3889 if ((info->flags & DF_TEXTREL) != 0)
3891 if ((elf_tdata (output_bfd)->has_gnu_symbols
3892 & elf_gnu_symbol_ifunc) == elf_gnu_symbol_ifunc)
3894 info->callbacks->einfo
3895 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3896 bfd_set_error (bfd_error_bad_value);
3900 if (!add_dynamic_entry (DT_TEXTREL, 0))
3905 #undef add_dynamic_entry
3911 elf_x86_64_always_size_sections (bfd *output_bfd,
3912 struct bfd_link_info *info)
3914 asection *tls_sec = elf_hash_table (info)->tls_sec;
3918 struct elf_link_hash_entry *tlsbase;
3920 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
3921 "_TLS_MODULE_BASE_",
3922 FALSE, FALSE, FALSE);
3924 if (tlsbase && tlsbase->type == STT_TLS)
3926 struct elf_x86_64_link_hash_table *htab;
3927 struct bfd_link_hash_entry *bh = NULL;
3928 const struct elf_backend_data *bed
3929 = get_elf_backend_data (output_bfd);
3931 htab = elf_x86_64_hash_table (info);
3935 if (!(_bfd_generic_link_add_one_symbol
3936 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
3937 tls_sec, 0, NULL, FALSE,
3938 bed->collect, &bh)))
3941 htab->tls_module_base = bh;
3943 tlsbase = (struct elf_link_hash_entry *)bh;
3944 tlsbase->def_regular = 1;
3945 tlsbase->other = STV_HIDDEN;
3946 tlsbase->root.linker_def = 1;
3947 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
3954 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3955 executables. Rather than setting it to the beginning of the TLS
3956 section, we have to set it to the end. This function may be called
3957 multiple times, it is idempotent. */
3960 elf_x86_64_set_tls_module_base (struct bfd_link_info *info)
3962 struct elf_x86_64_link_hash_table *htab;
3963 struct bfd_link_hash_entry *base;
3965 if (!bfd_link_executable (info))
3968 htab = elf_x86_64_hash_table (info);
3972 base = htab->tls_module_base;
3976 base->u.def.value = htab->elf.tls_size;
3979 /* Return the base VMA address which should be subtracted from real addresses
3980 when resolving @dtpoff relocation.
3981 This is PT_TLS segment p_vaddr. */
3984 elf_x86_64_dtpoff_base (struct bfd_link_info *info)
3986 /* If tls_sec is NULL, we should have signalled an error already. */
3987 if (elf_hash_table (info)->tls_sec == NULL)
3989 return elf_hash_table (info)->tls_sec->vma;
3992 /* Return the relocation value for @tpoff relocation
3993 if STT_TLS virtual address is ADDRESS. */
3996 elf_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address)
3998 struct elf_link_hash_table *htab = elf_hash_table (info);
3999 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
4000 bfd_vma static_tls_size;
4002 /* If tls_segment is NULL, we should have signalled an error already. */
4003 if (htab->tls_sec == NULL)
4006 /* Consider special static TLS alignment requirements. */
4007 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
4008 return address - static_tls_size - htab->tls_sec->vma;
4011 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
4015 is_32bit_relative_branch (bfd_byte *contents, bfd_vma offset)
4017 /* Opcode Instruction
4020 0x0f 0x8x conditional jump */
4022 && (contents [offset - 1] == 0xe8
4023 || contents [offset - 1] == 0xe9))
4025 && contents [offset - 2] == 0x0f
4026 && (contents [offset - 1] & 0xf0) == 0x80));
4030 elf_x86_64_need_pic (bfd *input_bfd, struct elf_link_hash_entry *h,
4031 reloc_howto_type *howto)
4035 const char *pic = "";
4037 switch (ELF_ST_VISIBILITY (h->other))
4040 v = _("hidden symbol");
4043 v = _("internal symbol");
4046 v = _("protected symbol");
4050 pic = _("; recompile with -fPIC");
4055 fmt = _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
4057 fmt = _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
4059 (*_bfd_error_handler) (fmt, input_bfd, howto->name,
4060 v, h->root.root.string, pic);
4061 bfd_set_error (bfd_error_bad_value);
4065 /* Relocate an x86_64 ELF section. */
4068 elf_x86_64_relocate_section (bfd *output_bfd,
4069 struct bfd_link_info *info,
4071 asection *input_section,
4073 Elf_Internal_Rela *relocs,
4074 Elf_Internal_Sym *local_syms,
4075 asection **local_sections)
4077 struct elf_x86_64_link_hash_table *htab;
4078 Elf_Internal_Shdr *symtab_hdr;
4079 struct elf_link_hash_entry **sym_hashes;
4080 bfd_vma *local_got_offsets;
4081 bfd_vma *local_tlsdesc_gotents;
4082 Elf_Internal_Rela *rel;
4083 Elf_Internal_Rela *wrel;
4084 Elf_Internal_Rela *relend;
4085 const unsigned int plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
4087 BFD_ASSERT (is_x86_64_elf (input_bfd));
4089 htab = elf_x86_64_hash_table (info);
4092 symtab_hdr = &elf_symtab_hdr (input_bfd);
4093 sym_hashes = elf_sym_hashes (input_bfd);
4094 local_got_offsets = elf_local_got_offsets (input_bfd);
4095 local_tlsdesc_gotents = elf_x86_64_local_tlsdesc_gotent (input_bfd);
4097 elf_x86_64_set_tls_module_base (info);
4099 rel = wrel = relocs;
4100 relend = relocs + input_section->reloc_count;
4101 for (; rel < relend; wrel++, rel++)
4103 unsigned int r_type;
4104 reloc_howto_type *howto;
4105 unsigned long r_symndx;
4106 struct elf_link_hash_entry *h;
4107 struct elf_x86_64_link_hash_entry *eh;
4108 Elf_Internal_Sym *sym;
4110 bfd_vma off, offplt, plt_offset;
4112 bfd_boolean unresolved_reloc;
4113 bfd_reloc_status_type r;
4115 asection *base_got, *resolved_plt;
4117 bfd_boolean resolved_to_zero;
4119 r_type = ELF32_R_TYPE (rel->r_info);
4120 if (r_type == (int) R_X86_64_GNU_VTINHERIT
4121 || r_type == (int) R_X86_64_GNU_VTENTRY)
4128 if (r_type >= (int) R_X86_64_standard)
4130 (*_bfd_error_handler)
4131 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
4132 input_bfd, input_section, r_type);
4133 bfd_set_error (bfd_error_bad_value);
4137 if (r_type != (int) R_X86_64_32
4138 || ABI_64_P (output_bfd))
4139 howto = x86_64_elf_howto_table + r_type;
4141 howto = (x86_64_elf_howto_table
4142 + ARRAY_SIZE (x86_64_elf_howto_table) - 1);
4143 r_symndx = htab->r_sym (rel->r_info);
4147 unresolved_reloc = FALSE;
4148 if (r_symndx < symtab_hdr->sh_info)
4150 sym = local_syms + r_symndx;
4151 sec = local_sections[r_symndx];
4153 relocation = _bfd_elf_rela_local_sym (output_bfd, sym,
4155 st_size = sym->st_size;
4157 /* Relocate against local STT_GNU_IFUNC symbol. */
4158 if (!bfd_link_relocatable (info)
4159 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
4161 h = elf_x86_64_get_local_sym_hash (htab, input_bfd,
4166 /* Set STT_GNU_IFUNC symbol value. */
4167 h->root.u.def.value = sym->st_value;
4168 h->root.u.def.section = sec;
4173 bfd_boolean warned ATTRIBUTE_UNUSED;
4174 bfd_boolean ignored ATTRIBUTE_UNUSED;
4176 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4177 r_symndx, symtab_hdr, sym_hashes,
4179 unresolved_reloc, warned, ignored);
4183 if (sec != NULL && discarded_section (sec))
4185 _bfd_clear_contents (howto, input_bfd, input_section,
4186 contents + rel->r_offset);
4187 wrel->r_offset = rel->r_offset;
4191 /* For ld -r, remove relocations in debug sections against
4192 sections defined in discarded sections. Not done for
4193 eh_frame editing code expects to be present. */
4194 if (bfd_link_relocatable (info)
4195 && (input_section->flags & SEC_DEBUGGING))
4201 if (bfd_link_relocatable (info))
4208 if (rel->r_addend == 0 && !ABI_64_P (output_bfd))
4210 if (r_type == R_X86_64_64)
4212 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
4213 zero-extend it to 64bit if addend is zero. */
4214 r_type = R_X86_64_32;
4215 memset (contents + rel->r_offset + 4, 0, 4);
4217 else if (r_type == R_X86_64_SIZE64)
4219 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
4220 zero-extend it to 64bit if addend is zero. */
4221 r_type = R_X86_64_SIZE32;
4222 memset (contents + rel->r_offset + 4, 0, 4);
4226 eh = (struct elf_x86_64_link_hash_entry *) h;
4228 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
4229 it here if it is defined in a non-shared object. */
4231 && h->type == STT_GNU_IFUNC
4237 if ((input_section->flags & SEC_ALLOC) == 0)
4239 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4240 sections because such sections are not SEC_ALLOC and
4241 thus ld.so will not process them. */
4242 if ((input_section->flags & SEC_DEBUGGING) != 0)
4246 else if (h->plt.offset == (bfd_vma) -1)
4249 /* STT_GNU_IFUNC symbol must go through PLT. */
4250 if (htab->elf.splt != NULL)
4252 if (htab->plt_bnd != NULL)
4254 resolved_plt = htab->plt_bnd;
4255 plt_offset = eh->plt_bnd.offset;
4259 resolved_plt = htab->elf.splt;
4260 plt_offset = h->plt.offset;
4265 resolved_plt = htab->elf.iplt;
4266 plt_offset = h->plt.offset;
4269 relocation = (resolved_plt->output_section->vma
4270 + resolved_plt->output_offset + plt_offset);
4275 if (h->root.root.string)
4276 name = h->root.root.string;
4278 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
4280 (*_bfd_error_handler)
4281 (_("%B: relocation %s against STT_GNU_IFUNC "
4282 "symbol `%s' isn't handled by %s"), input_bfd,
4283 howto->name, name, __FUNCTION__);
4284 bfd_set_error (bfd_error_bad_value);
4288 if (bfd_link_pic (info))
4293 if (ABI_64_P (output_bfd))
4297 if (rel->r_addend != 0)
4299 if (h->root.root.string)
4300 name = h->root.root.string;
4302 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
4304 (*_bfd_error_handler)
4305 (_("%B: relocation %s against STT_GNU_IFUNC "
4306 "symbol `%s' has non-zero addend: %d"),
4307 input_bfd, howto->name, name, rel->r_addend);
4308 bfd_set_error (bfd_error_bad_value);
4312 /* Generate dynamic relcoation only when there is a
4313 non-GOT reference in a shared object. */
4314 if (bfd_link_pic (info) && h->non_got_ref)
4316 Elf_Internal_Rela outrel;
4319 /* Need a dynamic relocation to get the real function
4321 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
4325 if (outrel.r_offset == (bfd_vma) -1
4326 || outrel.r_offset == (bfd_vma) -2)
4329 outrel.r_offset += (input_section->output_section->vma
4330 + input_section->output_offset);
4332 if (h->dynindx == -1
4334 || bfd_link_executable (info))
4336 /* This symbol is resolved locally. */
4337 outrel.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
4338 outrel.r_addend = (h->root.u.def.value
4339 + h->root.u.def.section->output_section->vma
4340 + h->root.u.def.section->output_offset);
4344 outrel.r_info = htab->r_info (h->dynindx, r_type);
4345 outrel.r_addend = 0;
4348 sreloc = htab->elf.irelifunc;
4349 elf_append_rela (output_bfd, sreloc, &outrel);
4351 /* If this reloc is against an external symbol, we
4352 do not want to fiddle with the addend. Otherwise,
4353 we need to include the symbol value so that it
4354 becomes an addend for the dynamic reloc. For an
4355 internal symbol, we have updated addend. */
4360 case R_X86_64_PC32_BND:
4362 case R_X86_64_PLT32:
4363 case R_X86_64_PLT32_BND:
4366 case R_X86_64_GOTPCREL:
4367 case R_X86_64_GOTPCRELX:
4368 case R_X86_64_REX_GOTPCRELX:
4369 case R_X86_64_GOTPCREL64:
4370 base_got = htab->elf.sgot;
4371 off = h->got.offset;
4373 if (base_got == NULL)
4376 if (off == (bfd_vma) -1)
4378 /* We can't use h->got.offset here to save state, or
4379 even just remember the offset, as finish_dynamic_symbol
4380 would use that as offset into .got. */
4382 if (htab->elf.splt != NULL)
4384 plt_index = h->plt.offset / plt_entry_size - 1;
4385 off = (plt_index + 3) * GOT_ENTRY_SIZE;
4386 base_got = htab->elf.sgotplt;
4390 plt_index = h->plt.offset / plt_entry_size;
4391 off = plt_index * GOT_ENTRY_SIZE;
4392 base_got = htab->elf.igotplt;
4395 if (h->dynindx == -1
4399 /* This references the local defitionion. We must
4400 initialize this entry in the global offset table.
4401 Since the offset must always be a multiple of 8,
4402 we use the least significant bit to record
4403 whether we have initialized it already.
4405 When doing a dynamic link, we create a .rela.got
4406 relocation entry to initialize the value. This
4407 is done in the finish_dynamic_symbol routine. */
4412 bfd_put_64 (output_bfd, relocation,
4413 base_got->contents + off);
4414 /* Note that this is harmless for the GOTPLT64
4415 case, as -1 | 1 still is -1. */
4421 relocation = (base_got->output_section->vma
4422 + base_got->output_offset + off);
4428 resolved_to_zero = (eh != NULL
4429 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh));
4431 /* When generating a shared object, the relocations handled here are
4432 copied into the output file to be resolved at run time. */
4435 case R_X86_64_GOT32:
4436 case R_X86_64_GOT64:
4437 /* Relocation is to the entry for this symbol in the global
4439 case R_X86_64_GOTPCREL:
4440 case R_X86_64_GOTPCRELX:
4441 case R_X86_64_REX_GOTPCRELX:
4442 case R_X86_64_GOTPCREL64:
4443 /* Use global offset table entry as symbol value. */
4444 case R_X86_64_GOTPLT64:
4445 /* This is obsolete and treated the the same as GOT64. */
4446 base_got = htab->elf.sgot;
4448 if (htab->elf.sgot == NULL)
4455 off = h->got.offset;
4457 && h->plt.offset != (bfd_vma)-1
4458 && off == (bfd_vma)-1)
4460 /* We can't use h->got.offset here to save
4461 state, or even just remember the offset, as
4462 finish_dynamic_symbol would use that as offset into
4464 bfd_vma plt_index = h->plt.offset / plt_entry_size - 1;
4465 off = (plt_index + 3) * GOT_ENTRY_SIZE;
4466 base_got = htab->elf.sgotplt;
4469 dyn = htab->elf.dynamic_sections_created;
4471 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
4472 || (bfd_link_pic (info)
4473 && SYMBOL_REFERENCES_LOCAL (info, h))
4474 || (ELF_ST_VISIBILITY (h->other)
4475 && h->root.type == bfd_link_hash_undefweak))
4477 /* This is actually a static link, or it is a -Bsymbolic
4478 link and the symbol is defined locally, or the symbol
4479 was forced to be local because of a version file. We
4480 must initialize this entry in the global offset table.
4481 Since the offset must always be a multiple of 8, we
4482 use the least significant bit to record whether we
4483 have initialized it already.
4485 When doing a dynamic link, we create a .rela.got
4486 relocation entry to initialize the value. This is
4487 done in the finish_dynamic_symbol routine. */
4492 bfd_put_64 (output_bfd, relocation,
4493 base_got->contents + off);
4494 /* Note that this is harmless for the GOTPLT64 case,
4495 as -1 | 1 still is -1. */
4500 unresolved_reloc = FALSE;
4504 if (local_got_offsets == NULL)
4507 off = local_got_offsets[r_symndx];
4509 /* The offset must always be a multiple of 8. We use
4510 the least significant bit to record whether we have
4511 already generated the necessary reloc. */
4516 bfd_put_64 (output_bfd, relocation,
4517 base_got->contents + off);
4519 if (bfd_link_pic (info))
4522 Elf_Internal_Rela outrel;
4524 /* We need to generate a R_X86_64_RELATIVE reloc
4525 for the dynamic linker. */
4526 s = htab->elf.srelgot;
4530 outrel.r_offset = (base_got->output_section->vma
4531 + base_got->output_offset
4533 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
4534 outrel.r_addend = relocation;
4535 elf_append_rela (output_bfd, s, &outrel);
4538 local_got_offsets[r_symndx] |= 1;
4542 if (off >= (bfd_vma) -2)
4545 relocation = base_got->output_section->vma
4546 + base_got->output_offset + off;
4547 if (r_type != R_X86_64_GOTPCREL
4548 && r_type != R_X86_64_GOTPCRELX
4549 && r_type != R_X86_64_REX_GOTPCRELX
4550 && r_type != R_X86_64_GOTPCREL64)
4551 relocation -= htab->elf.sgotplt->output_section->vma
4552 - htab->elf.sgotplt->output_offset;
4556 case R_X86_64_GOTOFF64:
4557 /* Relocation is relative to the start of the global offset
4560 /* Check to make sure it isn't a protected function or data
4561 symbol for shared library since it may not be local when
4562 used as function address or with copy relocation. We also
4563 need to make sure that a symbol is referenced locally. */
4564 if (bfd_link_pic (info) && h)
4566 if (!h->def_regular)
4570 switch (ELF_ST_VISIBILITY (h->other))
4573 v = _("hidden symbol");
4576 v = _("internal symbol");
4579 v = _("protected symbol");
4586 (*_bfd_error_handler)
4587 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s `%s' can not be used when making a shared object"),
4588 input_bfd, v, h->root.root.string);
4589 bfd_set_error (bfd_error_bad_value);
4592 else if (!bfd_link_executable (info)
4593 && !SYMBOL_REFERENCES_LOCAL (info, h)
4594 && (h->type == STT_FUNC
4595 || h->type == STT_OBJECT)
4596 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
4598 (*_bfd_error_handler)
4599 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s `%s' can not be used when making a shared object"),
4601 h->type == STT_FUNC ? "function" : "data",
4602 h->root.root.string);
4603 bfd_set_error (bfd_error_bad_value);
4608 /* Note that sgot is not involved in this
4609 calculation. We always want the start of .got.plt. If we
4610 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4611 permitted by the ABI, we might have to change this
4613 relocation -= htab->elf.sgotplt->output_section->vma
4614 + htab->elf.sgotplt->output_offset;
4617 case R_X86_64_GOTPC32:
4618 case R_X86_64_GOTPC64:
4619 /* Use global offset table as symbol value. */
4620 relocation = htab->elf.sgotplt->output_section->vma
4621 + htab->elf.sgotplt->output_offset;
4622 unresolved_reloc = FALSE;
4625 case R_X86_64_PLTOFF64:
4626 /* Relocation is PLT entry relative to GOT. For local
4627 symbols it's the symbol itself relative to GOT. */
4629 /* See PLT32 handling. */
4630 && h->plt.offset != (bfd_vma) -1
4631 && htab->elf.splt != NULL)
4633 if (htab->plt_bnd != NULL)
4635 resolved_plt = htab->plt_bnd;
4636 plt_offset = eh->plt_bnd.offset;
4640 resolved_plt = htab->elf.splt;
4641 plt_offset = h->plt.offset;
4644 relocation = (resolved_plt->output_section->vma
4645 + resolved_plt->output_offset
4647 unresolved_reloc = FALSE;
4650 relocation -= htab->elf.sgotplt->output_section->vma
4651 + htab->elf.sgotplt->output_offset;
4654 case R_X86_64_PLT32:
4655 case R_X86_64_PLT32_BND:
4656 /* Relocation is to the entry for this symbol in the
4657 procedure linkage table. */
4659 /* Resolve a PLT32 reloc against a local symbol directly,
4660 without using the procedure linkage table. */
4664 if ((h->plt.offset == (bfd_vma) -1
4665 && eh->plt_got.offset == (bfd_vma) -1)
4666 || htab->elf.splt == NULL)
4668 /* We didn't make a PLT entry for this symbol. This
4669 happens when statically linking PIC code, or when
4670 using -Bsymbolic. */
4674 if (h->plt.offset != (bfd_vma) -1)
4676 if (htab->plt_bnd != NULL)
4678 resolved_plt = htab->plt_bnd;
4679 plt_offset = eh->plt_bnd.offset;
4683 resolved_plt = htab->elf.splt;
4684 plt_offset = h->plt.offset;
4689 /* Use the GOT PLT. */
4690 resolved_plt = htab->plt_got;
4691 plt_offset = eh->plt_got.offset;
4694 relocation = (resolved_plt->output_section->vma
4695 + resolved_plt->output_offset
4697 unresolved_reloc = FALSE;
4700 case R_X86_64_SIZE32:
4701 case R_X86_64_SIZE64:
4702 /* Set to symbol size. */
4703 relocation = st_size;
4709 case R_X86_64_PC32_BND:
4710 /* Don't complain about -fPIC if the symbol is undefined when
4711 building executable unless it is unresolved weak symbol. */
4712 if ((input_section->flags & SEC_ALLOC) != 0
4713 && (input_section->flags & SEC_READONLY) != 0
4715 && ((bfd_link_executable (info)
4716 && h->root.type == bfd_link_hash_undefweak
4717 && !resolved_to_zero)
4718 || (bfd_link_pic (info)
4719 && !(bfd_link_pie (info)
4720 && h->root.type == bfd_link_hash_undefined))))
4722 bfd_boolean fail = FALSE;
4724 = ((r_type == R_X86_64_PC32
4725 || r_type == R_X86_64_PC32_BND)
4726 && is_32bit_relative_branch (contents, rel->r_offset));
4728 if (SYMBOL_REFERENCES_LOCAL (info, h))
4730 /* Symbol is referenced locally. Make sure it is
4731 defined locally or for a branch. */
4732 fail = !h->def_regular && !branch;
4734 else if (!(bfd_link_pie (info)
4735 && (h->needs_copy || eh->needs_copy)))
4737 /* Symbol doesn't need copy reloc and isn't referenced
4738 locally. We only allow branch to symbol with
4739 non-default visibility. */
4741 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT);
4745 return elf_x86_64_need_pic (input_bfd, h, howto);
4754 /* FIXME: The ABI says the linker should make sure the value is
4755 the same when it's zeroextended to 64 bit. */
4758 if ((input_section->flags & SEC_ALLOC) == 0)
4761 /* Don't copy a pc-relative relocation into the output file
4762 if the symbol needs copy reloc or the symbol is undefined
4763 when building executable. Copy dynamic function pointer
4764 relocations. Don't generate dynamic relocations against
4765 resolved undefined weak symbols in PIE. */
4766 if ((bfd_link_pic (info)
4767 && !(bfd_link_pie (info)
4771 || h->root.type == bfd_link_hash_undefined)
4772 && IS_X86_64_PCREL_TYPE (r_type))
4774 || ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4775 && !resolved_to_zero)
4776 || h->root.type != bfd_link_hash_undefweak))
4777 && ((! IS_X86_64_PCREL_TYPE (r_type)
4778 && r_type != R_X86_64_SIZE32
4779 && r_type != R_X86_64_SIZE64)
4780 || ! SYMBOL_CALLS_LOCAL (info, h)))
4781 || (ELIMINATE_COPY_RELOCS
4782 && !bfd_link_pic (info)
4786 || eh->func_pointer_refcount > 0
4787 || (h->root.type == bfd_link_hash_undefweak
4788 && !resolved_to_zero))
4789 && ((h->def_dynamic && !h->def_regular)
4790 /* Undefined weak symbol is bound locally when
4792 || h->root.type == bfd_link_hash_undefined)))
4794 Elf_Internal_Rela outrel;
4795 bfd_boolean skip, relocate;
4798 /* When generating a shared object, these relocations
4799 are copied into the output file to be resolved at run
4805 _bfd_elf_section_offset (output_bfd, info, input_section,
4807 if (outrel.r_offset == (bfd_vma) -1)
4809 else if (outrel.r_offset == (bfd_vma) -2)
4810 skip = TRUE, relocate = TRUE;
4812 outrel.r_offset += (input_section->output_section->vma
4813 + input_section->output_offset);
4816 memset (&outrel, 0, sizeof outrel);
4818 /* h->dynindx may be -1 if this symbol was marked to
4822 && (IS_X86_64_PCREL_TYPE (r_type)
4823 || ! bfd_link_pic (info)
4824 || ! SYMBOLIC_BIND (info, h)
4825 || ! h->def_regular))
4827 if ((r_type != R_X86_64_PC64 && r_type != R_X86_64_64)
4828 && bfd_link_executable (info)
4829 && h->root.type == bfd_link_hash_undefweak
4830 && !resolved_to_zero)
4831 return elf_x86_64_need_pic (input_bfd, h, howto);
4832 outrel.r_info = htab->r_info (h->dynindx, r_type);
4833 outrel.r_addend = rel->r_addend;
4837 /* This symbol is local, or marked to become local. */
4838 if (r_type == htab->pointer_r_type)
4841 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
4842 outrel.r_addend = relocation + rel->r_addend;
4844 else if (r_type == R_X86_64_64
4845 && !ABI_64_P (output_bfd))
4848 outrel.r_info = htab->r_info (0,
4849 R_X86_64_RELATIVE64);
4850 outrel.r_addend = relocation + rel->r_addend;
4851 /* Check addend overflow. */
4852 if ((outrel.r_addend & 0x80000000)
4853 != (rel->r_addend & 0x80000000))
4856 int addend = rel->r_addend;
4857 if (h && h->root.root.string)
4858 name = h->root.root.string;
4860 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
4863 (*_bfd_error_handler)
4864 (_("%B: addend -0x%x in relocation %s against "
4865 "symbol `%s' at 0x%lx in section `%A' is "
4867 input_bfd, input_section, addend,
4869 (unsigned long) rel->r_offset);
4871 (*_bfd_error_handler)
4872 (_("%B: addend 0x%x in relocation %s against "
4873 "symbol `%s' at 0x%lx in section `%A' is "
4875 input_bfd, input_section, addend,
4877 (unsigned long) rel->r_offset);
4878 bfd_set_error (bfd_error_bad_value);
4886 if (bfd_is_abs_section (sec))
4888 else if (sec == NULL || sec->owner == NULL)
4890 bfd_set_error (bfd_error_bad_value);
4897 /* We are turning this relocation into one
4898 against a section symbol. It would be
4899 proper to subtract the symbol's value,
4900 osec->vma, from the emitted reloc addend,
4901 but ld.so expects buggy relocs. */
4902 osec = sec->output_section;
4903 sindx = elf_section_data (osec)->dynindx;
4906 asection *oi = htab->elf.text_index_section;
4907 sindx = elf_section_data (oi)->dynindx;
4909 BFD_ASSERT (sindx != 0);
4912 outrel.r_info = htab->r_info (sindx, r_type);
4913 outrel.r_addend = relocation + rel->r_addend;
4917 sreloc = elf_section_data (input_section)->sreloc;
4919 if (sreloc == NULL || sreloc->contents == NULL)
4921 r = bfd_reloc_notsupported;
4922 goto check_relocation_error;
4925 elf_append_rela (output_bfd, sreloc, &outrel);
4927 /* If this reloc is against an external symbol, we do
4928 not want to fiddle with the addend. Otherwise, we
4929 need to include the symbol value so that it becomes
4930 an addend for the dynamic reloc. */
4937 case R_X86_64_TLSGD:
4938 case R_X86_64_GOTPC32_TLSDESC:
4939 case R_X86_64_TLSDESC_CALL:
4940 case R_X86_64_GOTTPOFF:
4941 tls_type = GOT_UNKNOWN;
4942 if (h == NULL && local_got_offsets)
4943 tls_type = elf_x86_64_local_got_tls_type (input_bfd) [r_symndx];
4945 tls_type = elf_x86_64_hash_entry (h)->tls_type;
4947 if (! elf_x86_64_tls_transition (info, input_bfd,
4948 input_section, contents,
4949 symtab_hdr, sym_hashes,
4950 &r_type, tls_type, rel,
4951 relend, h, r_symndx))
4954 if (r_type == R_X86_64_TPOFF32)
4956 bfd_vma roff = rel->r_offset;
4958 BFD_ASSERT (! unresolved_reloc);
4960 if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
4962 /* GD->LE transition. For 64bit, change
4963 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4964 .word 0x6666; rex64; call __tls_get_addr
4967 leaq foo@tpoff(%rax), %rax
4969 leaq foo@tlsgd(%rip), %rdi
4970 .word 0x6666; rex64; call __tls_get_addr
4973 leaq foo@tpoff(%rax), %rax
4974 For largepic, change:
4975 leaq foo@tlsgd(%rip), %rdi
4976 movabsq $__tls_get_addr@pltoff, %rax
4981 leaq foo@tpoff(%rax), %rax
4982 nopw 0x0(%rax,%rax,1) */
4984 if (ABI_64_P (output_bfd)
4985 && contents[roff + 5] == (bfd_byte) '\xb8')
4987 memcpy (contents + roff - 3,
4988 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
4989 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4992 else if (ABI_64_P (output_bfd))
4993 memcpy (contents + roff - 4,
4994 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4997 memcpy (contents + roff - 3,
4998 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5000 bfd_put_32 (output_bfd,
5001 elf_x86_64_tpoff (info, relocation),
5002 contents + roff + 8 + largepic);
5003 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5008 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
5010 /* GDesc -> LE transition.
5011 It's originally something like:
5012 leaq x@tlsdesc(%rip), %rax
5015 movl $x@tpoff, %rax. */
5017 unsigned int val, type;
5019 type = bfd_get_8 (input_bfd, contents + roff - 3);
5020 val = bfd_get_8 (input_bfd, contents + roff - 1);
5021 bfd_put_8 (output_bfd, 0x48 | ((type >> 2) & 1),
5022 contents + roff - 3);
5023 bfd_put_8 (output_bfd, 0xc7, contents + roff - 2);
5024 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
5025 contents + roff - 1);
5026 bfd_put_32 (output_bfd,
5027 elf_x86_64_tpoff (info, relocation),
5031 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
5033 /* GDesc -> LE transition.
5038 bfd_put_8 (output_bfd, 0x66, contents + roff);
5039 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
5042 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTTPOFF)
5044 /* IE->LE transition:
5045 For 64bit, originally it can be one of:
5046 movq foo@gottpoff(%rip), %reg
5047 addq foo@gottpoff(%rip), %reg
5050 leaq foo(%reg), %reg
5052 For 32bit, originally it can be one of:
5053 movq foo@gottpoff(%rip), %reg
5054 addl foo@gottpoff(%rip), %reg
5057 leal foo(%reg), %reg
5060 unsigned int val, type, reg;
5063 val = bfd_get_8 (input_bfd, contents + roff - 3);
5066 type = bfd_get_8 (input_bfd, contents + roff - 2);
5067 reg = bfd_get_8 (input_bfd, contents + roff - 1);
5073 bfd_put_8 (output_bfd, 0x49,
5074 contents + roff - 3);
5075 else if (!ABI_64_P (output_bfd) && val == 0x44)
5076 bfd_put_8 (output_bfd, 0x41,
5077 contents + roff - 3);
5078 bfd_put_8 (output_bfd, 0xc7,
5079 contents + roff - 2);
5080 bfd_put_8 (output_bfd, 0xc0 | reg,
5081 contents + roff - 1);
5085 /* addq/addl -> addq/addl - addressing with %rsp/%r12
5088 bfd_put_8 (output_bfd, 0x49,
5089 contents + roff - 3);
5090 else if (!ABI_64_P (output_bfd) && val == 0x44)
5091 bfd_put_8 (output_bfd, 0x41,
5092 contents + roff - 3);
5093 bfd_put_8 (output_bfd, 0x81,
5094 contents + roff - 2);
5095 bfd_put_8 (output_bfd, 0xc0 | reg,
5096 contents + roff - 1);
5100 /* addq/addl -> leaq/leal */
5102 bfd_put_8 (output_bfd, 0x4d,
5103 contents + roff - 3);
5104 else if (!ABI_64_P (output_bfd) && val == 0x44)
5105 bfd_put_8 (output_bfd, 0x45,
5106 contents + roff - 3);
5107 bfd_put_8 (output_bfd, 0x8d,
5108 contents + roff - 2);
5109 bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
5110 contents + roff - 1);
5112 bfd_put_32 (output_bfd,
5113 elf_x86_64_tpoff (info, relocation),
5121 if (htab->elf.sgot == NULL)
5126 off = h->got.offset;
5127 offplt = elf_x86_64_hash_entry (h)->tlsdesc_got;
5131 if (local_got_offsets == NULL)
5134 off = local_got_offsets[r_symndx];
5135 offplt = local_tlsdesc_gotents[r_symndx];
5142 Elf_Internal_Rela outrel;
5146 if (htab->elf.srelgot == NULL)
5149 indx = h && h->dynindx != -1 ? h->dynindx : 0;
5151 if (GOT_TLS_GDESC_P (tls_type))
5153 outrel.r_info = htab->r_info (indx, R_X86_64_TLSDESC);
5154 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt
5155 + 2 * GOT_ENTRY_SIZE <= htab->elf.sgotplt->size);
5156 outrel.r_offset = (htab->elf.sgotplt->output_section->vma
5157 + htab->elf.sgotplt->output_offset
5159 + htab->sgotplt_jump_table_size);
5160 sreloc = htab->elf.srelplt;
5162 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
5164 outrel.r_addend = 0;
5165 elf_append_rela (output_bfd, sreloc, &outrel);
5168 sreloc = htab->elf.srelgot;
5170 outrel.r_offset = (htab->elf.sgot->output_section->vma
5171 + htab->elf.sgot->output_offset + off);
5173 if (GOT_TLS_GD_P (tls_type))
5174 dr_type = R_X86_64_DTPMOD64;
5175 else if (GOT_TLS_GDESC_P (tls_type))
5178 dr_type = R_X86_64_TPOFF64;
5180 bfd_put_64 (output_bfd, 0, htab->elf.sgot->contents + off);
5181 outrel.r_addend = 0;
5182 if ((dr_type == R_X86_64_TPOFF64
5183 || dr_type == R_X86_64_TLSDESC) && indx == 0)
5184 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
5185 outrel.r_info = htab->r_info (indx, dr_type);
5187 elf_append_rela (output_bfd, sreloc, &outrel);
5189 if (GOT_TLS_GD_P (tls_type))
5193 BFD_ASSERT (! unresolved_reloc);
5194 bfd_put_64 (output_bfd,
5195 relocation - elf_x86_64_dtpoff_base (info),
5196 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
5200 bfd_put_64 (output_bfd, 0,
5201 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
5202 outrel.r_info = htab->r_info (indx,
5204 outrel.r_offset += GOT_ENTRY_SIZE;
5205 elf_append_rela (output_bfd, sreloc,
5214 local_got_offsets[r_symndx] |= 1;
5217 if (off >= (bfd_vma) -2
5218 && ! GOT_TLS_GDESC_P (tls_type))
5220 if (r_type == ELF32_R_TYPE (rel->r_info))
5222 if (r_type == R_X86_64_GOTPC32_TLSDESC
5223 || r_type == R_X86_64_TLSDESC_CALL)
5224 relocation = htab->elf.sgotplt->output_section->vma
5225 + htab->elf.sgotplt->output_offset
5226 + offplt + htab->sgotplt_jump_table_size;
5228 relocation = htab->elf.sgot->output_section->vma
5229 + htab->elf.sgot->output_offset + off;
5230 unresolved_reloc = FALSE;
5234 bfd_vma roff = rel->r_offset;
5236 if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
5238 /* GD->IE transition. For 64bit, change
5239 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5240 .word 0x6666; rex64; call __tls_get_addr@plt
5243 addq foo@gottpoff(%rip), %rax
5245 leaq foo@tlsgd(%rip), %rdi
5246 .word 0x6666; rex64; call __tls_get_addr@plt
5249 addq foo@gottpoff(%rip), %rax
5250 For largepic, change:
5251 leaq foo@tlsgd(%rip), %rdi
5252 movabsq $__tls_get_addr@pltoff, %rax
5257 addq foo@gottpoff(%rax), %rax
5258 nopw 0x0(%rax,%rax,1) */
5260 if (ABI_64_P (output_bfd)
5261 && contents[roff + 5] == (bfd_byte) '\xb8')
5263 memcpy (contents + roff - 3,
5264 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
5265 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5268 else if (ABI_64_P (output_bfd))
5269 memcpy (contents + roff - 4,
5270 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5273 memcpy (contents + roff - 3,
5274 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5277 relocation = (htab->elf.sgot->output_section->vma
5278 + htab->elf.sgot->output_offset + off
5281 - input_section->output_section->vma
5282 - input_section->output_offset
5284 bfd_put_32 (output_bfd, relocation,
5285 contents + roff + 8 + largepic);
5286 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5291 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
5293 /* GDesc -> IE transition.
5294 It's originally something like:
5295 leaq x@tlsdesc(%rip), %rax
5298 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
5300 /* Now modify the instruction as appropriate. To
5301 turn a leaq into a movq in the form we use it, it
5302 suffices to change the second byte from 0x8d to
5304 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
5306 bfd_put_32 (output_bfd,
5307 htab->elf.sgot->output_section->vma
5308 + htab->elf.sgot->output_offset + off
5310 - input_section->output_section->vma
5311 - input_section->output_offset
5316 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
5318 /* GDesc -> IE transition.
5325 bfd_put_8 (output_bfd, 0x66, contents + roff);
5326 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
5334 case R_X86_64_TLSLD:
5335 if (! elf_x86_64_tls_transition (info, input_bfd,
5336 input_section, contents,
5337 symtab_hdr, sym_hashes,
5338 &r_type, GOT_UNKNOWN,
5339 rel, relend, h, r_symndx))
5342 if (r_type != R_X86_64_TLSLD)
5344 /* LD->LE transition:
5345 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
5346 For 64bit, we change it into:
5347 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
5348 For 32bit, we change it into:
5349 nopl 0x0(%rax); movl %fs:0, %eax.
5350 For largepic, change:
5351 leaq foo@tlsgd(%rip), %rdi
5352 movabsq $__tls_get_addr@pltoff, %rax
5356 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
5359 BFD_ASSERT (r_type == R_X86_64_TPOFF32);
5360 if (ABI_64_P (output_bfd)
5361 && contents[rel->r_offset + 5] == (bfd_byte) '\xb8')
5362 memcpy (contents + rel->r_offset - 3,
5363 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
5364 "\x64\x48\x8b\x04\x25\0\0\0", 22);
5365 else if (ABI_64_P (output_bfd))
5366 memcpy (contents + rel->r_offset - 3,
5367 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
5369 memcpy (contents + rel->r_offset - 3,
5370 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
5371 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5377 if (htab->elf.sgot == NULL)
5380 off = htab->tls_ld_got.offset;
5385 Elf_Internal_Rela outrel;
5387 if (htab->elf.srelgot == NULL)
5390 outrel.r_offset = (htab->elf.sgot->output_section->vma
5391 + htab->elf.sgot->output_offset + off);
5393 bfd_put_64 (output_bfd, 0,
5394 htab->elf.sgot->contents + off);
5395 bfd_put_64 (output_bfd, 0,
5396 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
5397 outrel.r_info = htab->r_info (0, R_X86_64_DTPMOD64);
5398 outrel.r_addend = 0;
5399 elf_append_rela (output_bfd, htab->elf.srelgot,
5401 htab->tls_ld_got.offset |= 1;
5403 relocation = htab->elf.sgot->output_section->vma
5404 + htab->elf.sgot->output_offset + off;
5405 unresolved_reloc = FALSE;
5408 case R_X86_64_DTPOFF32:
5409 if (!bfd_link_executable (info)
5410 || (input_section->flags & SEC_CODE) == 0)
5411 relocation -= elf_x86_64_dtpoff_base (info);
5413 relocation = elf_x86_64_tpoff (info, relocation);
5416 case R_X86_64_TPOFF32:
5417 case R_X86_64_TPOFF64:
5418 BFD_ASSERT (bfd_link_executable (info));
5419 relocation = elf_x86_64_tpoff (info, relocation);
5422 case R_X86_64_DTPOFF64:
5423 BFD_ASSERT ((input_section->flags & SEC_CODE) == 0);
5424 relocation -= elf_x86_64_dtpoff_base (info);
5431 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5432 because such sections are not SEC_ALLOC and thus ld.so will
5433 not process them. */
5434 if (unresolved_reloc
5435 && !((input_section->flags & SEC_DEBUGGING) != 0
5437 && _bfd_elf_section_offset (output_bfd, info, input_section,
5438 rel->r_offset) != (bfd_vma) -1)
5440 (*_bfd_error_handler)
5441 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5444 (long) rel->r_offset,
5446 h->root.root.string);
5451 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5452 contents, rel->r_offset,
5453 relocation, rel->r_addend);
5455 check_relocation_error:
5456 if (r != bfd_reloc_ok)
5461 name = h->root.root.string;
5464 name = bfd_elf_string_from_elf_section (input_bfd,
5465 symtab_hdr->sh_link,
5470 name = bfd_section_name (input_bfd, sec);
5473 if (r == bfd_reloc_overflow)
5475 if (! ((*info->callbacks->reloc_overflow)
5476 (info, (h ? &h->root : NULL), name, howto->name,
5477 (bfd_vma) 0, input_bfd, input_section,
5483 (*_bfd_error_handler)
5484 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5485 input_bfd, input_section,
5486 (long) rel->r_offset, name, (int) r);
5497 Elf_Internal_Shdr *rel_hdr;
5498 size_t deleted = rel - wrel;
5500 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
5501 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
5502 if (rel_hdr->sh_size == 0)
5504 /* It is too late to remove an empty reloc section. Leave
5506 ??? What is wrong with an empty section??? */
5507 rel_hdr->sh_size = rel_hdr->sh_entsize;
5510 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
5511 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
5512 input_section->reloc_count -= deleted;
5518 /* Finish up dynamic symbol handling. We set the contents of various
5519 dynamic sections here. */
5522 elf_x86_64_finish_dynamic_symbol (bfd *output_bfd,
5523 struct bfd_link_info *info,
5524 struct elf_link_hash_entry *h,
5525 Elf_Internal_Sym *sym)
5527 struct elf_x86_64_link_hash_table *htab;
5528 const struct elf_x86_64_backend_data *abed;
5529 bfd_boolean use_plt_bnd;
5530 struct elf_x86_64_link_hash_entry *eh;
5531 bfd_boolean local_undefweak;
5533 htab = elf_x86_64_hash_table (info);
5537 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5538 section only if there is .plt section. */
5539 use_plt_bnd = htab->elf.splt != NULL && htab->plt_bnd != NULL;
5541 ? &elf_x86_64_bnd_arch_bed
5542 : get_elf_x86_64_backend_data (output_bfd));
5544 eh = (struct elf_x86_64_link_hash_entry *) h;
5546 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5547 resolved undefined weak symbols in executable so that their
5548 references have value 0 at run-time. */
5549 local_undefweak = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh);
5551 if (h->plt.offset != (bfd_vma) -1)
5554 bfd_vma got_offset, plt_offset, plt_plt_offset, plt_got_offset;
5555 bfd_vma plt_plt_insn_end, plt_got_insn_size;
5556 Elf_Internal_Rela rela;
5558 asection *plt, *gotplt, *relplt, *resolved_plt;
5559 const struct elf_backend_data *bed;
5560 bfd_vma plt_got_pcrel_offset;
5562 /* When building a static executable, use .iplt, .igot.plt and
5563 .rela.iplt sections for STT_GNU_IFUNC symbols. */
5564 if (htab->elf.splt != NULL)
5566 plt = htab->elf.splt;
5567 gotplt = htab->elf.sgotplt;
5568 relplt = htab->elf.srelplt;
5572 plt = htab->elf.iplt;
5573 gotplt = htab->elf.igotplt;
5574 relplt = htab->elf.irelplt;
5577 /* This symbol has an entry in the procedure linkage table. Set
5579 if ((h->dynindx == -1
5581 && !((h->forced_local || bfd_link_executable (info))
5583 && h->type == STT_GNU_IFUNC))
5589 /* Get the index in the procedure linkage table which
5590 corresponds to this symbol. This is the index of this symbol
5591 in all the symbols for which we are making plt entries. The
5592 first entry in the procedure linkage table is reserved.
5594 Get the offset into the .got table of the entry that
5595 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
5596 bytes. The first three are reserved for the dynamic linker.
5598 For static executables, we don't reserve anything. */
5600 if (plt == htab->elf.splt)
5602 got_offset = h->plt.offset / abed->plt_entry_size - 1;
5603 got_offset = (got_offset + 3) * GOT_ENTRY_SIZE;
5607 got_offset = h->plt.offset / abed->plt_entry_size;
5608 got_offset = got_offset * GOT_ENTRY_SIZE;
5611 plt_plt_insn_end = abed->plt_plt_insn_end;
5612 plt_plt_offset = abed->plt_plt_offset;
5613 plt_got_insn_size = abed->plt_got_insn_size;
5614 plt_got_offset = abed->plt_got_offset;
5617 /* Use the second PLT with BND relocations. */
5618 const bfd_byte *plt_entry, *plt2_entry;
5620 if (eh->has_bnd_reloc)
5622 plt_entry = elf_x86_64_bnd_plt_entry;
5623 plt2_entry = elf_x86_64_bnd_plt2_entry;
5627 plt_entry = elf_x86_64_legacy_plt_entry;
5628 plt2_entry = elf_x86_64_legacy_plt2_entry;
5630 /* Subtract 1 since there is no BND prefix. */
5631 plt_plt_insn_end -= 1;
5632 plt_plt_offset -= 1;
5633 plt_got_insn_size -= 1;
5634 plt_got_offset -= 1;
5637 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry)
5638 == sizeof (elf_x86_64_legacy_plt_entry));
5640 /* Fill in the entry in the procedure linkage table. */
5641 memcpy (plt->contents + h->plt.offset,
5642 plt_entry, sizeof (elf_x86_64_legacy_plt_entry));
5643 /* Fill in the entry in the second PLT. */
5644 memcpy (htab->plt_bnd->contents + eh->plt_bnd.offset,
5645 plt2_entry, sizeof (elf_x86_64_legacy_plt2_entry));
5647 resolved_plt = htab->plt_bnd;
5648 plt_offset = eh->plt_bnd.offset;
5652 /* Fill in the entry in the procedure linkage table. */
5653 memcpy (plt->contents + h->plt.offset, abed->plt_entry,
5654 abed->plt_entry_size);
5657 plt_offset = h->plt.offset;
5660 /* Insert the relocation positions of the plt section. */
5662 /* Put offset the PC-relative instruction referring to the GOT entry,
5663 subtracting the size of that instruction. */
5664 plt_got_pcrel_offset = (gotplt->output_section->vma
5665 + gotplt->output_offset
5667 - resolved_plt->output_section->vma
5668 - resolved_plt->output_offset
5670 - plt_got_insn_size);
5672 /* Check PC-relative offset overflow in PLT entry. */
5673 if ((plt_got_pcrel_offset + 0x80000000) > 0xffffffff)
5674 info->callbacks->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5675 output_bfd, h->root.root.string);
5677 bfd_put_32 (output_bfd, plt_got_pcrel_offset,
5678 resolved_plt->contents + plt_offset + plt_got_offset);
5680 /* Fill in the entry in the global offset table, initially this
5681 points to the second part of the PLT entry. Leave the entry
5682 as zero for undefined weak symbol in PIE. No PLT relocation
5683 against undefined weak symbol in PIE. */
5684 if (!local_undefweak)
5686 bfd_put_64 (output_bfd, (plt->output_section->vma
5687 + plt->output_offset
5689 + abed->plt_lazy_offset),
5690 gotplt->contents + got_offset);
5692 /* Fill in the entry in the .rela.plt section. */
5693 rela.r_offset = (gotplt->output_section->vma
5694 + gotplt->output_offset
5696 if (h->dynindx == -1
5697 || ((bfd_link_executable (info)
5698 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
5700 && h->type == STT_GNU_IFUNC))
5702 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5703 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
5704 rela.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
5705 rela.r_addend = (h->root.u.def.value
5706 + h->root.u.def.section->output_section->vma
5707 + h->root.u.def.section->output_offset);
5708 /* R_X86_64_IRELATIVE comes last. */
5709 plt_index = htab->next_irelative_index--;
5713 rela.r_info = htab->r_info (h->dynindx, R_X86_64_JUMP_SLOT);
5715 plt_index = htab->next_jump_slot_index++;
5718 /* Don't fill PLT entry for static executables. */
5719 if (plt == htab->elf.splt)
5721 bfd_vma plt0_offset = h->plt.offset + plt_plt_insn_end;
5723 /* Put relocation index. */
5724 bfd_put_32 (output_bfd, plt_index,
5725 (plt->contents + h->plt.offset
5726 + abed->plt_reloc_offset));
5728 /* Put offset for jmp .PLT0 and check for overflow. We don't
5729 check relocation index for overflow since branch displacement
5730 will overflow first. */
5731 if (plt0_offset > 0x80000000)
5732 info->callbacks->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5733 output_bfd, h->root.root.string);
5734 bfd_put_32 (output_bfd, - plt0_offset,
5735 plt->contents + h->plt.offset + plt_plt_offset);
5738 bed = get_elf_backend_data (output_bfd);
5739 loc = relplt->contents + plt_index * bed->s->sizeof_rela;
5740 bed->s->swap_reloca_out (output_bfd, &rela, loc);
5743 else if (eh->plt_got.offset != (bfd_vma) -1)
5745 bfd_vma got_offset, plt_offset, plt_got_offset, plt_got_insn_size;
5746 asection *plt, *got;
5747 bfd_boolean got_after_plt;
5748 int32_t got_pcrel_offset;
5749 const bfd_byte *got_plt_entry;
5751 /* Set the entry in the GOT procedure linkage table. */
5752 plt = htab->plt_got;
5753 got = htab->elf.sgot;
5754 got_offset = h->got.offset;
5756 if (got_offset == (bfd_vma) -1
5757 || h->type == STT_GNU_IFUNC
5762 /* Use the second PLT entry template for the GOT PLT since they
5763 are the identical. */
5764 plt_got_insn_size = elf_x86_64_bnd_arch_bed.plt_got_insn_size;
5765 plt_got_offset = elf_x86_64_bnd_arch_bed.plt_got_offset;
5766 if (eh->has_bnd_reloc)
5767 got_plt_entry = elf_x86_64_bnd_plt2_entry;
5770 got_plt_entry = elf_x86_64_legacy_plt2_entry;
5772 /* Subtract 1 since there is no BND prefix. */
5773 plt_got_insn_size -= 1;
5774 plt_got_offset -= 1;
5777 /* Fill in the entry in the GOT procedure linkage table. */
5778 plt_offset = eh->plt_got.offset;
5779 memcpy (plt->contents + plt_offset,
5780 got_plt_entry, sizeof (elf_x86_64_legacy_plt2_entry));
5782 /* Put offset the PC-relative instruction referring to the GOT
5783 entry, subtracting the size of that instruction. */
5784 got_pcrel_offset = (got->output_section->vma
5785 + got->output_offset
5787 - plt->output_section->vma
5788 - plt->output_offset
5790 - plt_got_insn_size);
5792 /* Check PC-relative offset overflow in GOT PLT entry. */
5793 got_after_plt = got->output_section->vma > plt->output_section->vma;
5794 if ((got_after_plt && got_pcrel_offset < 0)
5795 || (!got_after_plt && got_pcrel_offset > 0))
5796 info->callbacks->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
5797 output_bfd, h->root.root.string);
5799 bfd_put_32 (output_bfd, got_pcrel_offset,
5800 plt->contents + plt_offset + plt_got_offset);
5803 if (!local_undefweak
5805 && (h->plt.offset != (bfd_vma) -1
5806 || eh->plt_got.offset != (bfd_vma) -1))
5808 /* Mark the symbol as undefined, rather than as defined in
5809 the .plt section. Leave the value if there were any
5810 relocations where pointer equality matters (this is a clue
5811 for the dynamic linker, to make function pointer
5812 comparisons work between an application and shared
5813 library), otherwise set it to zero. If a function is only
5814 called from a binary, there is no need to slow down
5815 shared libraries because of that. */
5816 sym->st_shndx = SHN_UNDEF;
5817 if (!h->pointer_equality_needed)
5821 /* Don't generate dynamic GOT relocation against undefined weak
5822 symbol in executable. */
5823 if (h->got.offset != (bfd_vma) -1
5824 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h)->tls_type)
5825 && elf_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE
5826 && !local_undefweak)
5828 Elf_Internal_Rela rela;
5830 /* This symbol has an entry in the global offset table. Set it
5832 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
5835 rela.r_offset = (htab->elf.sgot->output_section->vma
5836 + htab->elf.sgot->output_offset
5837 + (h->got.offset &~ (bfd_vma) 1));
5839 /* If this is a static link, or it is a -Bsymbolic link and the
5840 symbol is defined locally or was forced to be local because
5841 of a version file, we just want to emit a RELATIVE reloc.
5842 The entry in the global offset table will already have been
5843 initialized in the relocate_section function. */
5845 && h->type == STT_GNU_IFUNC)
5847 if (bfd_link_pic (info))
5849 /* Generate R_X86_64_GLOB_DAT. */
5856 if (!h->pointer_equality_needed)
5859 /* For non-shared object, we can't use .got.plt, which
5860 contains the real function addres if we need pointer
5861 equality. We load the GOT entry with the PLT entry. */
5862 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
5863 bfd_put_64 (output_bfd, (plt->output_section->vma
5864 + plt->output_offset
5866 htab->elf.sgot->contents + h->got.offset);
5870 else if (bfd_link_pic (info)
5871 && SYMBOL_REFERENCES_LOCAL (info, h))
5873 if (!h->def_regular)
5875 BFD_ASSERT((h->got.offset & 1) != 0);
5876 rela.r_info = htab->r_info (0, R_X86_64_RELATIVE);
5877 rela.r_addend = (h->root.u.def.value
5878 + h->root.u.def.section->output_section->vma
5879 + h->root.u.def.section->output_offset);
5883 BFD_ASSERT((h->got.offset & 1) == 0);
5885 bfd_put_64 (output_bfd, (bfd_vma) 0,
5886 htab->elf.sgot->contents + h->got.offset);
5887 rela.r_info = htab->r_info (h->dynindx, R_X86_64_GLOB_DAT);
5891 elf_append_rela (output_bfd, htab->elf.srelgot, &rela);
5896 Elf_Internal_Rela rela;
5898 /* This symbol needs a copy reloc. Set it up. */
5900 if (h->dynindx == -1
5901 || (h->root.type != bfd_link_hash_defined
5902 && h->root.type != bfd_link_hash_defweak)
5903 || htab->srelbss == NULL)
5906 rela.r_offset = (h->root.u.def.value
5907 + h->root.u.def.section->output_section->vma
5908 + h->root.u.def.section->output_offset);
5909 rela.r_info = htab->r_info (h->dynindx, R_X86_64_COPY);
5911 elf_append_rela (output_bfd, htab->srelbss, &rela);
5917 /* Finish up local dynamic symbol handling. We set the contents of
5918 various dynamic sections here. */
5921 elf_x86_64_finish_local_dynamic_symbol (void **slot, void *inf)
5923 struct elf_link_hash_entry *h
5924 = (struct elf_link_hash_entry *) *slot;
5925 struct bfd_link_info *info
5926 = (struct bfd_link_info *) inf;
5928 return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
5932 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5933 here since undefined weak symbol may not be dynamic and may not be
5934 called for elf_x86_64_finish_dynamic_symbol. */
5937 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry *bh,
5940 struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
5941 struct bfd_link_info *info = (struct bfd_link_info *) inf;
5943 if (h->root.type != bfd_link_hash_undefweak
5944 || h->dynindx != -1)
5947 return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
5951 /* Used to decide how to sort relocs in an optimal manner for the
5952 dynamic linker, before writing them out. */
5954 static enum elf_reloc_type_class
5955 elf_x86_64_reloc_type_class (const struct bfd_link_info *info,
5956 const asection *rel_sec ATTRIBUTE_UNUSED,
5957 const Elf_Internal_Rela *rela)
5959 bfd *abfd = info->output_bfd;
5960 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5961 struct elf_x86_64_link_hash_table *htab = elf_x86_64_hash_table (info);
5963 if (htab->elf.dynsym != NULL
5964 && htab->elf.dynsym->contents != NULL)
5966 /* Check relocation against STT_GNU_IFUNC symbol if there are
5968 unsigned long r_symndx = htab->r_sym (rela->r_info);
5969 Elf_Internal_Sym sym;
5970 if (!bed->s->swap_symbol_in (abfd,
5971 (htab->elf.dynsym->contents
5972 + r_symndx * bed->s->sizeof_sym),
5976 if (ELF_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
5977 return reloc_class_ifunc;
5980 switch ((int) ELF32_R_TYPE (rela->r_info))
5982 case R_X86_64_RELATIVE:
5983 case R_X86_64_RELATIVE64:
5984 return reloc_class_relative;
5985 case R_X86_64_JUMP_SLOT:
5986 return reloc_class_plt;
5988 return reloc_class_copy;
5990 return reloc_class_normal;
5994 /* Finish up the dynamic sections. */
5997 elf_x86_64_finish_dynamic_sections (bfd *output_bfd,
5998 struct bfd_link_info *info)
6000 struct elf_x86_64_link_hash_table *htab;
6003 const struct elf_x86_64_backend_data *abed;
6005 htab = elf_x86_64_hash_table (info);
6009 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
6010 section only if there is .plt section. */
6011 abed = (htab->elf.splt != NULL && htab->plt_bnd != NULL
6012 ? &elf_x86_64_bnd_arch_bed
6013 : get_elf_x86_64_backend_data (output_bfd));
6015 dynobj = htab->elf.dynobj;
6016 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
6018 if (htab->elf.dynamic_sections_created)
6020 bfd_byte *dyncon, *dynconend;
6021 const struct elf_backend_data *bed;
6022 bfd_size_type sizeof_dyn;
6024 if (sdyn == NULL || htab->elf.sgot == NULL)
6027 bed = get_elf_backend_data (dynobj);
6028 sizeof_dyn = bed->s->sizeof_dyn;
6029 dyncon = sdyn->contents;
6030 dynconend = sdyn->contents + sdyn->size;
6031 for (; dyncon < dynconend; dyncon += sizeof_dyn)
6033 Elf_Internal_Dyn dyn;
6036 (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
6044 s = htab->elf.sgotplt;
6045 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
6049 dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
6053 s = htab->elf.srelplt->output_section;
6054 dyn.d_un.d_val = s->size;
6058 /* The procedure linkage table relocs (DT_JMPREL) should
6059 not be included in the overall relocs (DT_RELA).
6060 Therefore, we override the DT_RELASZ entry here to
6061 make it not include the JMPREL relocs. Since the
6062 linker script arranges for .rela.plt to follow all
6063 other relocation sections, we don't have to worry
6064 about changing the DT_RELA entry. */
6065 if (htab->elf.srelplt != NULL)
6067 s = htab->elf.srelplt->output_section;
6068 dyn.d_un.d_val -= s->size;
6072 case DT_TLSDESC_PLT:
6074 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
6075 + htab->tlsdesc_plt;
6078 case DT_TLSDESC_GOT:
6080 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
6081 + htab->tlsdesc_got;
6085 (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
6088 /* Fill in the special first entry in the procedure linkage table. */
6089 if (htab->elf.splt && htab->elf.splt->size > 0)
6091 /* Fill in the first entry in the procedure linkage table. */
6092 memcpy (htab->elf.splt->contents,
6093 abed->plt0_entry, abed->plt_entry_size);
6094 /* Add offset for pushq GOT+8(%rip), since the instruction
6095 uses 6 bytes subtract this value. */
6096 bfd_put_32 (output_bfd,
6097 (htab->elf.sgotplt->output_section->vma
6098 + htab->elf.sgotplt->output_offset
6100 - htab->elf.splt->output_section->vma
6101 - htab->elf.splt->output_offset
6103 htab->elf.splt->contents + abed->plt0_got1_offset);
6104 /* Add offset for the PC-relative instruction accessing GOT+16,
6105 subtracting the offset to the end of that instruction. */
6106 bfd_put_32 (output_bfd,
6107 (htab->elf.sgotplt->output_section->vma
6108 + htab->elf.sgotplt->output_offset
6110 - htab->elf.splt->output_section->vma
6111 - htab->elf.splt->output_offset
6112 - abed->plt0_got2_insn_end),
6113 htab->elf.splt->contents + abed->plt0_got2_offset);
6115 elf_section_data (htab->elf.splt->output_section)
6116 ->this_hdr.sh_entsize = abed->plt_entry_size;
6118 if (htab->tlsdesc_plt)
6120 bfd_put_64 (output_bfd, (bfd_vma) 0,
6121 htab->elf.sgot->contents + htab->tlsdesc_got);
6123 memcpy (htab->elf.splt->contents + htab->tlsdesc_plt,
6124 abed->plt0_entry, abed->plt_entry_size);
6126 /* Add offset for pushq GOT+8(%rip), since the
6127 instruction uses 6 bytes subtract this value. */
6128 bfd_put_32 (output_bfd,
6129 (htab->elf.sgotplt->output_section->vma
6130 + htab->elf.sgotplt->output_offset
6132 - htab->elf.splt->output_section->vma
6133 - htab->elf.splt->output_offset
6136 htab->elf.splt->contents
6137 + htab->tlsdesc_plt + abed->plt0_got1_offset);
6138 /* Add offset for the PC-relative instruction accessing GOT+TDG,
6139 where TGD stands for htab->tlsdesc_got, subtracting the offset
6140 to the end of that instruction. */
6141 bfd_put_32 (output_bfd,
6142 (htab->elf.sgot->output_section->vma
6143 + htab->elf.sgot->output_offset
6145 - htab->elf.splt->output_section->vma
6146 - htab->elf.splt->output_offset
6148 - abed->plt0_got2_insn_end),
6149 htab->elf.splt->contents
6150 + htab->tlsdesc_plt + abed->plt0_got2_offset);
6155 if (htab->plt_bnd != NULL)
6156 elf_section_data (htab->plt_bnd->output_section)
6157 ->this_hdr.sh_entsize = sizeof (elf_x86_64_bnd_plt2_entry);
6159 if (htab->elf.sgotplt)
6161 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
6163 (*_bfd_error_handler)
6164 (_("discarded output section: `%A'"), htab->elf.sgotplt);
6168 /* Fill in the first three entries in the global offset table. */
6169 if (htab->elf.sgotplt->size > 0)
6171 /* Set the first entry in the global offset table to the address of
6172 the dynamic section. */
6174 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents);
6176 bfd_put_64 (output_bfd,
6177 sdyn->output_section->vma + sdyn->output_offset,
6178 htab->elf.sgotplt->contents);
6179 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
6180 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
6181 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE*2);
6184 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize =
6188 /* Adjust .eh_frame for .plt section. */
6189 if (htab->plt_eh_frame != NULL
6190 && htab->plt_eh_frame->contents != NULL)
6192 if (htab->elf.splt != NULL
6193 && htab->elf.splt->size != 0
6194 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
6195 && htab->elf.splt->output_section != NULL
6196 && htab->plt_eh_frame->output_section != NULL)
6198 bfd_vma plt_start = htab->elf.splt->output_section->vma;
6199 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
6200 + htab->plt_eh_frame->output_offset
6201 + PLT_FDE_START_OFFSET;
6202 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
6203 htab->plt_eh_frame->contents
6204 + PLT_FDE_START_OFFSET);
6206 if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
6208 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
6210 htab->plt_eh_frame->contents))
6215 if (htab->elf.sgot && htab->elf.sgot->size > 0)
6216 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
6219 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
6220 htab_traverse (htab->loc_hash_table,
6221 elf_x86_64_finish_local_dynamic_symbol,
6224 /* Fill PLT entries for undefined weak symbols in PIE. */
6225 if (bfd_link_pie (info))
6226 bfd_hash_traverse (&info->hash->table,
6227 elf_x86_64_pie_finish_undefweak_symbol,
6233 /* Return an array of PLT entry symbol values. */
6236 elf_x86_64_get_plt_sym_val (bfd *abfd, asymbol **dynsyms, asection *plt,
6239 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
6242 bfd_vma *plt_sym_val;
6244 bfd_byte *plt_contents;
6245 const struct elf_x86_64_backend_data *bed;
6246 Elf_Internal_Shdr *hdr;
6249 /* Get the .plt section contents. PLT passed down may point to the
6250 .plt.bnd section. Make sure that PLT always points to the .plt
6252 plt_bnd = bfd_get_section_by_name (abfd, ".plt.bnd");
6257 plt = bfd_get_section_by_name (abfd, ".plt");
6260 bed = &elf_x86_64_bnd_arch_bed;
6263 bed = get_elf_x86_64_backend_data (abfd);
6265 plt_contents = (bfd_byte *) bfd_malloc (plt->size);
6266 if (plt_contents == NULL)
6268 if (!bfd_get_section_contents (abfd, (asection *) plt,
6269 plt_contents, 0, plt->size))
6272 free (plt_contents);
6276 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
6277 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
6280 hdr = &elf_section_data (relplt)->this_hdr;
6281 count = relplt->size / hdr->sh_entsize;
6283 plt_sym_val = (bfd_vma *) bfd_malloc (sizeof (bfd_vma) * count);
6284 if (plt_sym_val == NULL)
6287 for (i = 0; i < count; i++)
6288 plt_sym_val[i] = -1;
6290 plt_offset = bed->plt_entry_size;
6291 p = relplt->relocation;
6292 for (i = 0; i < count; i++, p++)
6296 /* Skip unknown relocation. */
6297 if (p->howto == NULL)
6300 if (p->howto->type != R_X86_64_JUMP_SLOT
6301 && p->howto->type != R_X86_64_IRELATIVE)
6304 reloc_index = H_GET_32 (abfd, (plt_contents + plt_offset
6305 + bed->plt_reloc_offset));
6306 if (reloc_index < count)
6310 /* This is the index in .plt section. */
6311 long plt_index = plt_offset / bed->plt_entry_size;
6312 /* Store VMA + the offset in .plt.bnd section. */
6313 plt_sym_val[reloc_index] =
6315 + (plt_index - 1) * sizeof (elf_x86_64_legacy_plt2_entry));
6318 plt_sym_val[reloc_index] = plt->vma + plt_offset;
6320 plt_offset += bed->plt_entry_size;
6322 /* PR binutils/18437: Skip extra relocations in the .rela.plt
6324 if (plt_offset >= plt->size)
6328 free (plt_contents);
6333 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
6337 elf_x86_64_get_synthetic_symtab (bfd *abfd,
6344 /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
6345 as PLT if it exists. */
6346 asection *plt = bfd_get_section_by_name (abfd, ".plt.bnd");
6348 plt = bfd_get_section_by_name (abfd, ".plt");
6349 return _bfd_elf_ifunc_get_synthetic_symtab (abfd, symcount, syms,
6350 dynsymcount, dynsyms, ret,
6352 elf_x86_64_get_plt_sym_val);
6355 /* Handle an x86-64 specific section when reading an object file. This
6356 is called when elfcode.h finds a section with an unknown type. */
6359 elf_x86_64_section_from_shdr (bfd *abfd, Elf_Internal_Shdr *hdr,
6360 const char *name, int shindex)
6362 if (hdr->sh_type != SHT_X86_64_UNWIND)
6365 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
6371 /* Hook called by the linker routine which adds symbols from an object
6372 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
6376 elf_x86_64_add_symbol_hook (bfd *abfd,
6377 struct bfd_link_info *info,
6378 Elf_Internal_Sym *sym,
6379 const char **namep ATTRIBUTE_UNUSED,
6380 flagword *flagsp ATTRIBUTE_UNUSED,
6386 switch (sym->st_shndx)
6388 case SHN_X86_64_LCOMMON:
6389 lcomm = bfd_get_section_by_name (abfd, "LARGE_COMMON");
6392 lcomm = bfd_make_section_with_flags (abfd,
6396 | SEC_LINKER_CREATED));
6399 elf_section_flags (lcomm) |= SHF_X86_64_LARGE;
6402 *valp = sym->st_size;
6406 if (ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE
6407 && (abfd->flags & DYNAMIC) == 0
6408 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
6409 elf_tdata (info->output_bfd)->has_gnu_symbols
6410 |= elf_gnu_symbol_unique;
6416 /* Given a BFD section, try to locate the corresponding ELF section
6420 elf_x86_64_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
6421 asection *sec, int *index_return)
6423 if (sec == &_bfd_elf_large_com_section)
6425 *index_return = SHN_X86_64_LCOMMON;
6431 /* Process a symbol. */
6434 elf_x86_64_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
6437 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
6439 switch (elfsym->internal_elf_sym.st_shndx)
6441 case SHN_X86_64_LCOMMON:
6442 asym->section = &_bfd_elf_large_com_section;
6443 asym->value = elfsym->internal_elf_sym.st_size;
6444 /* Common symbol doesn't set BSF_GLOBAL. */
6445 asym->flags &= ~BSF_GLOBAL;
6451 elf_x86_64_common_definition (Elf_Internal_Sym *sym)
6453 return (sym->st_shndx == SHN_COMMON
6454 || sym->st_shndx == SHN_X86_64_LCOMMON);
6458 elf_x86_64_common_section_index (asection *sec)
6460 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
6463 return SHN_X86_64_LCOMMON;
6467 elf_x86_64_common_section (asection *sec)
6469 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
6470 return bfd_com_section_ptr;
6472 return &_bfd_elf_large_com_section;
6476 elf_x86_64_merge_symbol (struct elf_link_hash_entry *h,
6477 const Elf_Internal_Sym *sym,
6482 const asection *oldsec)
6484 /* A normal common symbol and a large common symbol result in a
6485 normal common symbol. We turn the large common symbol into a
6488 && h->root.type == bfd_link_hash_common
6490 && bfd_is_com_section (*psec)
6493 if (sym->st_shndx == SHN_COMMON
6494 && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) != 0)
6496 h->root.u.c.p->section
6497 = bfd_make_section_old_way (oldbfd, "COMMON");
6498 h->root.u.c.p->section->flags = SEC_ALLOC;
6500 else if (sym->st_shndx == SHN_X86_64_LCOMMON
6501 && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) == 0)
6502 *psec = bfd_com_section_ptr;
6509 elf_x86_64_additional_program_headers (bfd *abfd,
6510 struct bfd_link_info *info ATTRIBUTE_UNUSED)
6515 /* Check to see if we need a large readonly segment. */
6516 s = bfd_get_section_by_name (abfd, ".lrodata");
6517 if (s && (s->flags & SEC_LOAD))
6520 /* Check to see if we need a large data segment. Since .lbss sections
6521 is placed right after the .bss section, there should be no need for
6522 a large data segment just because of .lbss. */
6523 s = bfd_get_section_by_name (abfd, ".ldata");
6524 if (s && (s->flags & SEC_LOAD))
6530 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6533 elf_x86_64_hash_symbol (struct elf_link_hash_entry *h)
6535 if (h->plt.offset != (bfd_vma) -1
6537 && !h->pointer_equality_needed)
6540 return _bfd_elf_hash_symbol (h);
6543 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
6546 elf_x86_64_relocs_compatible (const bfd_target *input,
6547 const bfd_target *output)
6549 return ((xvec_get_elf_backend_data (input)->s->elfclass
6550 == xvec_get_elf_backend_data (output)->s->elfclass)
6551 && _bfd_elf_relocs_compatible (input, output));
6554 static const struct bfd_elf_special_section
6555 elf_x86_64_special_sections[]=
6557 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
6558 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
6559 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR + SHF_X86_64_LARGE},
6560 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
6561 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
6562 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
6563 { NULL, 0, 0, 0, 0 }
6566 #define TARGET_LITTLE_SYM x86_64_elf64_vec
6567 #define TARGET_LITTLE_NAME "elf64-x86-64"
6568 #define ELF_ARCH bfd_arch_i386
6569 #define ELF_TARGET_ID X86_64_ELF_DATA
6570 #define ELF_MACHINE_CODE EM_X86_64
6571 #define ELF_MAXPAGESIZE 0x200000
6572 #define ELF_MINPAGESIZE 0x1000
6573 #define ELF_COMMONPAGESIZE 0x1000
6575 #define elf_backend_can_gc_sections 1
6576 #define elf_backend_can_refcount 1
6577 #define elf_backend_want_got_plt 1
6578 #define elf_backend_plt_readonly 1
6579 #define elf_backend_want_plt_sym 0
6580 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
6581 #define elf_backend_rela_normal 1
6582 #define elf_backend_plt_alignment 4
6583 #define elf_backend_extern_protected_data 1
6585 #define elf_info_to_howto elf_x86_64_info_to_howto
6587 #define bfd_elf64_bfd_link_hash_table_create \
6588 elf_x86_64_link_hash_table_create
6589 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
6590 #define bfd_elf64_bfd_reloc_name_lookup \
6591 elf_x86_64_reloc_name_lookup
6593 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
6594 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
6595 #define elf_backend_check_relocs elf_x86_64_check_relocs
6596 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
6597 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
6598 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
6599 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
6600 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
6601 #define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
6602 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
6603 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
6605 #define elf_backend_write_core_note elf_x86_64_write_core_note
6607 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
6608 #define elf_backend_relocate_section elf_x86_64_relocate_section
6609 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
6610 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
6611 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
6612 #define elf_backend_object_p elf64_x86_64_elf_object_p
6613 #define bfd_elf64_mkobject elf_x86_64_mkobject
6614 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
6616 #define elf_backend_section_from_shdr \
6617 elf_x86_64_section_from_shdr
6619 #define elf_backend_section_from_bfd_section \
6620 elf_x86_64_elf_section_from_bfd_section
6621 #define elf_backend_add_symbol_hook \
6622 elf_x86_64_add_symbol_hook
6623 #define elf_backend_symbol_processing \
6624 elf_x86_64_symbol_processing
6625 #define elf_backend_common_section_index \
6626 elf_x86_64_common_section_index
6627 #define elf_backend_common_section \
6628 elf_x86_64_common_section
6629 #define elf_backend_common_definition \
6630 elf_x86_64_common_definition
6631 #define elf_backend_merge_symbol \
6632 elf_x86_64_merge_symbol
6633 #define elf_backend_special_sections \
6634 elf_x86_64_special_sections
6635 #define elf_backend_additional_program_headers \
6636 elf_x86_64_additional_program_headers
6637 #define elf_backend_hash_symbol \
6638 elf_x86_64_hash_symbol
6639 #define elf_backend_omit_section_dynsym \
6640 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6641 #define elf_backend_fixup_symbol \
6642 elf_x86_64_fixup_symbol
6644 #include "elf64-target.h"
6646 /* CloudABI support. */
6648 #undef TARGET_LITTLE_SYM
6649 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
6650 #undef TARGET_LITTLE_NAME
6651 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
6654 #define ELF_OSABI ELFOSABI_CLOUDABI
6657 #define elf64_bed elf64_x86_64_cloudabi_bed
6659 #include "elf64-target.h"
6661 /* FreeBSD support. */
6663 #undef TARGET_LITTLE_SYM
6664 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
6665 #undef TARGET_LITTLE_NAME
6666 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
6669 #define ELF_OSABI ELFOSABI_FREEBSD
6672 #define elf64_bed elf64_x86_64_fbsd_bed
6674 #include "elf64-target.h"
6676 /* Solaris 2 support. */
6678 #undef TARGET_LITTLE_SYM
6679 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
6680 #undef TARGET_LITTLE_NAME
6681 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
6683 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6684 objects won't be recognized. */
6688 #define elf64_bed elf64_x86_64_sol2_bed
6690 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
6692 #undef elf_backend_static_tls_alignment
6693 #define elf_backend_static_tls_alignment 16
6695 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6697 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6699 #undef elf_backend_want_plt_sym
6700 #define elf_backend_want_plt_sym 1
6702 #include "elf64-target.h"
6704 /* Native Client support. */
6707 elf64_x86_64_nacl_elf_object_p (bfd *abfd)
6709 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
6710 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64_nacl);
6714 #undef TARGET_LITTLE_SYM
6715 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
6716 #undef TARGET_LITTLE_NAME
6717 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
6719 #define elf64_bed elf64_x86_64_nacl_bed
6721 #undef ELF_MAXPAGESIZE
6722 #undef ELF_MINPAGESIZE
6723 #undef ELF_COMMONPAGESIZE
6724 #define ELF_MAXPAGESIZE 0x10000
6725 #define ELF_MINPAGESIZE 0x10000
6726 #define ELF_COMMONPAGESIZE 0x10000
6728 /* Restore defaults. */
6730 #undef elf_backend_static_tls_alignment
6731 #undef elf_backend_want_plt_sym
6732 #define elf_backend_want_plt_sym 0
6734 /* NaCl uses substantially different PLT entries for the same effects. */
6736 #undef elf_backend_plt_alignment
6737 #define elf_backend_plt_alignment 5
6738 #define NACL_PLT_ENTRY_SIZE 64
6739 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6741 static const bfd_byte elf_x86_64_nacl_plt0_entry[NACL_PLT_ENTRY_SIZE] =
6743 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
6744 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
6745 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */
6746 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6747 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6749 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
6750 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
6752 /* 32 bytes of nop to pad out to the standard size. */
6753 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6754 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6755 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6756 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6757 0x66, /* excess data32 prefix */
6761 static const bfd_byte elf_x86_64_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
6763 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
6764 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */
6765 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6766 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6768 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
6769 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6770 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6772 /* Lazy GOT entries point here (32-byte aligned). */
6773 0x68, /* pushq immediate */
6774 0, 0, 0, 0, /* replaced with index into relocation table. */
6775 0xe9, /* jmp relative */
6776 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
6778 /* 22 bytes of nop to pad out to the standard size. */
6779 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6780 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6781 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
6784 /* .eh_frame covering the .plt section. */
6786 static const bfd_byte elf_x86_64_nacl_eh_frame_plt[] =
6788 #if (PLT_CIE_LENGTH != 20 \
6789 || PLT_FDE_LENGTH != 36 \
6790 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6791 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6792 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
6794 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
6795 0, 0, 0, 0, /* CIE ID */
6796 1, /* CIE version */
6797 'z', 'R', 0, /* Augmentation string */
6798 1, /* Code alignment factor */
6799 0x78, /* Data alignment factor */
6800 16, /* Return address column */
6801 1, /* Augmentation size */
6802 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
6803 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
6804 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
6805 DW_CFA_nop, DW_CFA_nop,
6807 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
6808 PLT_CIE_LENGTH + 8, 0, 0, 0,/* CIE pointer */
6809 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
6810 0, 0, 0, 0, /* .plt size goes here */
6811 0, /* Augmentation size */
6812 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
6813 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6814 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
6815 DW_CFA_advance_loc + 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6816 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
6817 13, /* Block length */
6818 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
6819 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
6820 DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
6821 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
6822 DW_CFA_nop, DW_CFA_nop
6825 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed =
6827 elf_x86_64_nacl_plt0_entry, /* plt0_entry */
6828 elf_x86_64_nacl_plt_entry, /* plt_entry */
6829 NACL_PLT_ENTRY_SIZE, /* plt_entry_size */
6830 2, /* plt0_got1_offset */
6831 9, /* plt0_got2_offset */
6832 13, /* plt0_got2_insn_end */
6833 3, /* plt_got_offset */
6834 33, /* plt_reloc_offset */
6835 38, /* plt_plt_offset */
6836 7, /* plt_got_insn_size */
6837 42, /* plt_plt_insn_end */
6838 32, /* plt_lazy_offset */
6839 elf_x86_64_nacl_eh_frame_plt, /* eh_frame_plt */
6840 sizeof (elf_x86_64_nacl_eh_frame_plt), /* eh_frame_plt_size */
6843 #undef elf_backend_arch_data
6844 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
6846 #undef elf_backend_object_p
6847 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
6848 #undef elf_backend_modify_segment_map
6849 #define elf_backend_modify_segment_map nacl_modify_segment_map
6850 #undef elf_backend_modify_program_headers
6851 #define elf_backend_modify_program_headers nacl_modify_program_headers
6852 #undef elf_backend_final_write_processing
6853 #define elf_backend_final_write_processing nacl_final_write_processing
6855 #include "elf64-target.h"
6857 /* Native Client x32 support. */
6860 elf32_x86_64_nacl_elf_object_p (bfd *abfd)
6862 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
6863 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32_nacl);
6867 #undef TARGET_LITTLE_SYM
6868 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
6869 #undef TARGET_LITTLE_NAME
6870 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
6872 #define elf32_bed elf32_x86_64_nacl_bed
6874 #define bfd_elf32_bfd_link_hash_table_create \
6875 elf_x86_64_link_hash_table_create
6876 #define bfd_elf32_bfd_reloc_type_lookup \
6877 elf_x86_64_reloc_type_lookup
6878 #define bfd_elf32_bfd_reloc_name_lookup \
6879 elf_x86_64_reloc_name_lookup
6880 #define bfd_elf32_mkobject \
6882 #define bfd_elf32_get_synthetic_symtab \
6883 elf_x86_64_get_synthetic_symtab
6885 #undef elf_backend_object_p
6886 #define elf_backend_object_p \
6887 elf32_x86_64_nacl_elf_object_p
6889 #undef elf_backend_bfd_from_remote_memory
6890 #define elf_backend_bfd_from_remote_memory \
6891 _bfd_elf32_bfd_from_remote_memory
6893 #undef elf_backend_size_info
6894 #define elf_backend_size_info \
6895 _bfd_elf32_size_info
6897 #include "elf32-target.h"
6899 /* Restore defaults. */
6900 #undef elf_backend_object_p
6901 #define elf_backend_object_p elf64_x86_64_elf_object_p
6902 #undef elf_backend_bfd_from_remote_memory
6903 #undef elf_backend_size_info
6904 #undef elf_backend_modify_segment_map
6905 #undef elf_backend_modify_program_headers
6906 #undef elf_backend_final_write_processing
6908 /* Intel L1OM support. */
6911 elf64_l1om_elf_object_p (bfd *abfd)
6913 /* Set the right machine number for an L1OM elf64 file. */
6914 bfd_default_set_arch_mach (abfd, bfd_arch_l1om, bfd_mach_l1om);
6918 #undef TARGET_LITTLE_SYM
6919 #define TARGET_LITTLE_SYM l1om_elf64_vec
6920 #undef TARGET_LITTLE_NAME
6921 #define TARGET_LITTLE_NAME "elf64-l1om"
6923 #define ELF_ARCH bfd_arch_l1om
6925 #undef ELF_MACHINE_CODE
6926 #define ELF_MACHINE_CODE EM_L1OM
6931 #define elf64_bed elf64_l1om_bed
6933 #undef elf_backend_object_p
6934 #define elf_backend_object_p elf64_l1om_elf_object_p
6936 /* Restore defaults. */
6937 #undef ELF_MAXPAGESIZE
6938 #undef ELF_MINPAGESIZE
6939 #undef ELF_COMMONPAGESIZE
6940 #define ELF_MAXPAGESIZE 0x200000
6941 #define ELF_MINPAGESIZE 0x1000
6942 #define ELF_COMMONPAGESIZE 0x1000
6943 #undef elf_backend_plt_alignment
6944 #define elf_backend_plt_alignment 4
6945 #undef elf_backend_arch_data
6946 #define elf_backend_arch_data &elf_x86_64_arch_bed
6948 #include "elf64-target.h"
6950 /* FreeBSD L1OM support. */
6952 #undef TARGET_LITTLE_SYM
6953 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
6954 #undef TARGET_LITTLE_NAME
6955 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
6958 #define ELF_OSABI ELFOSABI_FREEBSD
6961 #define elf64_bed elf64_l1om_fbsd_bed
6963 #include "elf64-target.h"
6965 /* Intel K1OM support. */
6968 elf64_k1om_elf_object_p (bfd *abfd)
6970 /* Set the right machine number for an K1OM elf64 file. */
6971 bfd_default_set_arch_mach (abfd, bfd_arch_k1om, bfd_mach_k1om);
6975 #undef TARGET_LITTLE_SYM
6976 #define TARGET_LITTLE_SYM k1om_elf64_vec
6977 #undef TARGET_LITTLE_NAME
6978 #define TARGET_LITTLE_NAME "elf64-k1om"
6980 #define ELF_ARCH bfd_arch_k1om
6982 #undef ELF_MACHINE_CODE
6983 #define ELF_MACHINE_CODE EM_K1OM
6988 #define elf64_bed elf64_k1om_bed
6990 #undef elf_backend_object_p
6991 #define elf_backend_object_p elf64_k1om_elf_object_p
6993 #undef elf_backend_static_tls_alignment
6995 #undef elf_backend_want_plt_sym
6996 #define elf_backend_want_plt_sym 0
6998 #include "elf64-target.h"
7000 /* FreeBSD K1OM support. */
7002 #undef TARGET_LITTLE_SYM
7003 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
7004 #undef TARGET_LITTLE_NAME
7005 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
7008 #define ELF_OSABI ELFOSABI_FREEBSD
7011 #define elf64_bed elf64_k1om_fbsd_bed
7013 #include "elf64-target.h"
7015 /* 32bit x86-64 support. */
7017 #undef TARGET_LITTLE_SYM
7018 #define TARGET_LITTLE_SYM x86_64_elf32_vec
7019 #undef TARGET_LITTLE_NAME
7020 #define TARGET_LITTLE_NAME "elf32-x86-64"
7024 #define ELF_ARCH bfd_arch_i386
7026 #undef ELF_MACHINE_CODE
7027 #define ELF_MACHINE_CODE EM_X86_64
7031 #undef elf_backend_object_p
7032 #define elf_backend_object_p \
7033 elf32_x86_64_elf_object_p
7035 #undef elf_backend_bfd_from_remote_memory
7036 #define elf_backend_bfd_from_remote_memory \
7037 _bfd_elf32_bfd_from_remote_memory
7039 #undef elf_backend_size_info
7040 #define elf_backend_size_info \
7041 _bfd_elf32_size_info
7043 #include "elf32-target.h"