1 /* X86-64 specific support for ELF
2 Copyright (C) 2000-2018 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. */
22 #include "elfxx-x86.h"
25 #include "libiberty.h"
27 #include "opcode/i386.h"
28 #include "elf/x86-64.h"
35 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
36 #define MINUS_ONE (~ (bfd_vma) 0)
38 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
39 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
40 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
41 since they are the same. */
43 /* The relocation "howto" table. Order of fields:
44 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
45 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
46 static reloc_howto_type x86_64_elf_howto_table[] =
48 HOWTO(R_X86_64_NONE, 0, 3, 0, FALSE, 0, complain_overflow_dont,
49 bfd_elf_generic_reloc, "R_X86_64_NONE", FALSE, 0x00000000, 0x00000000,
51 HOWTO(R_X86_64_64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
52 bfd_elf_generic_reloc, "R_X86_64_64", FALSE, MINUS_ONE, MINUS_ONE,
54 HOWTO(R_X86_64_PC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
55 bfd_elf_generic_reloc, "R_X86_64_PC32", FALSE, 0xffffffff, 0xffffffff,
57 HOWTO(R_X86_64_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
58 bfd_elf_generic_reloc, "R_X86_64_GOT32", FALSE, 0xffffffff, 0xffffffff,
60 HOWTO(R_X86_64_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
61 bfd_elf_generic_reloc, "R_X86_64_PLT32", FALSE, 0xffffffff, 0xffffffff,
63 HOWTO(R_X86_64_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
64 bfd_elf_generic_reloc, "R_X86_64_COPY", FALSE, 0xffffffff, 0xffffffff,
66 HOWTO(R_X86_64_GLOB_DAT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
67 bfd_elf_generic_reloc, "R_X86_64_GLOB_DAT", FALSE, MINUS_ONE,
69 HOWTO(R_X86_64_JUMP_SLOT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
70 bfd_elf_generic_reloc, "R_X86_64_JUMP_SLOT", FALSE, MINUS_ONE,
72 HOWTO(R_X86_64_RELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
73 bfd_elf_generic_reloc, "R_X86_64_RELATIVE", FALSE, MINUS_ONE,
75 HOWTO(R_X86_64_GOTPCREL, 0, 2, 32, TRUE, 0, complain_overflow_signed,
76 bfd_elf_generic_reloc, "R_X86_64_GOTPCREL", FALSE, 0xffffffff,
78 HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
79 bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
81 HOWTO(R_X86_64_32S, 0, 2, 32, FALSE, 0, complain_overflow_signed,
82 bfd_elf_generic_reloc, "R_X86_64_32S", FALSE, 0xffffffff, 0xffffffff,
84 HOWTO(R_X86_64_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
85 bfd_elf_generic_reloc, "R_X86_64_16", FALSE, 0xffff, 0xffff, FALSE),
86 HOWTO(R_X86_64_PC16,0, 1, 16, TRUE, 0, complain_overflow_bitfield,
87 bfd_elf_generic_reloc, "R_X86_64_PC16", FALSE, 0xffff, 0xffff, TRUE),
88 HOWTO(R_X86_64_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
89 bfd_elf_generic_reloc, "R_X86_64_8", FALSE, 0xff, 0xff, FALSE),
90 HOWTO(R_X86_64_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
91 bfd_elf_generic_reloc, "R_X86_64_PC8", FALSE, 0xff, 0xff, TRUE),
92 HOWTO(R_X86_64_DTPMOD64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
93 bfd_elf_generic_reloc, "R_X86_64_DTPMOD64", FALSE, MINUS_ONE,
95 HOWTO(R_X86_64_DTPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
96 bfd_elf_generic_reloc, "R_X86_64_DTPOFF64", FALSE, MINUS_ONE,
98 HOWTO(R_X86_64_TPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
99 bfd_elf_generic_reloc, "R_X86_64_TPOFF64", FALSE, MINUS_ONE,
101 HOWTO(R_X86_64_TLSGD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
102 bfd_elf_generic_reloc, "R_X86_64_TLSGD", FALSE, 0xffffffff,
104 HOWTO(R_X86_64_TLSLD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
105 bfd_elf_generic_reloc, "R_X86_64_TLSLD", FALSE, 0xffffffff,
107 HOWTO(R_X86_64_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
108 bfd_elf_generic_reloc, "R_X86_64_DTPOFF32", FALSE, 0xffffffff,
110 HOWTO(R_X86_64_GOTTPOFF, 0, 2, 32, TRUE, 0, complain_overflow_signed,
111 bfd_elf_generic_reloc, "R_X86_64_GOTTPOFF", FALSE, 0xffffffff,
113 HOWTO(R_X86_64_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
114 bfd_elf_generic_reloc, "R_X86_64_TPOFF32", FALSE, 0xffffffff,
116 HOWTO(R_X86_64_PC64, 0, 4, 64, TRUE, 0, complain_overflow_bitfield,
117 bfd_elf_generic_reloc, "R_X86_64_PC64", FALSE, MINUS_ONE, MINUS_ONE,
119 HOWTO(R_X86_64_GOTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
120 bfd_elf_generic_reloc, "R_X86_64_GOTOFF64",
121 FALSE, MINUS_ONE, MINUS_ONE, FALSE),
122 HOWTO(R_X86_64_GOTPC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
123 bfd_elf_generic_reloc, "R_X86_64_GOTPC32",
124 FALSE, 0xffffffff, 0xffffffff, TRUE),
125 HOWTO(R_X86_64_GOT64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
126 bfd_elf_generic_reloc, "R_X86_64_GOT64", FALSE, MINUS_ONE, MINUS_ONE,
128 HOWTO(R_X86_64_GOTPCREL64, 0, 4, 64, TRUE, 0, complain_overflow_signed,
129 bfd_elf_generic_reloc, "R_X86_64_GOTPCREL64", FALSE, MINUS_ONE,
131 HOWTO(R_X86_64_GOTPC64, 0, 4, 64, TRUE, 0, complain_overflow_signed,
132 bfd_elf_generic_reloc, "R_X86_64_GOTPC64",
133 FALSE, MINUS_ONE, MINUS_ONE, TRUE),
134 HOWTO(R_X86_64_GOTPLT64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
135 bfd_elf_generic_reloc, "R_X86_64_GOTPLT64", FALSE, MINUS_ONE,
137 HOWTO(R_X86_64_PLTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
138 bfd_elf_generic_reloc, "R_X86_64_PLTOFF64", FALSE, MINUS_ONE,
140 HOWTO(R_X86_64_SIZE32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
141 bfd_elf_generic_reloc, "R_X86_64_SIZE32", FALSE, 0xffffffff, 0xffffffff,
143 HOWTO(R_X86_64_SIZE64, 0, 4, 64, FALSE, 0, complain_overflow_unsigned,
144 bfd_elf_generic_reloc, "R_X86_64_SIZE64", FALSE, MINUS_ONE, MINUS_ONE,
146 HOWTO(R_X86_64_GOTPC32_TLSDESC, 0, 2, 32, TRUE, 0,
147 complain_overflow_bitfield, bfd_elf_generic_reloc,
148 "R_X86_64_GOTPC32_TLSDESC",
149 FALSE, 0xffffffff, 0xffffffff, TRUE),
150 HOWTO(R_X86_64_TLSDESC_CALL, 0, 0, 0, FALSE, 0,
151 complain_overflow_dont, bfd_elf_generic_reloc,
152 "R_X86_64_TLSDESC_CALL",
154 HOWTO(R_X86_64_TLSDESC, 0, 4, 64, FALSE, 0,
155 complain_overflow_bitfield, bfd_elf_generic_reloc,
157 FALSE, MINUS_ONE, MINUS_ONE, FALSE),
158 HOWTO(R_X86_64_IRELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
159 bfd_elf_generic_reloc, "R_X86_64_IRELATIVE", FALSE, MINUS_ONE,
161 HOWTO(R_X86_64_RELATIVE64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
162 bfd_elf_generic_reloc, "R_X86_64_RELATIVE64", FALSE, MINUS_ONE,
164 HOWTO(R_X86_64_PC32_BND, 0, 2, 32, TRUE, 0, complain_overflow_signed,
165 bfd_elf_generic_reloc, "R_X86_64_PC32_BND", FALSE, 0xffffffff, 0xffffffff,
167 HOWTO(R_X86_64_PLT32_BND, 0, 2, 32, TRUE, 0, complain_overflow_signed,
168 bfd_elf_generic_reloc, "R_X86_64_PLT32_BND", FALSE, 0xffffffff, 0xffffffff,
170 HOWTO(R_X86_64_GOTPCRELX, 0, 2, 32, TRUE, 0, complain_overflow_signed,
171 bfd_elf_generic_reloc, "R_X86_64_GOTPCRELX", FALSE, 0xffffffff,
173 HOWTO(R_X86_64_REX_GOTPCRELX, 0, 2, 32, TRUE, 0, complain_overflow_signed,
174 bfd_elf_generic_reloc, "R_X86_64_REX_GOTPCRELX", FALSE, 0xffffffff,
177 /* We have a gap in the reloc numbers here.
178 R_X86_64_standard counts the number up to this point, and
179 R_X86_64_vt_offset is the value to subtract from a reloc type of
180 R_X86_64_GNU_VT* to form an index into this table. */
181 #define R_X86_64_standard (R_X86_64_REX_GOTPCRELX + 1)
182 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
184 /* GNU extension to record C++ vtable hierarchy. */
185 HOWTO (R_X86_64_GNU_VTINHERIT, 0, 4, 0, FALSE, 0, complain_overflow_dont,
186 NULL, "R_X86_64_GNU_VTINHERIT", FALSE, 0, 0, FALSE),
188 /* GNU extension to record C++ vtable member usage. */
189 HOWTO (R_X86_64_GNU_VTENTRY, 0, 4, 0, FALSE, 0, complain_overflow_dont,
190 _bfd_elf_rel_vtable_reloc_fn, "R_X86_64_GNU_VTENTRY", FALSE, 0, 0,
193 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
194 HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
195 bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
199 /* Set if a relocation is converted from a GOTPCREL relocation. */
200 #define R_X86_64_converted_reloc_bit (1 << 7)
202 #define X86_PCREL_TYPE_P(TYPE) \
203 ( ((TYPE) == R_X86_64_PC8) \
204 || ((TYPE) == R_X86_64_PC16) \
205 || ((TYPE) == R_X86_64_PC32) \
206 || ((TYPE) == R_X86_64_PC32_BND) \
207 || ((TYPE) == R_X86_64_PC64))
209 #define X86_SIZE_TYPE_P(TYPE) \
210 ((TYPE) == R_X86_64_SIZE32 || (TYPE) == R_X86_64_SIZE64)
212 /* Map BFD relocs to the x86_64 elf relocs. */
215 bfd_reloc_code_real_type bfd_reloc_val;
216 unsigned char elf_reloc_val;
219 static const struct elf_reloc_map x86_64_reloc_map[] =
221 { BFD_RELOC_NONE, R_X86_64_NONE, },
222 { BFD_RELOC_64, R_X86_64_64, },
223 { BFD_RELOC_32_PCREL, R_X86_64_PC32, },
224 { BFD_RELOC_X86_64_GOT32, R_X86_64_GOT32,},
225 { BFD_RELOC_X86_64_PLT32, R_X86_64_PLT32,},
226 { BFD_RELOC_X86_64_COPY, R_X86_64_COPY, },
227 { BFD_RELOC_X86_64_GLOB_DAT, R_X86_64_GLOB_DAT, },
228 { BFD_RELOC_X86_64_JUMP_SLOT, R_X86_64_JUMP_SLOT, },
229 { BFD_RELOC_X86_64_RELATIVE, R_X86_64_RELATIVE, },
230 { BFD_RELOC_X86_64_GOTPCREL, R_X86_64_GOTPCREL, },
231 { BFD_RELOC_32, R_X86_64_32, },
232 { BFD_RELOC_X86_64_32S, R_X86_64_32S, },
233 { BFD_RELOC_16, R_X86_64_16, },
234 { BFD_RELOC_16_PCREL, R_X86_64_PC16, },
235 { BFD_RELOC_8, R_X86_64_8, },
236 { BFD_RELOC_8_PCREL, R_X86_64_PC8, },
237 { BFD_RELOC_X86_64_DTPMOD64, R_X86_64_DTPMOD64, },
238 { BFD_RELOC_X86_64_DTPOFF64, R_X86_64_DTPOFF64, },
239 { BFD_RELOC_X86_64_TPOFF64, R_X86_64_TPOFF64, },
240 { BFD_RELOC_X86_64_TLSGD, R_X86_64_TLSGD, },
241 { BFD_RELOC_X86_64_TLSLD, R_X86_64_TLSLD, },
242 { BFD_RELOC_X86_64_DTPOFF32, R_X86_64_DTPOFF32, },
243 { BFD_RELOC_X86_64_GOTTPOFF, R_X86_64_GOTTPOFF, },
244 { BFD_RELOC_X86_64_TPOFF32, R_X86_64_TPOFF32, },
245 { BFD_RELOC_64_PCREL, R_X86_64_PC64, },
246 { BFD_RELOC_X86_64_GOTOFF64, R_X86_64_GOTOFF64, },
247 { BFD_RELOC_X86_64_GOTPC32, R_X86_64_GOTPC32, },
248 { BFD_RELOC_X86_64_GOT64, R_X86_64_GOT64, },
249 { BFD_RELOC_X86_64_GOTPCREL64,R_X86_64_GOTPCREL64, },
250 { BFD_RELOC_X86_64_GOTPC64, R_X86_64_GOTPC64, },
251 { BFD_RELOC_X86_64_GOTPLT64, R_X86_64_GOTPLT64, },
252 { BFD_RELOC_X86_64_PLTOFF64, R_X86_64_PLTOFF64, },
253 { BFD_RELOC_SIZE32, R_X86_64_SIZE32, },
254 { BFD_RELOC_SIZE64, R_X86_64_SIZE64, },
255 { BFD_RELOC_X86_64_GOTPC32_TLSDESC, R_X86_64_GOTPC32_TLSDESC, },
256 { BFD_RELOC_X86_64_TLSDESC_CALL, R_X86_64_TLSDESC_CALL, },
257 { BFD_RELOC_X86_64_TLSDESC, R_X86_64_TLSDESC, },
258 { BFD_RELOC_X86_64_IRELATIVE, R_X86_64_IRELATIVE, },
259 { BFD_RELOC_X86_64_PC32_BND, R_X86_64_PC32_BND, },
260 { BFD_RELOC_X86_64_PLT32_BND, R_X86_64_PLT32_BND, },
261 { BFD_RELOC_X86_64_GOTPCRELX, R_X86_64_GOTPCRELX, },
262 { BFD_RELOC_X86_64_REX_GOTPCRELX, R_X86_64_REX_GOTPCRELX, },
263 { BFD_RELOC_VTABLE_INHERIT, R_X86_64_GNU_VTINHERIT, },
264 { BFD_RELOC_VTABLE_ENTRY, R_X86_64_GNU_VTENTRY, },
267 static reloc_howto_type *
268 elf_x86_64_rtype_to_howto (bfd *abfd, unsigned r_type)
272 if (r_type == (unsigned int) R_X86_64_32)
277 i = ARRAY_SIZE (x86_64_elf_howto_table) - 1;
279 else if (r_type < (unsigned int) R_X86_64_GNU_VTINHERIT
280 || r_type >= (unsigned int) R_X86_64_max)
282 if (r_type >= (unsigned int) R_X86_64_standard)
284 /* xgettext:c-format */
285 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
287 bfd_set_error (bfd_error_bad_value);
293 i = r_type - (unsigned int) R_X86_64_vt_offset;
294 BFD_ASSERT (x86_64_elf_howto_table[i].type == r_type);
295 return &x86_64_elf_howto_table[i];
298 /* Given a BFD reloc type, return a HOWTO structure. */
299 static reloc_howto_type *
300 elf_x86_64_reloc_type_lookup (bfd *abfd,
301 bfd_reloc_code_real_type code)
305 for (i = 0; i < sizeof (x86_64_reloc_map) / sizeof (struct elf_reloc_map);
308 if (x86_64_reloc_map[i].bfd_reloc_val == code)
309 return elf_x86_64_rtype_to_howto (abfd,
310 x86_64_reloc_map[i].elf_reloc_val);
315 static reloc_howto_type *
316 elf_x86_64_reloc_name_lookup (bfd *abfd,
321 if (!ABI_64_P (abfd) && strcasecmp (r_name, "R_X86_64_32") == 0)
323 /* Get x32 R_X86_64_32. */
324 reloc_howto_type *reloc
325 = &x86_64_elf_howto_table[ARRAY_SIZE (x86_64_elf_howto_table) - 1];
326 BFD_ASSERT (reloc->type == (unsigned int) R_X86_64_32);
330 for (i = 0; i < ARRAY_SIZE (x86_64_elf_howto_table); i++)
331 if (x86_64_elf_howto_table[i].name != NULL
332 && strcasecmp (x86_64_elf_howto_table[i].name, r_name) == 0)
333 return &x86_64_elf_howto_table[i];
338 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
341 elf_x86_64_info_to_howto (bfd *abfd, arelent *cache_ptr,
342 Elf_Internal_Rela *dst)
346 r_type = ELF32_R_TYPE (dst->r_info);
347 if (r_type != (unsigned int) R_X86_64_GNU_VTINHERIT
348 && r_type != (unsigned int) R_X86_64_GNU_VTENTRY)
349 r_type &= ~R_X86_64_converted_reloc_bit;
350 cache_ptr->howto = elf_x86_64_rtype_to_howto (abfd, r_type);
351 if (cache_ptr->howto == NULL)
353 BFD_ASSERT (r_type == cache_ptr->howto->type || cache_ptr->howto->type == R_X86_64_NONE);
357 /* Support for core dump NOTE sections. */
359 elf_x86_64_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
364 switch (note->descsz)
369 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
371 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
374 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
382 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
384 elf_tdata (abfd)->core->signal
385 = bfd_get_16 (abfd, note->descdata + 12);
388 elf_tdata (abfd)->core->lwpid
389 = bfd_get_32 (abfd, note->descdata + 32);
398 /* Make a ".reg/999" section. */
399 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
400 size, note->descpos + offset);
404 elf_x86_64_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
406 switch (note->descsz)
411 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
412 elf_tdata (abfd)->core->pid
413 = bfd_get_32 (abfd, note->descdata + 12);
414 elf_tdata (abfd)->core->program
415 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
416 elf_tdata (abfd)->core->command
417 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
420 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
421 elf_tdata (abfd)->core->pid
422 = bfd_get_32 (abfd, note->descdata + 24);
423 elf_tdata (abfd)->core->program
424 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
425 elf_tdata (abfd)->core->command
426 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
429 /* Note that for some reason, a spurious space is tacked
430 onto the end of the args in some (at least one anyway)
431 implementations, so strip it off if it exists. */
434 char *command = elf_tdata (abfd)->core->command;
435 int n = strlen (command);
437 if (0 < n && command[n - 1] == ' ')
438 command[n - 1] = '\0';
446 elf_x86_64_write_core_note (bfd *abfd, char *buf, int *bufsiz,
449 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
451 const char *fname, *psargs;
462 va_start (ap, note_type);
463 fname = va_arg (ap, const char *);
464 psargs = va_arg (ap, const char *);
467 if (bed->s->elfclass == ELFCLASS32)
470 memset (&data, 0, sizeof (data));
471 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
472 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
473 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
474 &data, sizeof (data));
479 memset (&data, 0, sizeof (data));
480 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
481 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
482 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
483 &data, sizeof (data));
488 va_start (ap, note_type);
489 pid = va_arg (ap, long);
490 cursig = va_arg (ap, int);
491 gregs = va_arg (ap, const void *);
494 if (bed->s->elfclass == ELFCLASS32)
496 if (bed->elf_machine_code == EM_X86_64)
498 prstatusx32_t prstat;
499 memset (&prstat, 0, sizeof (prstat));
501 prstat.pr_cursig = cursig;
502 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
503 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
504 &prstat, sizeof (prstat));
509 memset (&prstat, 0, sizeof (prstat));
511 prstat.pr_cursig = cursig;
512 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
513 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
514 &prstat, sizeof (prstat));
520 memset (&prstat, 0, sizeof (prstat));
522 prstat.pr_cursig = cursig;
523 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
524 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
525 &prstat, sizeof (prstat));
532 /* Functions for the x86-64 ELF linker. */
534 /* The size in bytes of an entry in the global offset table. */
536 #define GOT_ENTRY_SIZE 8
538 /* The size in bytes of an entry in the lazy procedure linkage table. */
540 #define LAZY_PLT_ENTRY_SIZE 16
542 /* The size in bytes of an entry in the non-lazy procedure linkage
545 #define NON_LAZY_PLT_ENTRY_SIZE 8
547 /* The first entry in a lazy procedure linkage table looks like this.
548 See the SVR4 ABI i386 supplement and the x86-64 ABI to see how this
551 static const bfd_byte elf_x86_64_lazy_plt0_entry[LAZY_PLT_ENTRY_SIZE] =
553 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
554 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
555 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
558 /* Subsequent entries in a lazy procedure linkage table look like this. */
560 static const bfd_byte elf_x86_64_lazy_plt_entry[LAZY_PLT_ENTRY_SIZE] =
562 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
563 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
564 0x68, /* pushq immediate */
565 0, 0, 0, 0, /* replaced with index into relocation table. */
566 0xe9, /* jmp relative */
567 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
570 /* The first entry in a lazy procedure linkage table with BND prefix
573 static const bfd_byte elf_x86_64_lazy_bnd_plt0_entry[LAZY_PLT_ENTRY_SIZE] =
575 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
576 0xf2, 0xff, 0x25, 16, 0, 0, 0, /* bnd jmpq *GOT+16(%rip) */
577 0x0f, 0x1f, 0 /* nopl (%rax) */
580 /* Subsequent entries for branches with BND prefx in a lazy procedure
581 linkage table look like this. */
583 static const bfd_byte elf_x86_64_lazy_bnd_plt_entry[LAZY_PLT_ENTRY_SIZE] =
585 0x68, 0, 0, 0, 0, /* pushq immediate */
586 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
587 0x0f, 0x1f, 0x44, 0, 0 /* nopl 0(%rax,%rax,1) */
590 /* The first entry in the IBT-enabled lazy procedure linkage table is the
591 the same as the lazy PLT with BND prefix so that bound registers are
592 preserved when control is passed to dynamic linker. Subsequent
593 entries for a IBT-enabled lazy procedure linkage table look like
596 static const bfd_byte elf_x86_64_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] =
598 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */
599 0x68, 0, 0, 0, 0, /* pushq immediate */
600 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
604 /* The first entry in the x32 IBT-enabled lazy procedure linkage table
605 is the same as the normal lazy PLT. Subsequent entries for an
606 x32 IBT-enabled lazy procedure linkage table look like this. */
608 static const bfd_byte elf_x32_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] =
610 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */
611 0x68, 0, 0, 0, 0, /* pushq immediate */
612 0xe9, 0, 0, 0, 0, /* jmpq relative */
613 0x66, 0x90 /* xchg %ax,%ax */
616 /* Entries in the non-lazey procedure linkage table look like this. */
618 static const bfd_byte elf_x86_64_non_lazy_plt_entry[NON_LAZY_PLT_ENTRY_SIZE] =
620 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
621 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
622 0x66, 0x90 /* xchg %ax,%ax */
625 /* Entries for branches with BND prefix in the non-lazey procedure
626 linkage table look like this. */
628 static const bfd_byte elf_x86_64_non_lazy_bnd_plt_entry[NON_LAZY_PLT_ENTRY_SIZE] =
630 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
631 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
635 /* Entries for branches with IBT-enabled in the non-lazey procedure
636 linkage table look like this. They have the same size as the lazy
639 static const bfd_byte elf_x86_64_non_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] =
641 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */
642 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
643 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
644 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nopl 0x0(%rax,%rax,1) */
647 /* Entries for branches with IBT-enabled in the x32 non-lazey procedure
648 linkage table look like this. They have the same size as the lazy
651 static const bfd_byte elf_x32_non_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] =
653 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */
654 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
655 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
656 0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nopw 0x0(%rax,%rax,1) */
659 /* .eh_frame covering the lazy .plt section. */
661 static const bfd_byte elf_x86_64_eh_frame_lazy_plt[] =
663 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
664 0, 0, 0, 0, /* CIE ID */
666 'z', 'R', 0, /* Augmentation string */
667 1, /* Code alignment factor */
668 0x78, /* Data alignment factor */
669 16, /* Return address column */
670 1, /* Augmentation size */
671 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
672 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
673 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
674 DW_CFA_nop, DW_CFA_nop,
676 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
677 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
678 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
679 0, 0, 0, 0, /* .plt size goes here */
680 0, /* Augmentation size */
681 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
682 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
683 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
684 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
685 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
686 11, /* Block length */
687 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
688 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
689 DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
690 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
691 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
694 /* .eh_frame covering the lazy BND .plt section. */
696 static const bfd_byte elf_x86_64_eh_frame_lazy_bnd_plt[] =
698 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
699 0, 0, 0, 0, /* CIE ID */
701 'z', 'R', 0, /* Augmentation string */
702 1, /* Code alignment factor */
703 0x78, /* Data alignment factor */
704 16, /* Return address column */
705 1, /* Augmentation size */
706 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
707 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
708 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
709 DW_CFA_nop, DW_CFA_nop,
711 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
712 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
713 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
714 0, 0, 0, 0, /* .plt size goes here */
715 0, /* Augmentation size */
716 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
717 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
718 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
719 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
720 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
721 11, /* Block length */
722 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
723 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
724 DW_OP_lit15, DW_OP_and, DW_OP_lit5, DW_OP_ge,
725 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
726 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
729 /* .eh_frame covering the lazy .plt section with IBT-enabled. */
731 static const bfd_byte elf_x86_64_eh_frame_lazy_ibt_plt[] =
733 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
734 0, 0, 0, 0, /* CIE ID */
736 'z', 'R', 0, /* Augmentation string */
737 1, /* Code alignment factor */
738 0x78, /* Data alignment factor */
739 16, /* Return address column */
740 1, /* Augmentation size */
741 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
742 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
743 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
744 DW_CFA_nop, DW_CFA_nop,
746 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
747 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
748 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
749 0, 0, 0, 0, /* .plt size goes here */
750 0, /* Augmentation size */
751 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
752 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
753 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
754 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
755 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
756 11, /* Block length */
757 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
758 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
759 DW_OP_lit15, DW_OP_and, DW_OP_lit10, DW_OP_ge,
760 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
761 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
764 /* .eh_frame covering the x32 lazy .plt section with IBT-enabled. */
766 static const bfd_byte elf_x32_eh_frame_lazy_ibt_plt[] =
768 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
769 0, 0, 0, 0, /* CIE ID */
771 'z', 'R', 0, /* Augmentation string */
772 1, /* Code alignment factor */
773 0x78, /* Data alignment factor */
774 16, /* Return address column */
775 1, /* Augmentation size */
776 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
777 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
778 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
779 DW_CFA_nop, DW_CFA_nop,
781 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
782 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
783 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
784 0, 0, 0, 0, /* .plt size goes here */
785 0, /* Augmentation size */
786 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
787 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
788 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
789 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
790 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
791 11, /* Block length */
792 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
793 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
794 DW_OP_lit15, DW_OP_and, DW_OP_lit9, DW_OP_ge,
795 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
796 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
799 /* .eh_frame covering the non-lazy .plt section. */
801 static const bfd_byte elf_x86_64_eh_frame_non_lazy_plt[] =
803 #define PLT_GOT_FDE_LENGTH 20
804 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
805 0, 0, 0, 0, /* CIE ID */
807 'z', 'R', 0, /* Augmentation string */
808 1, /* Code alignment factor */
809 0x78, /* Data alignment factor */
810 16, /* Return address column */
811 1, /* Augmentation size */
812 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
813 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
814 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
815 DW_CFA_nop, DW_CFA_nop,
817 PLT_GOT_FDE_LENGTH, 0, 0, 0, /* FDE length */
818 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
819 0, 0, 0, 0, /* the start of non-lazy .plt goes here */
820 0, 0, 0, 0, /* non-lazy .plt size goes here */
821 0, /* Augmentation size */
822 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop,
823 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
826 /* These are the standard parameters. */
827 static const struct elf_x86_lazy_plt_layout elf_x86_64_lazy_plt =
829 elf_x86_64_lazy_plt0_entry, /* plt0_entry */
830 LAZY_PLT_ENTRY_SIZE, /* plt0_entry_size */
831 elf_x86_64_lazy_plt_entry, /* plt_entry */
832 LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */
833 2, /* plt0_got1_offset */
834 8, /* plt0_got2_offset */
835 12, /* plt0_got2_insn_end */
836 2, /* plt_got_offset */
837 7, /* plt_reloc_offset */
838 12, /* plt_plt_offset */
839 6, /* plt_got_insn_size */
840 LAZY_PLT_ENTRY_SIZE, /* plt_plt_insn_end */
841 6, /* plt_lazy_offset */
842 elf_x86_64_lazy_plt0_entry, /* pic_plt0_entry */
843 elf_x86_64_lazy_plt_entry, /* pic_plt_entry */
844 elf_x86_64_eh_frame_lazy_plt, /* eh_frame_plt */
845 sizeof (elf_x86_64_eh_frame_lazy_plt) /* eh_frame_plt_size */
848 static const struct elf_x86_non_lazy_plt_layout elf_x86_64_non_lazy_plt =
850 elf_x86_64_non_lazy_plt_entry, /* plt_entry */
851 elf_x86_64_non_lazy_plt_entry, /* pic_plt_entry */
852 NON_LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */
853 2, /* plt_got_offset */
854 6, /* plt_got_insn_size */
855 elf_x86_64_eh_frame_non_lazy_plt, /* eh_frame_plt */
856 sizeof (elf_x86_64_eh_frame_non_lazy_plt) /* eh_frame_plt_size */
859 static const struct elf_x86_lazy_plt_layout elf_x86_64_lazy_bnd_plt =
861 elf_x86_64_lazy_bnd_plt0_entry, /* plt0_entry */
862 LAZY_PLT_ENTRY_SIZE, /* plt0_entry_size */
863 elf_x86_64_lazy_bnd_plt_entry, /* plt_entry */
864 LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */
865 2, /* plt0_got1_offset */
866 1+8, /* plt0_got2_offset */
867 1+12, /* plt0_got2_insn_end */
868 1+2, /* plt_got_offset */
869 1, /* plt_reloc_offset */
870 7, /* plt_plt_offset */
871 1+6, /* plt_got_insn_size */
872 11, /* plt_plt_insn_end */
873 0, /* plt_lazy_offset */
874 elf_x86_64_lazy_bnd_plt0_entry, /* pic_plt0_entry */
875 elf_x86_64_lazy_bnd_plt_entry, /* pic_plt_entry */
876 elf_x86_64_eh_frame_lazy_bnd_plt, /* eh_frame_plt */
877 sizeof (elf_x86_64_eh_frame_lazy_bnd_plt) /* eh_frame_plt_size */
880 static const struct elf_x86_non_lazy_plt_layout elf_x86_64_non_lazy_bnd_plt =
882 elf_x86_64_non_lazy_bnd_plt_entry, /* plt_entry */
883 elf_x86_64_non_lazy_bnd_plt_entry, /* pic_plt_entry */
884 NON_LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */
885 1+2, /* plt_got_offset */
886 1+6, /* plt_got_insn_size */
887 elf_x86_64_eh_frame_non_lazy_plt, /* eh_frame_plt */
888 sizeof (elf_x86_64_eh_frame_non_lazy_plt) /* eh_frame_plt_size */
891 static const struct elf_x86_lazy_plt_layout elf_x86_64_lazy_ibt_plt =
893 elf_x86_64_lazy_bnd_plt0_entry, /* plt0_entry */
894 LAZY_PLT_ENTRY_SIZE, /* plt0_entry_size */
895 elf_x86_64_lazy_ibt_plt_entry, /* plt_entry */
896 LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */
897 2, /* plt0_got1_offset */
898 1+8, /* plt0_got2_offset */
899 1+12, /* plt0_got2_insn_end */
900 4+1+2, /* plt_got_offset */
901 4+1, /* plt_reloc_offset */
902 4+1+6, /* plt_plt_offset */
903 4+1+6, /* plt_got_insn_size */
904 4+1+5+5, /* plt_plt_insn_end */
905 0, /* plt_lazy_offset */
906 elf_x86_64_lazy_bnd_plt0_entry, /* pic_plt0_entry */
907 elf_x86_64_lazy_ibt_plt_entry, /* pic_plt_entry */
908 elf_x86_64_eh_frame_lazy_ibt_plt, /* eh_frame_plt */
909 sizeof (elf_x86_64_eh_frame_lazy_ibt_plt) /* eh_frame_plt_size */
912 static const struct elf_x86_lazy_plt_layout elf_x32_lazy_ibt_plt =
914 elf_x86_64_lazy_plt0_entry, /* plt0_entry */
915 LAZY_PLT_ENTRY_SIZE, /* plt0_entry_size */
916 elf_x32_lazy_ibt_plt_entry, /* plt_entry */
917 LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */
918 2, /* plt0_got1_offset */
919 8, /* plt0_got2_offset */
920 12, /* plt0_got2_insn_end */
921 4+2, /* plt_got_offset */
922 4+1, /* plt_reloc_offset */
923 4+6, /* plt_plt_offset */
924 4+6, /* plt_got_insn_size */
925 4+5+5, /* plt_plt_insn_end */
926 0, /* plt_lazy_offset */
927 elf_x86_64_lazy_plt0_entry, /* pic_plt0_entry */
928 elf_x32_lazy_ibt_plt_entry, /* pic_plt_entry */
929 elf_x32_eh_frame_lazy_ibt_plt, /* eh_frame_plt */
930 sizeof (elf_x32_eh_frame_lazy_ibt_plt) /* eh_frame_plt_size */
933 static const struct elf_x86_non_lazy_plt_layout elf_x86_64_non_lazy_ibt_plt =
935 elf_x86_64_non_lazy_ibt_plt_entry, /* plt_entry */
936 elf_x86_64_non_lazy_ibt_plt_entry, /* pic_plt_entry */
937 LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */
938 4+1+2, /* plt_got_offset */
939 4+1+6, /* plt_got_insn_size */
940 elf_x86_64_eh_frame_non_lazy_plt, /* eh_frame_plt */
941 sizeof (elf_x86_64_eh_frame_non_lazy_plt) /* eh_frame_plt_size */
944 static const struct elf_x86_non_lazy_plt_layout elf_x32_non_lazy_ibt_plt =
946 elf_x32_non_lazy_ibt_plt_entry, /* plt_entry */
947 elf_x32_non_lazy_ibt_plt_entry, /* pic_plt_entry */
948 LAZY_PLT_ENTRY_SIZE, /* plt_entry_size */
949 4+2, /* plt_got_offset */
950 4+6, /* plt_got_insn_size */
951 elf_x86_64_eh_frame_non_lazy_plt, /* eh_frame_plt */
952 sizeof (elf_x86_64_eh_frame_non_lazy_plt) /* eh_frame_plt_size */
955 static const struct elf_x86_backend_data elf_x86_64_arch_bed =
960 #define elf_backend_arch_data &elf_x86_64_arch_bed
963 elf64_x86_64_elf_object_p (bfd *abfd)
965 /* Set the right machine number for an x86-64 elf64 file. */
966 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64);
971 elf32_x86_64_elf_object_p (bfd *abfd)
973 /* Set the right machine number for an x86-64 elf32 file. */
974 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32);
978 /* Return TRUE if the TLS access code sequence support transition
982 elf_x86_64_check_tls_transition (bfd *abfd,
983 struct bfd_link_info *info,
986 Elf_Internal_Shdr *symtab_hdr,
987 struct elf_link_hash_entry **sym_hashes,
989 const Elf_Internal_Rela *rel,
990 const Elf_Internal_Rela *relend)
993 unsigned long r_symndx;
994 bfd_boolean largepic = FALSE;
995 struct elf_link_hash_entry *h;
997 struct elf_x86_link_hash_table *htab;
999 bfd_boolean indirect_call;
1001 htab = elf_x86_hash_table (info, X86_64_ELF_DATA);
1002 offset = rel->r_offset;
1005 case R_X86_64_TLSGD:
1006 case R_X86_64_TLSLD:
1007 if ((rel + 1) >= relend)
1010 if (r_type == R_X86_64_TLSGD)
1012 /* Check transition from GD access model. For 64bit, only
1013 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1014 .word 0x6666; rex64; call __tls_get_addr@PLT
1016 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1018 call *__tls_get_addr@GOTPCREL(%rip)
1019 which may be converted to
1020 addr32 call __tls_get_addr
1021 can transit to different access model. For 32bit, only
1022 leaq foo@tlsgd(%rip), %rdi
1023 .word 0x6666; rex64; call __tls_get_addr@PLT
1025 leaq foo@tlsgd(%rip), %rdi
1027 call *__tls_get_addr@GOTPCREL(%rip)
1028 which may be converted to
1029 addr32 call __tls_get_addr
1030 can transit to different access model. For largepic,
1032 leaq foo@tlsgd(%rip), %rdi
1033 movabsq $__tls_get_addr@pltoff, %rax
1037 leaq foo@tlsgd(%rip), %rdi
1038 movabsq $__tls_get_addr@pltoff, %rax
1042 static const unsigned char leaq[] = { 0x66, 0x48, 0x8d, 0x3d };
1044 if ((offset + 12) > sec->size)
1047 call = contents + offset + 4;
1049 || !((call[1] == 0x48
1057 && call[3] == 0xe8)))
1059 if (!ABI_64_P (abfd)
1060 || (offset + 19) > sec->size
1062 || memcmp (call - 7, leaq + 1, 3) != 0
1063 || memcmp (call, "\x48\xb8", 2) != 0
1067 || !((call[10] == 0x48 && call[12] == 0xd8)
1068 || (call[10] == 0x4c && call[12] == 0xf8)))
1072 else if (ABI_64_P (abfd))
1075 || memcmp (contents + offset - 4, leaq, 4) != 0)
1081 || memcmp (contents + offset - 3, leaq + 1, 3) != 0)
1084 indirect_call = call[2] == 0xff;
1088 /* Check transition from LD access model. Only
1089 leaq foo@tlsld(%rip), %rdi;
1090 call __tls_get_addr@PLT
1092 leaq foo@tlsld(%rip), %rdi;
1093 call *__tls_get_addr@GOTPCREL(%rip)
1094 which may be converted to
1095 addr32 call __tls_get_addr
1096 can transit to different access model. For largepic
1098 leaq foo@tlsld(%rip), %rdi
1099 movabsq $__tls_get_addr@pltoff, %rax
1103 leaq foo@tlsld(%rip), %rdi
1104 movabsq $__tls_get_addr@pltoff, %rax
1108 static const unsigned char lea[] = { 0x48, 0x8d, 0x3d };
1110 if (offset < 3 || (offset + 9) > sec->size)
1113 if (memcmp (contents + offset - 3, lea, 3) != 0)
1116 call = contents + offset + 4;
1117 if (!(call[0] == 0xe8
1118 || (call[0] == 0xff && call[1] == 0x15)
1119 || (call[0] == 0x67 && call[1] == 0xe8)))
1121 if (!ABI_64_P (abfd)
1122 || (offset + 19) > sec->size
1123 || memcmp (call, "\x48\xb8", 2) != 0
1127 || !((call[10] == 0x48 && call[12] == 0xd8)
1128 || (call[10] == 0x4c && call[12] == 0xf8)))
1132 indirect_call = call[0] == 0xff;
1135 r_symndx = htab->r_sym (rel[1].r_info);
1136 if (r_symndx < symtab_hdr->sh_info)
1139 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1141 || !((struct elf_x86_link_hash_entry *) h)->tls_get_addr)
1145 r_type = (ELF32_R_TYPE (rel[1].r_info)
1146 & ~R_X86_64_converted_reloc_bit);
1148 return r_type == R_X86_64_PLTOFF64;
1149 else if (indirect_call)
1150 return r_type == R_X86_64_GOTPCRELX;
1152 return (r_type == R_X86_64_PC32 || r_type == R_X86_64_PLT32);
1155 case R_X86_64_GOTTPOFF:
1156 /* Check transition from IE access model:
1157 mov foo@gottpoff(%rip), %reg
1158 add foo@gottpoff(%rip), %reg
1161 /* Check REX prefix first. */
1162 if (offset >= 3 && (offset + 4) <= sec->size)
1164 val = bfd_get_8 (abfd, contents + offset - 3);
1165 if (val != 0x48 && val != 0x4c)
1167 /* X32 may have 0x44 REX prefix or no REX prefix. */
1168 if (ABI_64_P (abfd))
1174 /* X32 may not have any REX prefix. */
1175 if (ABI_64_P (abfd))
1177 if (offset < 2 || (offset + 3) > sec->size)
1181 val = bfd_get_8 (abfd, contents + offset - 2);
1182 if (val != 0x8b && val != 0x03)
1185 val = bfd_get_8 (abfd, contents + offset - 1);
1186 return (val & 0xc7) == 5;
1188 case R_X86_64_GOTPC32_TLSDESC:
1189 /* Check transition from GDesc access model:
1190 leaq x@tlsdesc(%rip), %rax
1192 Make sure it's a leaq adding rip to a 32-bit offset
1193 into any register, although it's probably almost always
1196 if (offset < 3 || (offset + 4) > sec->size)
1199 val = bfd_get_8 (abfd, contents + offset - 3);
1200 if ((val & 0xfb) != 0x48)
1203 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1206 val = bfd_get_8 (abfd, contents + offset - 1);
1207 return (val & 0xc7) == 0x05;
1209 case R_X86_64_TLSDESC_CALL:
1210 /* Check transition from GDesc access model:
1211 call *x@tlsdesc(%rax)
1213 if (offset + 2 <= sec->size)
1215 /* Make sure that it's a call *x@tlsdesc(%rax). */
1216 call = contents + offset;
1217 return call[0] == 0xff && call[1] == 0x10;
1227 /* Return TRUE if the TLS access transition is OK or no transition
1228 will be performed. Update R_TYPE if there is a transition. */
1231 elf_x86_64_tls_transition (struct bfd_link_info *info, bfd *abfd,
1232 asection *sec, bfd_byte *contents,
1233 Elf_Internal_Shdr *symtab_hdr,
1234 struct elf_link_hash_entry **sym_hashes,
1235 unsigned int *r_type, int tls_type,
1236 const Elf_Internal_Rela *rel,
1237 const Elf_Internal_Rela *relend,
1238 struct elf_link_hash_entry *h,
1239 unsigned long r_symndx,
1240 bfd_boolean from_relocate_section)
1242 unsigned int from_type = *r_type;
1243 unsigned int to_type = from_type;
1244 bfd_boolean check = TRUE;
1246 /* Skip TLS transition for functions. */
1248 && (h->type == STT_FUNC
1249 || h->type == STT_GNU_IFUNC))
1254 case R_X86_64_TLSGD:
1255 case R_X86_64_GOTPC32_TLSDESC:
1256 case R_X86_64_TLSDESC_CALL:
1257 case R_X86_64_GOTTPOFF:
1258 if (bfd_link_executable (info))
1261 to_type = R_X86_64_TPOFF32;
1263 to_type = R_X86_64_GOTTPOFF;
1266 /* When we are called from elf_x86_64_relocate_section, there may
1267 be additional transitions based on TLS_TYPE. */
1268 if (from_relocate_section)
1270 unsigned int new_to_type = to_type;
1272 if (TLS_TRANSITION_IE_TO_LE_P (info, h, tls_type))
1273 new_to_type = R_X86_64_TPOFF32;
1275 if (to_type == R_X86_64_TLSGD
1276 || to_type == R_X86_64_GOTPC32_TLSDESC
1277 || to_type == R_X86_64_TLSDESC_CALL)
1279 if (tls_type == GOT_TLS_IE)
1280 new_to_type = R_X86_64_GOTTPOFF;
1283 /* We checked the transition before when we were called from
1284 elf_x86_64_check_relocs. We only want to check the new
1285 transition which hasn't been checked before. */
1286 check = new_to_type != to_type && from_type == to_type;
1287 to_type = new_to_type;
1292 case R_X86_64_TLSLD:
1293 if (bfd_link_executable (info))
1294 to_type = R_X86_64_TPOFF32;
1301 /* Return TRUE if there is no transition. */
1302 if (from_type == to_type)
1305 /* Check if the transition can be performed. */
1307 && ! elf_x86_64_check_tls_transition (abfd, info, sec, contents,
1308 symtab_hdr, sym_hashes,
1309 from_type, rel, relend))
1311 reloc_howto_type *from, *to;
1314 from = elf_x86_64_rtype_to_howto (abfd, from_type);
1315 to = elf_x86_64_rtype_to_howto (abfd, to_type);
1317 if (from == NULL || to == NULL)
1321 name = h->root.root.string;
1324 struct elf_x86_link_hash_table *htab;
1326 htab = elf_x86_hash_table (info, X86_64_ELF_DATA);
1331 Elf_Internal_Sym *isym;
1333 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1335 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1340 /* xgettext:c-format */
1341 (_("%pB: TLS transition from %s to %s against `%s' at %#" PRIx64
1342 " in section `%pA' failed"),
1343 abfd, from->name, to->name, name, (uint64_t) rel->r_offset, sec);
1344 bfd_set_error (bfd_error_bad_value);
1352 /* Rename some of the generic section flags to better document how they
1354 #define check_relocs_failed sec_flg0
1357 elf_x86_64_need_pic (struct bfd_link_info *info,
1358 bfd *input_bfd, asection *sec,
1359 struct elf_link_hash_entry *h,
1360 Elf_Internal_Shdr *symtab_hdr,
1361 Elf_Internal_Sym *isym,
1362 reloc_howto_type *howto)
1365 const char *und = "";
1366 const char *pic = "";
1372 name = h->root.root.string;
1373 switch (ELF_ST_VISIBILITY (h->other))
1376 v = _("hidden symbol ");
1379 v = _("internal symbol ");
1382 v = _("protected symbol ");
1385 if (((struct elf_x86_link_hash_entry *) h)->def_protected)
1386 v = _("protected symbol ");
1389 pic = _("; recompile with -fPIC");
1393 if (!h->def_regular && !h->def_dynamic)
1394 und = _("undefined ");
1398 name = bfd_elf_sym_name (input_bfd, symtab_hdr, isym, NULL);
1399 pic = _("; recompile with -fPIC");
1402 if (bfd_link_dll (info))
1403 object = _("a shared object");
1404 else if (bfd_link_pie (info))
1405 object = _("a PIE object");
1407 object = _("a PDE object");
1409 /* xgettext:c-format */
1410 _bfd_error_handler (_("%pB: relocation %s against %s%s`%s' can "
1411 "not be used when making %s%s"),
1412 input_bfd, howto->name, und, v, name,
1414 bfd_set_error (bfd_error_bad_value);
1415 sec->check_relocs_failed = 1;
1419 /* With the local symbol, foo, we convert
1420 mov foo@GOTPCREL(%rip), %reg
1424 call/jmp *foo@GOTPCREL(%rip)
1426 nop call foo/jmp foo nop
1427 When PIC is false, convert
1428 test %reg, foo@GOTPCREL(%rip)
1432 binop foo@GOTPCREL(%rip), %reg
1435 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1439 elf_x86_64_convert_load_reloc (bfd *abfd,
1441 unsigned int *r_type_p,
1442 Elf_Internal_Rela *irel,
1443 struct elf_link_hash_entry *h,
1444 bfd_boolean *converted,
1445 struct bfd_link_info *link_info)
1447 struct elf_x86_link_hash_table *htab;
1449 bfd_boolean no_overflow;
1451 bfd_boolean to_reloc_pc32;
1453 bfd_signed_vma raddend;
1454 unsigned int opcode;
1456 unsigned int r_type = *r_type_p;
1457 unsigned int r_symndx;
1458 bfd_vma roff = irel->r_offset;
1460 if (roff < (r_type == R_X86_64_REX_GOTPCRELX ? 3 : 2))
1463 raddend = irel->r_addend;
1464 /* Addend for 32-bit PC-relative relocation must be -4. */
1468 htab = elf_x86_hash_table (link_info, X86_64_ELF_DATA);
1469 is_pic = bfd_link_pic (link_info);
1471 relocx = (r_type == R_X86_64_GOTPCRELX
1472 || r_type == R_X86_64_REX_GOTPCRELX);
1474 /* TRUE if --no-relax is used. */
1475 no_overflow = link_info->disable_target_specific_optimizations > 1;
1477 r_symndx = htab->r_sym (irel->r_info);
1479 opcode = bfd_get_8 (abfd, contents + roff - 2);
1481 /* Convert mov to lea since it has been done for a while. */
1484 /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
1485 for call, jmp or one of adc, add, and, cmp, or, sbb, sub,
1486 test, xor instructions. */
1491 /* We convert only to R_X86_64_PC32:
1493 2. R_X86_64_GOTPCREL since we can't modify REX byte.
1494 3. no_overflow is true.
1497 to_reloc_pc32 = (opcode == 0xff
1502 /* Get the symbol referred to by the reloc. */
1505 Elf_Internal_Sym *isym
1506 = bfd_sym_from_r_symndx (&htab->sym_cache, abfd, r_symndx);
1508 /* Skip relocation against undefined symbols. */
1509 if (isym->st_shndx == SHN_UNDEF)
1512 if (isym->st_shndx == SHN_ABS)
1513 tsec = bfd_abs_section_ptr;
1514 else if (isym->st_shndx == SHN_COMMON)
1515 tsec = bfd_com_section_ptr;
1516 else if (isym->st_shndx == SHN_X86_64_LCOMMON)
1517 tsec = &_bfd_elf_large_com_section;
1519 tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1523 /* Undefined weak symbol is only bound locally in executable
1524 and its reference is resolved as 0 without relocation
1525 overflow. We can only perform this optimization for
1526 GOTPCRELX relocations since we need to modify REX byte.
1527 It is OK convert mov with R_X86_64_GOTPCREL to
1529 bfd_boolean local_ref;
1530 struct elf_x86_link_hash_entry *eh = elf_x86_hash_entry (h);
1532 /* NB: Also set linker_def via SYMBOL_REFERENCES_LOCAL_P. */
1533 local_ref = SYMBOL_REFERENCES_LOCAL_P (link_info, h);
1534 if ((relocx || opcode == 0x8b)
1535 && (h->root.type == bfd_link_hash_undefweak
1541 /* Skip for branch instructions since R_X86_64_PC32
1548 /* For non-branch instructions, we can convert to
1549 R_X86_64_32/R_X86_64_32S since we know if there
1551 to_reloc_pc32 = FALSE;
1554 /* Since we don't know the current PC when PIC is true,
1555 we can't convert to R_X86_64_PC32. */
1556 if (to_reloc_pc32 && is_pic)
1561 /* Avoid optimizing GOTPCREL relocations againt _DYNAMIC since
1562 ld.so may use its link-time address. */
1563 else if (h->start_stop
1566 || h->root.type == bfd_link_hash_defined
1567 || h->root.type == bfd_link_hash_defweak)
1568 && h != htab->elf.hdynamic
1571 /* bfd_link_hash_new or bfd_link_hash_undefined is
1572 set by an assignment in a linker script in
1573 bfd_elf_record_link_assignment. start_stop is set
1574 on __start_SECNAME/__stop_SECNAME which mark section
1579 && (h->root.type == bfd_link_hash_new
1580 || h->root.type == bfd_link_hash_undefined
1581 || ((h->root.type == bfd_link_hash_defined
1582 || h->root.type == bfd_link_hash_defweak)
1583 && h->root.u.def.section == bfd_und_section_ptr))))
1585 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */
1590 tsec = h->root.u.def.section;
1596 /* Don't convert GOTPCREL relocation against large section. */
1597 if (elf_section_data (tsec) != NULL
1598 && (elf_section_flags (tsec) & SHF_X86_64_LARGE) != 0)
1601 /* Skip since R_X86_64_PC32/R_X86_64_32/R_X86_64_32S may overflow. */
1608 /* We have "call/jmp *foo@GOTPCREL(%rip)". */
1613 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
1615 modrm = bfd_get_8 (abfd, contents + roff - 1);
1618 /* Convert to "jmp foo nop". */
1621 nop_offset = irel->r_offset + 3;
1622 disp = bfd_get_32 (abfd, contents + irel->r_offset);
1623 irel->r_offset -= 1;
1624 bfd_put_32 (abfd, disp, contents + irel->r_offset);
1628 struct elf_x86_link_hash_entry *eh
1629 = (struct elf_x86_link_hash_entry *) h;
1631 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
1634 /* To support TLS optimization, always use addr32 prefix for
1635 "call *__tls_get_addr@GOTPCREL(%rip)". */
1636 if (eh && eh->tls_get_addr)
1639 nop_offset = irel->r_offset - 2;
1643 nop = link_info->call_nop_byte;
1644 if (link_info->call_nop_as_suffix)
1646 nop_offset = irel->r_offset + 3;
1647 disp = bfd_get_32 (abfd, contents + irel->r_offset);
1648 irel->r_offset -= 1;
1649 bfd_put_32 (abfd, disp, contents + irel->r_offset);
1652 nop_offset = irel->r_offset - 2;
1655 bfd_put_8 (abfd, nop, contents + nop_offset);
1656 bfd_put_8 (abfd, modrm, contents + irel->r_offset - 1);
1657 r_type = R_X86_64_PC32;
1662 unsigned int rex_mask = REX_R;
1664 if (r_type == R_X86_64_REX_GOTPCRELX)
1665 rex = bfd_get_8 (abfd, contents + roff - 3);
1673 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
1674 "lea foo(%rip), %reg". */
1676 r_type = R_X86_64_PC32;
1680 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
1681 "mov $foo, %reg". */
1683 modrm = bfd_get_8 (abfd, contents + roff - 1);
1684 modrm = 0xc0 | (modrm & 0x38) >> 3;
1685 if ((rex & REX_W) != 0
1686 && ABI_64_P (link_info->output_bfd))
1688 /* Keep the REX_W bit in REX byte for LP64. */
1689 r_type = R_X86_64_32S;
1690 goto rewrite_modrm_rex;
1694 /* If the REX_W bit in REX byte isn't needed,
1695 use R_X86_64_32 and clear the W bit to avoid
1696 sign-extend imm32 to imm64. */
1697 r_type = R_X86_64_32;
1698 /* Clear the W bit in REX byte. */
1700 goto rewrite_modrm_rex;
1706 /* R_X86_64_PC32 isn't supported. */
1710 modrm = bfd_get_8 (abfd, contents + roff - 1);
1713 /* Convert "test %reg, foo@GOTPCREL(%rip)" to
1714 "test $foo, %reg". */
1715 modrm = 0xc0 | (modrm & 0x38) >> 3;
1720 /* Convert "binop foo@GOTPCREL(%rip), %reg" to
1721 "binop $foo, %reg". */
1722 modrm = 0xc0 | (modrm & 0x38) >> 3 | (opcode & 0x3c);
1726 /* Use R_X86_64_32 with 32-bit operand to avoid relocation
1727 overflow when sign-extending imm32 to imm64. */
1728 r_type = (rex & REX_W) != 0 ? R_X86_64_32S : R_X86_64_32;
1731 bfd_put_8 (abfd, modrm, contents + roff - 1);
1735 /* Move the R bit to the B bit in REX byte. */
1736 rex = (rex & ~rex_mask) | (rex & REX_R) >> 2;
1737 bfd_put_8 (abfd, rex, contents + roff - 3);
1740 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */
1744 bfd_put_8 (abfd, opcode, contents + roff - 2);
1748 irel->r_info = htab->r_info (r_symndx,
1749 r_type | R_X86_64_converted_reloc_bit);
1756 /* Look through the relocs for a section during the first phase, and
1757 calculate needed space in the global offset table, procedure
1758 linkage table, and dynamic reloc sections. */
1761 elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info,
1763 const Elf_Internal_Rela *relocs)
1765 struct elf_x86_link_hash_table *htab;
1766 Elf_Internal_Shdr *symtab_hdr;
1767 struct elf_link_hash_entry **sym_hashes;
1768 const Elf_Internal_Rela *rel;
1769 const Elf_Internal_Rela *rel_end;
1772 bfd_boolean converted;
1774 if (bfd_link_relocatable (info))
1777 /* Don't do anything special with non-loaded, non-alloced sections.
1778 In particular, any relocs in such sections should not affect GOT
1779 and PLT reference counting (ie. we don't allow them to create GOT
1780 or PLT entries), there's no possibility or desire to optimize TLS
1781 relocs, and there's not much point in propagating relocs to shared
1782 libs that the dynamic linker won't relocate. */
1783 if ((sec->flags & SEC_ALLOC) == 0)
1786 htab = elf_x86_hash_table (info, X86_64_ELF_DATA);
1789 sec->check_relocs_failed = 1;
1793 BFD_ASSERT (is_x86_elf (abfd, htab));
1795 /* Get the section contents. */
1796 if (elf_section_data (sec)->this_hdr.contents != NULL)
1797 contents = elf_section_data (sec)->this_hdr.contents;
1798 else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1800 sec->check_relocs_failed = 1;
1804 symtab_hdr = &elf_symtab_hdr (abfd);
1805 sym_hashes = elf_sym_hashes (abfd);
1811 rel_end = relocs + sec->reloc_count;
1812 for (rel = relocs; rel < rel_end; rel++)
1814 unsigned int r_type;
1815 unsigned int r_symndx;
1816 struct elf_link_hash_entry *h;
1817 struct elf_x86_link_hash_entry *eh;
1818 Elf_Internal_Sym *isym;
1820 bfd_boolean size_reloc;
1821 bfd_boolean converted_reloc;
1823 r_symndx = htab->r_sym (rel->r_info);
1824 r_type = ELF32_R_TYPE (rel->r_info);
1826 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1828 /* xgettext:c-format */
1829 _bfd_error_handler (_("%pB: bad symbol index: %d"),
1834 if (r_symndx < symtab_hdr->sh_info)
1836 /* A local symbol. */
1837 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1842 /* Check relocation against local STT_GNU_IFUNC symbol. */
1843 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1845 h = _bfd_elf_x86_get_local_sym_hash (htab, abfd, rel,
1850 /* Fake a STT_GNU_IFUNC symbol. */
1851 h->root.root.string = bfd_elf_sym_name (abfd, symtab_hdr,
1853 h->type = STT_GNU_IFUNC;
1856 h->forced_local = 1;
1857 h->root.type = bfd_link_hash_defined;
1865 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1866 while (h->root.type == bfd_link_hash_indirect
1867 || h->root.type == bfd_link_hash_warning)
1868 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1871 /* Check invalid x32 relocations. */
1872 if (!ABI_64_P (abfd))
1878 case R_X86_64_DTPOFF64:
1879 case R_X86_64_TPOFF64:
1881 case R_X86_64_GOTOFF64:
1882 case R_X86_64_GOT64:
1883 case R_X86_64_GOTPCREL64:
1884 case R_X86_64_GOTPC64:
1885 case R_X86_64_GOTPLT64:
1886 case R_X86_64_PLTOFF64:
1889 name = h->root.root.string;
1891 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1894 /* xgettext:c-format */
1895 (_("%pB: relocation %s against symbol `%s' isn't "
1896 "supported in x32 mode"), abfd,
1897 x86_64_elf_howto_table[r_type].name, name);
1898 bfd_set_error (bfd_error_bad_value);
1906 /* It is referenced by a non-shared object. */
1909 if (h->type == STT_GNU_IFUNC)
1910 elf_tdata (info->output_bfd)->has_gnu_symbols
1911 |= elf_gnu_symbol_ifunc;
1914 converted_reloc = FALSE;
1915 if ((r_type == R_X86_64_GOTPCREL
1916 || r_type == R_X86_64_GOTPCRELX
1917 || r_type == R_X86_64_REX_GOTPCRELX)
1918 && (h == NULL || h->type != STT_GNU_IFUNC))
1920 Elf_Internal_Rela *irel = (Elf_Internal_Rela *) rel;
1921 if (!elf_x86_64_convert_load_reloc (abfd, contents, &r_type,
1922 irel, h, &converted_reloc,
1926 if (converted_reloc)
1930 if (! elf_x86_64_tls_transition (info, abfd, sec, contents,
1931 symtab_hdr, sym_hashes,
1932 &r_type, GOT_UNKNOWN,
1933 rel, rel_end, h, r_symndx, FALSE))
1936 /* Check if _GLOBAL_OFFSET_TABLE_ is referenced. */
1937 if (h == htab->elf.hgot)
1938 htab->got_referenced = TRUE;
1940 eh = (struct elf_x86_link_hash_entry *) h;
1943 case R_X86_64_TLSLD:
1944 htab->tls_ld_or_ldm_got.refcount = 1;
1947 case R_X86_64_TPOFF32:
1948 if (!bfd_link_executable (info) && ABI_64_P (abfd))
1949 return elf_x86_64_need_pic (info, abfd, sec, h, symtab_hdr, isym,
1950 &x86_64_elf_howto_table[r_type]);
1952 eh->zero_undefweak &= 0x2;
1955 case R_X86_64_GOTTPOFF:
1956 if (!bfd_link_executable (info))
1957 info->flags |= DF_STATIC_TLS;
1960 case R_X86_64_GOT32:
1961 case R_X86_64_GOTPCREL:
1962 case R_X86_64_GOTPCRELX:
1963 case R_X86_64_REX_GOTPCRELX:
1964 case R_X86_64_TLSGD:
1965 case R_X86_64_GOT64:
1966 case R_X86_64_GOTPCREL64:
1967 case R_X86_64_GOTPLT64:
1968 case R_X86_64_GOTPC32_TLSDESC:
1969 case R_X86_64_TLSDESC_CALL:
1970 /* This symbol requires a global offset table entry. */
1972 int tls_type, old_tls_type;
1976 default: tls_type = GOT_NORMAL; break;
1977 case R_X86_64_TLSGD: tls_type = GOT_TLS_GD; break;
1978 case R_X86_64_GOTTPOFF: tls_type = GOT_TLS_IE; break;
1979 case R_X86_64_GOTPC32_TLSDESC:
1980 case R_X86_64_TLSDESC_CALL:
1981 tls_type = GOT_TLS_GDESC; break;
1986 h->got.refcount = 1;
1987 old_tls_type = eh->tls_type;
1991 bfd_signed_vma *local_got_refcounts;
1993 /* This is a global offset table entry for a local symbol. */
1994 local_got_refcounts = elf_local_got_refcounts (abfd);
1995 if (local_got_refcounts == NULL)
1999 size = symtab_hdr->sh_info;
2000 size *= sizeof (bfd_signed_vma)
2001 + sizeof (bfd_vma) + sizeof (char);
2002 local_got_refcounts = ((bfd_signed_vma *)
2003 bfd_zalloc (abfd, size));
2004 if (local_got_refcounts == NULL)
2006 elf_local_got_refcounts (abfd) = local_got_refcounts;
2007 elf_x86_local_tlsdesc_gotent (abfd)
2008 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
2009 elf_x86_local_got_tls_type (abfd)
2010 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
2012 local_got_refcounts[r_symndx] = 1;
2014 = elf_x86_local_got_tls_type (abfd) [r_symndx];
2017 /* If a TLS symbol is accessed using IE at least once,
2018 there is no point to use dynamic model for it. */
2019 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
2020 && (! GOT_TLS_GD_ANY_P (old_tls_type)
2021 || tls_type != GOT_TLS_IE))
2023 if (old_tls_type == GOT_TLS_IE && GOT_TLS_GD_ANY_P (tls_type))
2024 tls_type = old_tls_type;
2025 else if (GOT_TLS_GD_ANY_P (old_tls_type)
2026 && GOT_TLS_GD_ANY_P (tls_type))
2027 tls_type |= old_tls_type;
2031 name = h->root.root.string;
2033 name = bfd_elf_sym_name (abfd, symtab_hdr,
2036 /* xgettext:c-format */
2037 (_("%pB: '%s' accessed both as normal and"
2038 " thread local symbol"),
2040 bfd_set_error (bfd_error_bad_value);
2045 if (old_tls_type != tls_type)
2048 eh->tls_type = tls_type;
2050 elf_x86_local_got_tls_type (abfd) [r_symndx] = tls_type;
2055 case R_X86_64_GOTOFF64:
2056 case R_X86_64_GOTPC32:
2057 case R_X86_64_GOTPC64:
2060 eh->zero_undefweak &= 0x2;
2063 case R_X86_64_PLT32:
2064 case R_X86_64_PLT32_BND:
2065 /* This symbol requires a procedure linkage table entry. We
2066 actually build the entry in adjust_dynamic_symbol,
2067 because this might be a case of linking PIC code which is
2068 never referenced by a dynamic object, in which case we
2069 don't need to generate a procedure linkage table entry
2072 /* If this is a local symbol, we resolve it directly without
2073 creating a procedure linkage table entry. */
2077 eh->zero_undefweak &= 0x2;
2079 h->plt.refcount = 1;
2082 case R_X86_64_PLTOFF64:
2083 /* This tries to form the 'address' of a function relative
2084 to GOT. For global symbols we need a PLT entry. */
2088 h->plt.refcount = 1;
2092 case R_X86_64_SIZE32:
2093 case R_X86_64_SIZE64:
2098 if (!ABI_64_P (abfd))
2104 /* Check relocation overflow as these relocs may lead to
2105 run-time relocation overflow. Don't error out for
2106 sections we don't care about, such as debug sections or
2107 when relocation overflow check is disabled. */
2108 if (!info->no_reloc_overflow_check
2110 && (bfd_link_pic (info)
2111 || (bfd_link_executable (info)
2115 && (sec->flags & SEC_READONLY) == 0)))
2116 return elf_x86_64_need_pic (info, abfd, sec, h, symtab_hdr, isym,
2117 &x86_64_elf_howto_table[r_type]);
2123 case R_X86_64_PC32_BND:
2127 if (eh != NULL && (sec->flags & SEC_CODE) != 0)
2128 eh->zero_undefweak |= 0x2;
2129 /* We are called after all symbols have been resolved. Only
2130 relocation against STT_GNU_IFUNC symbol must go through
2133 && (bfd_link_executable (info)
2134 || h->type == STT_GNU_IFUNC))
2136 bfd_boolean func_pointer_ref = FALSE;
2138 if (r_type == R_X86_64_PC32)
2140 /* Since something like ".long foo - ." may be used
2141 as pointer, make sure that PLT is used if foo is
2142 a function defined in a shared library. */
2143 if ((sec->flags & SEC_CODE) == 0)
2145 h->pointer_equality_needed = 1;
2146 if (bfd_link_pie (info)
2147 && h->type == STT_FUNC
2152 h->plt.refcount = 1;
2156 else if (r_type != R_X86_64_PC32_BND
2157 && r_type != R_X86_64_PC64)
2159 h->pointer_equality_needed = 1;
2160 /* At run-time, R_X86_64_64 can be resolved for both
2161 x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2162 can only be resolved for x32. */
2163 if ((sec->flags & SEC_READONLY) == 0
2164 && (r_type == R_X86_64_64
2165 || (!ABI_64_P (abfd)
2166 && (r_type == R_X86_64_32
2167 || r_type == R_X86_64_32S))))
2168 func_pointer_ref = TRUE;
2171 if (!func_pointer_ref)
2173 /* If this reloc is in a read-only section, we might
2174 need a copy reloc. We can't check reliably at this
2175 stage whether the section is read-only, as input
2176 sections have not yet been mapped to output sections.
2177 Tentatively set the flag for now, and correct in
2178 adjust_dynamic_symbol. */
2181 /* We may need a .plt entry if the symbol is a function
2182 defined in a shared lib or is a function referenced
2183 from the code or read-only section. */
2185 || (sec->flags & (SEC_CODE | SEC_READONLY)) != 0)
2186 h->plt.refcount = 1;
2192 if (NEED_DYNAMIC_RELOCATION_P (info, TRUE, h, sec, r_type,
2193 htab->pointer_r_type))
2195 struct elf_dyn_relocs *p;
2196 struct elf_dyn_relocs **head;
2198 /* We must copy these reloc types into the output file.
2199 Create a reloc section in dynobj and make room for
2203 sreloc = _bfd_elf_make_dynamic_reloc_section
2204 (sec, htab->elf.dynobj, ABI_64_P (abfd) ? 3 : 2,
2205 abfd, /*rela?*/ TRUE);
2211 /* If this is a global symbol, we count the number of
2212 relocations we need for this symbol. */
2214 head = &eh->dyn_relocs;
2217 /* Track dynamic relocs needed for local syms too.
2218 We really need local syms available to do this
2223 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2228 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
2232 /* Beware of type punned pointers vs strict aliasing
2234 vpp = &(elf_section_data (s)->local_dynrel);
2235 head = (struct elf_dyn_relocs **)vpp;
2239 if (p == NULL || p->sec != sec)
2241 bfd_size_type amt = sizeof *p;
2243 p = ((struct elf_dyn_relocs *)
2244 bfd_alloc (htab->elf.dynobj, amt));
2255 /* Count size relocation as PC-relative relocation. */
2256 if (X86_PCREL_TYPE_P (r_type) || size_reloc)
2261 /* This relocation describes the C++ object vtable hierarchy.
2262 Reconstruct it for later use during GC. */
2263 case R_X86_64_GNU_VTINHERIT:
2264 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2268 /* This relocation describes which C++ vtable entries are actually
2269 used. Record for later use during GC. */
2270 case R_X86_64_GNU_VTENTRY:
2271 BFD_ASSERT (h != NULL);
2273 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2282 if (elf_section_data (sec)->this_hdr.contents != contents)
2284 if (!converted && !info->keep_memory)
2288 /* Cache the section contents for elf_link_input_bfd if any
2289 load is converted or --no-keep-memory isn't used. */
2290 elf_section_data (sec)->this_hdr.contents = contents;
2294 /* Cache relocations if any load is converted. */
2295 if (elf_section_data (sec)->relocs != relocs && converted)
2296 elf_section_data (sec)->relocs = (Elf_Internal_Rela *) relocs;
2301 if (elf_section_data (sec)->this_hdr.contents != contents)
2303 sec->check_relocs_failed = 1;
2307 /* Return the relocation value for @tpoff relocation
2308 if STT_TLS virtual address is ADDRESS. */
2311 elf_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address)
2313 struct elf_link_hash_table *htab = elf_hash_table (info);
2314 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
2315 bfd_vma static_tls_size;
2317 /* If tls_segment is NULL, we should have signalled an error already. */
2318 if (htab->tls_sec == NULL)
2321 /* Consider special static TLS alignment requirements. */
2322 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
2323 return address - static_tls_size - htab->tls_sec->vma;
2326 /* Relocate an x86_64 ELF section. */
2329 elf_x86_64_relocate_section (bfd *output_bfd,
2330 struct bfd_link_info *info,
2332 asection *input_section,
2334 Elf_Internal_Rela *relocs,
2335 Elf_Internal_Sym *local_syms,
2336 asection **local_sections)
2338 struct elf_x86_link_hash_table *htab;
2339 Elf_Internal_Shdr *symtab_hdr;
2340 struct elf_link_hash_entry **sym_hashes;
2341 bfd_vma *local_got_offsets;
2342 bfd_vma *local_tlsdesc_gotents;
2343 Elf_Internal_Rela *rel;
2344 Elf_Internal_Rela *wrel;
2345 Elf_Internal_Rela *relend;
2346 unsigned int plt_entry_size;
2348 /* Skip if check_relocs failed. */
2349 if (input_section->check_relocs_failed)
2352 htab = elf_x86_hash_table (info, X86_64_ELF_DATA);
2356 BFD_ASSERT (is_x86_elf (input_bfd, htab));
2358 plt_entry_size = htab->plt.plt_entry_size;
2359 symtab_hdr = &elf_symtab_hdr (input_bfd);
2360 sym_hashes = elf_sym_hashes (input_bfd);
2361 local_got_offsets = elf_local_got_offsets (input_bfd);
2362 local_tlsdesc_gotents = elf_x86_local_tlsdesc_gotent (input_bfd);
2364 _bfd_x86_elf_set_tls_module_base (info);
2366 rel = wrel = relocs;
2367 relend = relocs + input_section->reloc_count;
2368 for (; rel < relend; wrel++, rel++)
2370 unsigned int r_type, r_type_tls;
2371 reloc_howto_type *howto;
2372 unsigned long r_symndx;
2373 struct elf_link_hash_entry *h;
2374 struct elf_x86_link_hash_entry *eh;
2375 Elf_Internal_Sym *sym;
2377 bfd_vma off, offplt, plt_offset;
2379 bfd_boolean unresolved_reloc;
2380 bfd_reloc_status_type r;
2382 asection *base_got, *resolved_plt;
2384 bfd_boolean resolved_to_zero;
2385 bfd_boolean relative_reloc;
2386 bfd_boolean converted_reloc;
2387 bfd_boolean need_copy_reloc_in_pie;
2389 r_type = ELF32_R_TYPE (rel->r_info);
2390 if (r_type == (int) R_X86_64_GNU_VTINHERIT
2391 || r_type == (int) R_X86_64_GNU_VTENTRY)
2398 converted_reloc = (r_type & R_X86_64_converted_reloc_bit) != 0;
2399 r_type &= ~R_X86_64_converted_reloc_bit;
2401 if (r_type >= (int) R_X86_64_standard)
2402 return _bfd_unrecognized_reloc (input_bfd, input_section, r_type);
2404 if (r_type != (int) R_X86_64_32
2405 || ABI_64_P (output_bfd))
2406 howto = x86_64_elf_howto_table + r_type;
2408 howto = (x86_64_elf_howto_table
2409 + ARRAY_SIZE (x86_64_elf_howto_table) - 1);
2410 r_symndx = htab->r_sym (rel->r_info);
2414 unresolved_reloc = FALSE;
2415 if (r_symndx < symtab_hdr->sh_info)
2417 sym = local_syms + r_symndx;
2418 sec = local_sections[r_symndx];
2420 relocation = _bfd_elf_rela_local_sym (output_bfd, sym,
2422 st_size = sym->st_size;
2424 /* Relocate against local STT_GNU_IFUNC symbol. */
2425 if (!bfd_link_relocatable (info)
2426 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
2428 h = _bfd_elf_x86_get_local_sym_hash (htab, input_bfd,
2433 /* Set STT_GNU_IFUNC symbol value. */
2434 h->root.u.def.value = sym->st_value;
2435 h->root.u.def.section = sec;
2440 bfd_boolean warned ATTRIBUTE_UNUSED;
2441 bfd_boolean ignored ATTRIBUTE_UNUSED;
2443 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2444 r_symndx, symtab_hdr, sym_hashes,
2446 unresolved_reloc, warned, ignored);
2450 if (sec != NULL && discarded_section (sec))
2452 _bfd_clear_contents (howto, input_bfd, input_section,
2453 contents + rel->r_offset);
2454 wrel->r_offset = rel->r_offset;
2458 /* For ld -r, remove relocations in debug sections against
2459 sections defined in discarded sections. Not done for
2460 eh_frame editing code expects to be present. */
2461 if (bfd_link_relocatable (info)
2462 && (input_section->flags & SEC_DEBUGGING))
2468 if (bfd_link_relocatable (info))
2475 if (rel->r_addend == 0 && !ABI_64_P (output_bfd))
2477 if (r_type == R_X86_64_64)
2479 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
2480 zero-extend it to 64bit if addend is zero. */
2481 r_type = R_X86_64_32;
2482 memset (contents + rel->r_offset + 4, 0, 4);
2484 else if (r_type == R_X86_64_SIZE64)
2486 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
2487 zero-extend it to 64bit if addend is zero. */
2488 r_type = R_X86_64_SIZE32;
2489 memset (contents + rel->r_offset + 4, 0, 4);
2493 eh = (struct elf_x86_link_hash_entry *) h;
2495 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
2496 it here if it is defined in a non-shared object. */
2498 && h->type == STT_GNU_IFUNC
2504 if ((input_section->flags & SEC_ALLOC) == 0)
2506 /* Dynamic relocs are not propagated for SEC_DEBUGGING
2507 sections because such sections are not SEC_ALLOC and
2508 thus ld.so will not process them. */
2509 if ((input_section->flags & SEC_DEBUGGING) != 0)
2519 case R_X86_64_GOTPCREL:
2520 case R_X86_64_GOTPCRELX:
2521 case R_X86_64_REX_GOTPCRELX:
2522 case R_X86_64_GOTPCREL64:
2523 base_got = htab->elf.sgot;
2524 off = h->got.offset;
2526 if (base_got == NULL)
2529 if (off == (bfd_vma) -1)
2531 /* We can't use h->got.offset here to save state, or
2532 even just remember the offset, as finish_dynamic_symbol
2533 would use that as offset into .got. */
2535 if (h->plt.offset == (bfd_vma) -1)
2538 if (htab->elf.splt != NULL)
2540 plt_index = (h->plt.offset / plt_entry_size
2541 - htab->plt.has_plt0);
2542 off = (plt_index + 3) * GOT_ENTRY_SIZE;
2543 base_got = htab->elf.sgotplt;
2547 plt_index = h->plt.offset / plt_entry_size;
2548 off = plt_index * GOT_ENTRY_SIZE;
2549 base_got = htab->elf.igotplt;
2552 if (h->dynindx == -1
2556 /* This references the local defitionion. We must
2557 initialize this entry in the global offset table.
2558 Since the offset must always be a multiple of 8,
2559 we use the least significant bit to record
2560 whether we have initialized it already.
2562 When doing a dynamic link, we create a .rela.got
2563 relocation entry to initialize the value. This
2564 is done in the finish_dynamic_symbol routine. */
2569 bfd_put_64 (output_bfd, relocation,
2570 base_got->contents + off);
2571 /* Note that this is harmless for the GOTPLT64
2572 case, as -1 | 1 still is -1. */
2578 relocation = (base_got->output_section->vma
2579 + base_got->output_offset + off);
2584 if (h->plt.offset == (bfd_vma) -1)
2586 /* Handle static pointers of STT_GNU_IFUNC symbols. */
2587 if (r_type == htab->pointer_r_type
2588 && (input_section->flags & SEC_CODE) == 0)
2589 goto do_ifunc_pointer;
2590 goto bad_ifunc_reloc;
2593 /* STT_GNU_IFUNC symbol must go through PLT. */
2594 if (htab->elf.splt != NULL)
2596 if (htab->plt_second != NULL)
2598 resolved_plt = htab->plt_second;
2599 plt_offset = eh->plt_second.offset;
2603 resolved_plt = htab->elf.splt;
2604 plt_offset = h->plt.offset;
2609 resolved_plt = htab->elf.iplt;
2610 plt_offset = h->plt.offset;
2613 relocation = (resolved_plt->output_section->vma
2614 + resolved_plt->output_offset + plt_offset);
2620 if (h->root.root.string)
2621 name = h->root.root.string;
2623 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
2626 /* xgettext:c-format */
2627 (_("%pB: relocation %s against STT_GNU_IFUNC "
2628 "symbol `%s' isn't supported"), input_bfd,
2630 bfd_set_error (bfd_error_bad_value);
2634 if (bfd_link_pic (info))
2639 if (ABI_64_P (output_bfd))
2644 if (rel->r_addend != 0)
2646 if (h->root.root.string)
2647 name = h->root.root.string;
2649 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
2652 /* xgettext:c-format */
2653 (_("%pB: relocation %s against STT_GNU_IFUNC "
2654 "symbol `%s' has non-zero addend: %" PRId64),
2655 input_bfd, howto->name, name, (int64_t) rel->r_addend);
2656 bfd_set_error (bfd_error_bad_value);
2660 /* Generate dynamic relcoation only when there is a
2661 non-GOT reference in a shared object or there is no
2663 if ((bfd_link_pic (info) && h->non_got_ref)
2664 || h->plt.offset == (bfd_vma) -1)
2666 Elf_Internal_Rela outrel;
2669 /* Need a dynamic relocation to get the real function
2671 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
2675 if (outrel.r_offset == (bfd_vma) -1
2676 || outrel.r_offset == (bfd_vma) -2)
2679 outrel.r_offset += (input_section->output_section->vma
2680 + input_section->output_offset);
2682 if (POINTER_LOCAL_IFUNC_P (info, h))
2684 info->callbacks->minfo (_("Local IFUNC function `%s' in %pB\n"),
2685 h->root.root.string,
2686 h->root.u.def.section->owner);
2688 /* This symbol is resolved locally. */
2689 outrel.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
2690 outrel.r_addend = (h->root.u.def.value
2691 + h->root.u.def.section->output_section->vma
2692 + h->root.u.def.section->output_offset);
2696 outrel.r_info = htab->r_info (h->dynindx, r_type);
2697 outrel.r_addend = 0;
2700 /* Dynamic relocations are stored in
2701 1. .rela.ifunc section in PIC object.
2702 2. .rela.got section in dynamic executable.
2703 3. .rela.iplt section in static executable. */
2704 if (bfd_link_pic (info))
2705 sreloc = htab->elf.irelifunc;
2706 else if (htab->elf.splt != NULL)
2707 sreloc = htab->elf.srelgot;
2709 sreloc = htab->elf.irelplt;
2710 elf_append_rela (output_bfd, sreloc, &outrel);
2712 /* If this reloc is against an external symbol, we
2713 do not want to fiddle with the addend. Otherwise,
2714 we need to include the symbol value so that it
2715 becomes an addend for the dynamic reloc. For an
2716 internal symbol, we have updated addend. */
2721 case R_X86_64_PC32_BND:
2723 case R_X86_64_PLT32:
2724 case R_X86_64_PLT32_BND:
2729 resolved_to_zero = (eh != NULL
2730 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh));
2732 /* When generating a shared object, the relocations handled here are
2733 copied into the output file to be resolved at run time. */
2736 case R_X86_64_GOT32:
2737 case R_X86_64_GOT64:
2738 /* Relocation is to the entry for this symbol in the global
2740 case R_X86_64_GOTPCREL:
2741 case R_X86_64_GOTPCRELX:
2742 case R_X86_64_REX_GOTPCRELX:
2743 case R_X86_64_GOTPCREL64:
2744 /* Use global offset table entry as symbol value. */
2745 case R_X86_64_GOTPLT64:
2746 /* This is obsolete and treated the same as GOT64. */
2747 base_got = htab->elf.sgot;
2749 if (htab->elf.sgot == NULL)
2752 relative_reloc = FALSE;
2755 off = h->got.offset;
2757 && h->plt.offset != (bfd_vma)-1
2758 && off == (bfd_vma)-1)
2760 /* We can't use h->got.offset here to save
2761 state, or even just remember the offset, as
2762 finish_dynamic_symbol would use that as offset into
2764 bfd_vma plt_index = (h->plt.offset / plt_entry_size
2765 - htab->plt.has_plt0);
2766 off = (plt_index + 3) * GOT_ENTRY_SIZE;
2767 base_got = htab->elf.sgotplt;
2770 if (RESOLVED_LOCALLY_P (info, h, htab))
2772 /* We must initialize this entry in the global offset
2773 table. Since the offset must always be a multiple
2774 of 8, we use the least significant bit to record
2775 whether we have initialized it already.
2777 When doing a dynamic link, we create a .rela.got
2778 relocation entry to initialize the value. This is
2779 done in the finish_dynamic_symbol routine. */
2784 bfd_put_64 (output_bfd, relocation,
2785 base_got->contents + off);
2786 /* Note that this is harmless for the GOTPLT64 case,
2787 as -1 | 1 still is -1. */
2790 if (GENERATE_RELATIVE_RELOC_P (info, h))
2792 /* If this symbol isn't dynamic in PIC,
2793 generate R_X86_64_RELATIVE here. */
2794 eh->no_finish_dynamic_symbol = 1;
2795 relative_reloc = TRUE;
2800 unresolved_reloc = FALSE;
2804 if (local_got_offsets == NULL)
2807 off = local_got_offsets[r_symndx];
2809 /* The offset must always be a multiple of 8. We use
2810 the least significant bit to record whether we have
2811 already generated the necessary reloc. */
2816 bfd_put_64 (output_bfd, relocation,
2817 base_got->contents + off);
2818 local_got_offsets[r_symndx] |= 1;
2820 if (bfd_link_pic (info))
2821 relative_reloc = TRUE;
2828 Elf_Internal_Rela outrel;
2830 /* We need to generate a R_X86_64_RELATIVE reloc
2831 for the dynamic linker. */
2832 s = htab->elf.srelgot;
2836 outrel.r_offset = (base_got->output_section->vma
2837 + base_got->output_offset
2839 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
2840 outrel.r_addend = relocation;
2841 elf_append_rela (output_bfd, s, &outrel);
2844 if (off >= (bfd_vma) -2)
2847 relocation = base_got->output_section->vma
2848 + base_got->output_offset + off;
2849 if (r_type != R_X86_64_GOTPCREL
2850 && r_type != R_X86_64_GOTPCRELX
2851 && r_type != R_X86_64_REX_GOTPCRELX
2852 && r_type != R_X86_64_GOTPCREL64)
2853 relocation -= htab->elf.sgotplt->output_section->vma
2854 - htab->elf.sgotplt->output_offset;
2858 case R_X86_64_GOTOFF64:
2859 /* Relocation is relative to the start of the global offset
2862 /* Check to make sure it isn't a protected function or data
2863 symbol for shared library since it may not be local when
2864 used as function address or with copy relocation. We also
2865 need to make sure that a symbol is referenced locally. */
2866 if (bfd_link_pic (info) && h)
2868 if (!h->def_regular)
2872 switch (ELF_ST_VISIBILITY (h->other))
2875 v = _("hidden symbol");
2878 v = _("internal symbol");
2881 v = _("protected symbol");
2889 /* xgettext:c-format */
2890 (_("%pB: relocation R_X86_64_GOTOFF64 against undefined %s"
2891 " `%s' can not be used when making a shared object"),
2892 input_bfd, v, h->root.root.string);
2893 bfd_set_error (bfd_error_bad_value);
2896 else if (!bfd_link_executable (info)
2897 && !SYMBOL_REFERENCES_LOCAL_P (info, h)
2898 && (h->type == STT_FUNC
2899 || h->type == STT_OBJECT)
2900 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
2903 /* xgettext:c-format */
2904 (_("%pB: relocation R_X86_64_GOTOFF64 against protected %s"
2905 " `%s' can not be used when making a shared object"),
2907 h->type == STT_FUNC ? "function" : "data",
2908 h->root.root.string);
2909 bfd_set_error (bfd_error_bad_value);
2914 /* Note that sgot is not involved in this
2915 calculation. We always want the start of .got.plt. If we
2916 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
2917 permitted by the ABI, we might have to change this
2919 relocation -= htab->elf.sgotplt->output_section->vma
2920 + htab->elf.sgotplt->output_offset;
2923 case R_X86_64_GOTPC32:
2924 case R_X86_64_GOTPC64:
2925 /* Use global offset table as symbol value. */
2926 relocation = htab->elf.sgotplt->output_section->vma
2927 + htab->elf.sgotplt->output_offset;
2928 unresolved_reloc = FALSE;
2931 case R_X86_64_PLTOFF64:
2932 /* Relocation is PLT entry relative to GOT. For local
2933 symbols it's the symbol itself relative to GOT. */
2935 /* See PLT32 handling. */
2936 && (h->plt.offset != (bfd_vma) -1
2937 || eh->plt_got.offset != (bfd_vma) -1)
2938 && htab->elf.splt != NULL)
2940 if (eh->plt_got.offset != (bfd_vma) -1)
2942 /* Use the GOT PLT. */
2943 resolved_plt = htab->plt_got;
2944 plt_offset = eh->plt_got.offset;
2946 else if (htab->plt_second != NULL)
2948 resolved_plt = htab->plt_second;
2949 plt_offset = eh->plt_second.offset;
2953 resolved_plt = htab->elf.splt;
2954 plt_offset = h->plt.offset;
2957 relocation = (resolved_plt->output_section->vma
2958 + resolved_plt->output_offset
2960 unresolved_reloc = FALSE;
2963 relocation -= htab->elf.sgotplt->output_section->vma
2964 + htab->elf.sgotplt->output_offset;
2967 case R_X86_64_PLT32:
2968 case R_X86_64_PLT32_BND:
2969 /* Relocation is to the entry for this symbol in the
2970 procedure linkage table. */
2972 /* Resolve a PLT32 reloc against a local symbol directly,
2973 without using the procedure linkage table. */
2977 if ((h->plt.offset == (bfd_vma) -1
2978 && eh->plt_got.offset == (bfd_vma) -1)
2979 || htab->elf.splt == NULL)
2981 /* We didn't make a PLT entry for this symbol. This
2982 happens when statically linking PIC code, or when
2983 using -Bsymbolic. */
2988 if (h->plt.offset != (bfd_vma) -1)
2990 if (htab->plt_second != NULL)
2992 resolved_plt = htab->plt_second;
2993 plt_offset = eh->plt_second.offset;
2997 resolved_plt = htab->elf.splt;
2998 plt_offset = h->plt.offset;
3003 /* Use the GOT PLT. */
3004 resolved_plt = htab->plt_got;
3005 plt_offset = eh->plt_got.offset;
3008 relocation = (resolved_plt->output_section->vma
3009 + resolved_plt->output_offset
3011 unresolved_reloc = FALSE;
3014 case R_X86_64_SIZE32:
3015 case R_X86_64_SIZE64:
3016 /* Set to symbol size. */
3017 relocation = st_size;
3023 case R_X86_64_PC32_BND:
3024 /* Don't complain about -fPIC if the symbol is undefined when
3025 building executable unless it is unresolved weak symbol,
3026 references a dynamic definition in PIE or -z nocopyreloc
3028 if ((input_section->flags & SEC_ALLOC) != 0
3029 && (input_section->flags & SEC_READONLY) != 0
3031 && ((bfd_link_executable (info)
3032 && ((h->root.type == bfd_link_hash_undefweak
3033 && !resolved_to_zero)
3034 || (bfd_link_pie (info)
3037 || ((info->nocopyreloc
3038 || (eh->def_protected
3039 && elf_has_no_copy_on_protected (h->root.u.def.section->owner)))
3041 && !(h->root.u.def.section->flags & SEC_CODE))))
3042 || bfd_link_dll (info)))
3044 bfd_boolean fail = FALSE;
3045 if (SYMBOL_REFERENCES_LOCAL_P (info, h))
3047 /* Symbol is referenced locally. Make sure it is
3049 fail = !(h->def_regular || ELF_COMMON_DEF_P (h));
3051 else if (!(bfd_link_pie (info)
3052 && (h->needs_copy || eh->needs_copy)))
3054 /* Symbol doesn't need copy reloc and isn't referenced
3055 locally. Address of protected function may not be
3056 reachable at run-time. */
3057 fail = (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3058 || (ELF_ST_VISIBILITY (h->other) == STV_PROTECTED
3059 && h->type == STT_FUNC));
3063 return elf_x86_64_need_pic (info, input_bfd, input_section,
3064 h, NULL, NULL, howto);
3066 /* Since x86-64 has PC-relative PLT, we can use PLT in PIE
3067 as function address. */
3069 && (input_section->flags & SEC_CODE) == 0
3070 && bfd_link_pie (info)
3071 && h->type == STT_FUNC
3082 /* FIXME: The ABI says the linker should make sure the value is
3083 the same when it's zeroextended to 64 bit. */
3086 if ((input_section->flags & SEC_ALLOC) == 0)
3089 need_copy_reloc_in_pie = (bfd_link_pie (info)
3094 == bfd_link_hash_undefined))
3095 && (X86_PCREL_TYPE_P (r_type)
3096 || X86_SIZE_TYPE_P (r_type)));
3098 if (GENERATE_DYNAMIC_RELOCATION_P (info, eh, r_type,
3099 need_copy_reloc_in_pie,
3100 resolved_to_zero, FALSE))
3102 Elf_Internal_Rela outrel;
3103 bfd_boolean skip, relocate;
3106 /* When generating a shared object, these relocations
3107 are copied into the output file to be resolved at run
3113 _bfd_elf_section_offset (output_bfd, info, input_section,
3115 if (outrel.r_offset == (bfd_vma) -1)
3117 else if (outrel.r_offset == (bfd_vma) -2)
3118 skip = TRUE, relocate = TRUE;
3120 outrel.r_offset += (input_section->output_section->vma
3121 + input_section->output_offset);
3124 memset (&outrel, 0, sizeof outrel);
3126 else if (COPY_INPUT_RELOC_P (info, h, r_type))
3128 outrel.r_info = htab->r_info (h->dynindx, r_type);
3129 outrel.r_addend = rel->r_addend;
3133 /* This symbol is local, or marked to become local.
3134 When relocation overflow check is disabled, we
3135 convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */
3136 if (r_type == htab->pointer_r_type
3137 || (r_type == R_X86_64_32
3138 && info->no_reloc_overflow_check))
3141 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
3142 outrel.r_addend = relocation + rel->r_addend;
3144 else if (r_type == R_X86_64_64
3145 && !ABI_64_P (output_bfd))
3148 outrel.r_info = htab->r_info (0,
3149 R_X86_64_RELATIVE64);
3150 outrel.r_addend = relocation + rel->r_addend;
3151 /* Check addend overflow. */
3152 if ((outrel.r_addend & 0x80000000)
3153 != (rel->r_addend & 0x80000000))
3156 int addend = rel->r_addend;
3157 if (h && h->root.root.string)
3158 name = h->root.root.string;
3160 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
3163 /* xgettext:c-format */
3164 (_("%pB: addend %s%#x in relocation %s against "
3165 "symbol `%s' at %#" PRIx64
3166 " in section `%pA' is out of range"),
3167 input_bfd, addend < 0 ? "-" : "", addend,
3168 howto->name, name, (uint64_t) rel->r_offset,
3170 bfd_set_error (bfd_error_bad_value);
3178 if (bfd_is_abs_section (sec))
3180 else if (sec == NULL || sec->owner == NULL)
3182 bfd_set_error (bfd_error_bad_value);
3189 /* We are turning this relocation into one
3190 against a section symbol. It would be
3191 proper to subtract the symbol's value,
3192 osec->vma, from the emitted reloc addend,
3193 but ld.so expects buggy relocs. */
3194 osec = sec->output_section;
3195 sindx = elf_section_data (osec)->dynindx;
3198 asection *oi = htab->elf.text_index_section;
3199 sindx = elf_section_data (oi)->dynindx;
3201 BFD_ASSERT (sindx != 0);
3204 outrel.r_info = htab->r_info (sindx, r_type);
3205 outrel.r_addend = relocation + rel->r_addend;
3209 sreloc = elf_section_data (input_section)->sreloc;
3211 if (sreloc == NULL || sreloc->contents == NULL)
3213 r = bfd_reloc_notsupported;
3214 goto check_relocation_error;
3217 elf_append_rela (output_bfd, sreloc, &outrel);
3219 /* If this reloc is against an external symbol, we do
3220 not want to fiddle with the addend. Otherwise, we
3221 need to include the symbol value so that it becomes
3222 an addend for the dynamic reloc. */
3229 case R_X86_64_TLSGD:
3230 case R_X86_64_GOTPC32_TLSDESC:
3231 case R_X86_64_TLSDESC_CALL:
3232 case R_X86_64_GOTTPOFF:
3233 tls_type = GOT_UNKNOWN;
3234 if (h == NULL && local_got_offsets)
3235 tls_type = elf_x86_local_got_tls_type (input_bfd) [r_symndx];
3237 tls_type = elf_x86_hash_entry (h)->tls_type;
3239 r_type_tls = r_type;
3240 if (! elf_x86_64_tls_transition (info, input_bfd,
3241 input_section, contents,
3242 symtab_hdr, sym_hashes,
3243 &r_type_tls, tls_type, rel,
3244 relend, h, r_symndx, TRUE))
3247 if (r_type_tls == R_X86_64_TPOFF32)
3249 bfd_vma roff = rel->r_offset;
3251 BFD_ASSERT (! unresolved_reloc);
3253 if (r_type == R_X86_64_TLSGD)
3255 /* GD->LE transition. For 64bit, change
3256 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3257 .word 0x6666; rex64; call __tls_get_addr@PLT
3259 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3261 call *__tls_get_addr@GOTPCREL(%rip)
3262 which may be converted to
3263 addr32 call __tls_get_addr
3266 leaq foo@tpoff(%rax), %rax
3268 leaq foo@tlsgd(%rip), %rdi
3269 .word 0x6666; rex64; call __tls_get_addr@PLT
3271 leaq foo@tlsgd(%rip), %rdi
3273 call *__tls_get_addr@GOTPCREL(%rip)
3274 which may be converted to
3275 addr32 call __tls_get_addr
3278 leaq foo@tpoff(%rax), %rax
3279 For largepic, change:
3280 leaq foo@tlsgd(%rip), %rdi
3281 movabsq $__tls_get_addr@pltoff, %rax
3286 leaq foo@tpoff(%rax), %rax
3287 nopw 0x0(%rax,%rax,1) */
3289 if (ABI_64_P (output_bfd))
3291 if (contents[roff + 5] == 0xb8)
3293 memcpy (contents + roff - 3,
3294 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
3295 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
3299 memcpy (contents + roff - 4,
3300 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3304 memcpy (contents + roff - 3,
3305 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3307 bfd_put_32 (output_bfd,
3308 elf_x86_64_tpoff (info, relocation),
3309 contents + roff + 8 + largepic);
3310 /* Skip R_X86_64_PC32, R_X86_64_PLT32,
3311 R_X86_64_GOTPCRELX and R_X86_64_PLTOFF64. */
3316 else if (r_type == R_X86_64_GOTPC32_TLSDESC)
3318 /* GDesc -> LE transition.
3319 It's originally something like:
3320 leaq x@tlsdesc(%rip), %rax
3323 movl $x@tpoff, %rax. */
3325 unsigned int val, type;
3327 type = bfd_get_8 (input_bfd, contents + roff - 3);
3328 val = bfd_get_8 (input_bfd, contents + roff - 1);
3329 bfd_put_8 (output_bfd, 0x48 | ((type >> 2) & 1),
3330 contents + roff - 3);
3331 bfd_put_8 (output_bfd, 0xc7, contents + roff - 2);
3332 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3333 contents + roff - 1);
3334 bfd_put_32 (output_bfd,
3335 elf_x86_64_tpoff (info, relocation),
3339 else if (r_type == R_X86_64_TLSDESC_CALL)
3341 /* GDesc -> LE transition.
3346 bfd_put_8 (output_bfd, 0x66, contents + roff);
3347 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3350 else if (r_type == R_X86_64_GOTTPOFF)
3352 /* IE->LE transition:
3353 For 64bit, originally it can be one of:
3354 movq foo@gottpoff(%rip), %reg
3355 addq foo@gottpoff(%rip), %reg
3358 leaq foo(%reg), %reg
3360 For 32bit, originally it can be one of:
3361 movq foo@gottpoff(%rip), %reg
3362 addl foo@gottpoff(%rip), %reg
3365 leal foo(%reg), %reg
3368 unsigned int val, type, reg;
3371 val = bfd_get_8 (input_bfd, contents + roff - 3);
3374 type = bfd_get_8 (input_bfd, contents + roff - 2);
3375 reg = bfd_get_8 (input_bfd, contents + roff - 1);
3381 bfd_put_8 (output_bfd, 0x49,
3382 contents + roff - 3);
3383 else if (!ABI_64_P (output_bfd) && val == 0x44)
3384 bfd_put_8 (output_bfd, 0x41,
3385 contents + roff - 3);
3386 bfd_put_8 (output_bfd, 0xc7,
3387 contents + roff - 2);
3388 bfd_put_8 (output_bfd, 0xc0 | reg,
3389 contents + roff - 1);
3393 /* addq/addl -> addq/addl - addressing with %rsp/%r12
3396 bfd_put_8 (output_bfd, 0x49,
3397 contents + roff - 3);
3398 else if (!ABI_64_P (output_bfd) && val == 0x44)
3399 bfd_put_8 (output_bfd, 0x41,
3400 contents + roff - 3);
3401 bfd_put_8 (output_bfd, 0x81,
3402 contents + roff - 2);
3403 bfd_put_8 (output_bfd, 0xc0 | reg,
3404 contents + roff - 1);
3408 /* addq/addl -> leaq/leal */
3410 bfd_put_8 (output_bfd, 0x4d,
3411 contents + roff - 3);
3412 else if (!ABI_64_P (output_bfd) && val == 0x44)
3413 bfd_put_8 (output_bfd, 0x45,
3414 contents + roff - 3);
3415 bfd_put_8 (output_bfd, 0x8d,
3416 contents + roff - 2);
3417 bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
3418 contents + roff - 1);
3420 bfd_put_32 (output_bfd,
3421 elf_x86_64_tpoff (info, relocation),
3429 if (htab->elf.sgot == NULL)
3434 off = h->got.offset;
3435 offplt = elf_x86_hash_entry (h)->tlsdesc_got;
3439 if (local_got_offsets == NULL)
3442 off = local_got_offsets[r_symndx];
3443 offplt = local_tlsdesc_gotents[r_symndx];
3450 Elf_Internal_Rela outrel;
3454 if (htab->elf.srelgot == NULL)
3457 indx = h && h->dynindx != -1 ? h->dynindx : 0;
3459 if (GOT_TLS_GDESC_P (tls_type))
3461 outrel.r_info = htab->r_info (indx, R_X86_64_TLSDESC);
3462 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt
3463 + 2 * GOT_ENTRY_SIZE <= htab->elf.sgotplt->size);
3464 outrel.r_offset = (htab->elf.sgotplt->output_section->vma
3465 + htab->elf.sgotplt->output_offset
3467 + htab->sgotplt_jump_table_size);
3468 sreloc = htab->elf.srelplt;
3470 outrel.r_addend = relocation - _bfd_x86_elf_dtpoff_base (info);
3472 outrel.r_addend = 0;
3473 elf_append_rela (output_bfd, sreloc, &outrel);
3476 sreloc = htab->elf.srelgot;
3478 outrel.r_offset = (htab->elf.sgot->output_section->vma
3479 + htab->elf.sgot->output_offset + off);
3481 if (GOT_TLS_GD_P (tls_type))
3482 dr_type = R_X86_64_DTPMOD64;
3483 else if (GOT_TLS_GDESC_P (tls_type))
3486 dr_type = R_X86_64_TPOFF64;
3488 bfd_put_64 (output_bfd, 0, htab->elf.sgot->contents + off);
3489 outrel.r_addend = 0;
3490 if ((dr_type == R_X86_64_TPOFF64
3491 || dr_type == R_X86_64_TLSDESC) && indx == 0)
3492 outrel.r_addend = relocation - _bfd_x86_elf_dtpoff_base (info);
3493 outrel.r_info = htab->r_info (indx, dr_type);
3495 elf_append_rela (output_bfd, sreloc, &outrel);
3497 if (GOT_TLS_GD_P (tls_type))
3501 BFD_ASSERT (! unresolved_reloc);
3502 bfd_put_64 (output_bfd,
3503 relocation - _bfd_x86_elf_dtpoff_base (info),
3504 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3508 bfd_put_64 (output_bfd, 0,
3509 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3510 outrel.r_info = htab->r_info (indx,
3512 outrel.r_offset += GOT_ENTRY_SIZE;
3513 elf_append_rela (output_bfd, sreloc,
3522 local_got_offsets[r_symndx] |= 1;
3525 if (off >= (bfd_vma) -2
3526 && ! GOT_TLS_GDESC_P (tls_type))
3528 if (r_type_tls == r_type)
3530 if (r_type == R_X86_64_GOTPC32_TLSDESC
3531 || r_type == R_X86_64_TLSDESC_CALL)
3532 relocation = htab->elf.sgotplt->output_section->vma
3533 + htab->elf.sgotplt->output_offset
3534 + offplt + htab->sgotplt_jump_table_size;
3536 relocation = htab->elf.sgot->output_section->vma
3537 + htab->elf.sgot->output_offset + off;
3538 unresolved_reloc = FALSE;
3542 bfd_vma roff = rel->r_offset;
3544 if (r_type == R_X86_64_TLSGD)
3546 /* GD->IE transition. For 64bit, change
3547 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3548 .word 0x6666; rex64; call __tls_get_addr@PLT
3550 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3552 call *__tls_get_addr@GOTPCREL(%rip
3553 which may be converted to
3554 addr32 call __tls_get_addr
3557 addq foo@gottpoff(%rip), %rax
3559 leaq foo@tlsgd(%rip), %rdi
3560 .word 0x6666; rex64; call __tls_get_addr@PLT
3562 leaq foo@tlsgd(%rip), %rdi
3564 call *__tls_get_addr@GOTPCREL(%rip)
3565 which may be converted to
3566 addr32 call __tls_get_addr
3569 addq foo@gottpoff(%rip), %rax
3570 For largepic, change:
3571 leaq foo@tlsgd(%rip), %rdi
3572 movabsq $__tls_get_addr@pltoff, %rax
3577 addq foo@gottpoff(%rax), %rax
3578 nopw 0x0(%rax,%rax,1) */
3580 if (ABI_64_P (output_bfd))
3582 if (contents[roff + 5] == 0xb8)
3584 memcpy (contents + roff - 3,
3585 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
3586 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
3590 memcpy (contents + roff - 4,
3591 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
3595 memcpy (contents + roff - 3,
3596 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
3599 relocation = (htab->elf.sgot->output_section->vma
3600 + htab->elf.sgot->output_offset + off
3603 - input_section->output_section->vma
3604 - input_section->output_offset
3606 bfd_put_32 (output_bfd, relocation,
3607 contents + roff + 8 + largepic);
3608 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
3613 else if (r_type == R_X86_64_GOTPC32_TLSDESC)
3615 /* GDesc -> IE transition.
3616 It's originally something like:
3617 leaq x@tlsdesc(%rip), %rax
3620 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
3622 /* Now modify the instruction as appropriate. To
3623 turn a leaq into a movq in the form we use it, it
3624 suffices to change the second byte from 0x8d to
3626 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
3628 bfd_put_32 (output_bfd,
3629 htab->elf.sgot->output_section->vma
3630 + htab->elf.sgot->output_offset + off
3632 - input_section->output_section->vma
3633 - input_section->output_offset
3638 else if (r_type == R_X86_64_TLSDESC_CALL)
3640 /* GDesc -> IE transition.
3647 bfd_put_8 (output_bfd, 0x66, contents + roff);
3648 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3656 case R_X86_64_TLSLD:
3657 if (! elf_x86_64_tls_transition (info, input_bfd,
3658 input_section, contents,
3659 symtab_hdr, sym_hashes,
3660 &r_type, GOT_UNKNOWN, rel,
3661 relend, h, r_symndx, TRUE))
3664 if (r_type != R_X86_64_TLSLD)
3666 /* LD->LE transition:
3667 leaq foo@tlsld(%rip), %rdi
3668 call __tls_get_addr@PLT
3669 For 64bit, we change it into:
3670 .word 0x6666; .byte 0x66; movq %fs:0, %rax
3671 For 32bit, we change it into:
3672 nopl 0x0(%rax); movl %fs:0, %eax
3674 leaq foo@tlsld(%rip), %rdi;
3675 call *__tls_get_addr@GOTPCREL(%rip)
3676 which may be converted to
3677 addr32 call __tls_get_addr
3678 For 64bit, we change it into:
3679 .word 0x6666; .word 0x6666; movq %fs:0, %rax
3680 For 32bit, we change it into:
3681 nopw 0x0(%rax); movl %fs:0, %eax
3682 For largepic, change:
3683 leaq foo@tlsgd(%rip), %rdi
3684 movabsq $__tls_get_addr@pltoff, %rax
3688 data16 data16 data16 nopw %cs:0x0(%rax,%rax,1)
3691 BFD_ASSERT (r_type == R_X86_64_TPOFF32);
3692 if (ABI_64_P (output_bfd))
3694 if (contents[rel->r_offset + 5] == 0xb8)
3695 memcpy (contents + rel->r_offset - 3,
3696 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
3697 "\x64\x48\x8b\x04\x25\0\0\0", 22);
3698 else if (contents[rel->r_offset + 4] == 0xff
3699 || contents[rel->r_offset + 4] == 0x67)
3700 memcpy (contents + rel->r_offset - 3,
3701 "\x66\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0",
3704 memcpy (contents + rel->r_offset - 3,
3705 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
3709 if (contents[rel->r_offset + 4] == 0xff)
3710 memcpy (contents + rel->r_offset - 3,
3711 "\x66\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0",
3714 memcpy (contents + rel->r_offset - 3,
3715 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
3717 /* Skip R_X86_64_PC32, R_X86_64_PLT32, R_X86_64_GOTPCRELX
3718 and R_X86_64_PLTOFF64. */
3724 if (htab->elf.sgot == NULL)
3727 off = htab->tls_ld_or_ldm_got.offset;
3732 Elf_Internal_Rela outrel;
3734 if (htab->elf.srelgot == NULL)
3737 outrel.r_offset = (htab->elf.sgot->output_section->vma
3738 + htab->elf.sgot->output_offset + off);
3740 bfd_put_64 (output_bfd, 0,
3741 htab->elf.sgot->contents + off);
3742 bfd_put_64 (output_bfd, 0,
3743 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3744 outrel.r_info = htab->r_info (0, R_X86_64_DTPMOD64);
3745 outrel.r_addend = 0;
3746 elf_append_rela (output_bfd, htab->elf.srelgot,
3748 htab->tls_ld_or_ldm_got.offset |= 1;
3750 relocation = htab->elf.sgot->output_section->vma
3751 + htab->elf.sgot->output_offset + off;
3752 unresolved_reloc = FALSE;
3755 case R_X86_64_DTPOFF32:
3756 if (!bfd_link_executable (info)
3757 || (input_section->flags & SEC_CODE) == 0)
3758 relocation -= _bfd_x86_elf_dtpoff_base (info);
3760 relocation = elf_x86_64_tpoff (info, relocation);
3763 case R_X86_64_TPOFF32:
3764 case R_X86_64_TPOFF64:
3765 BFD_ASSERT (bfd_link_executable (info));
3766 relocation = elf_x86_64_tpoff (info, relocation);
3769 case R_X86_64_DTPOFF64:
3770 BFD_ASSERT ((input_section->flags & SEC_CODE) == 0);
3771 relocation -= _bfd_x86_elf_dtpoff_base (info);
3778 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3779 because such sections are not SEC_ALLOC and thus ld.so will
3780 not process them. */
3781 if (unresolved_reloc
3782 && !((input_section->flags & SEC_DEBUGGING) != 0
3784 && _bfd_elf_section_offset (output_bfd, info, input_section,
3785 rel->r_offset) != (bfd_vma) -1)
3790 sec = h->root.u.def.section;
3791 if ((info->nocopyreloc
3792 || (eh->def_protected
3793 && elf_has_no_copy_on_protected (h->root.u.def.section->owner)))
3794 && !(h->root.u.def.section->flags & SEC_CODE))
3795 return elf_x86_64_need_pic (info, input_bfd, input_section,
3796 h, NULL, NULL, howto);
3801 /* xgettext:c-format */
3802 (_("%pB(%pA+%#" PRIx64 "): "
3803 "unresolvable %s relocation against symbol `%s'"),
3806 (uint64_t) rel->r_offset,
3808 h->root.root.string);
3814 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3815 contents, rel->r_offset,
3816 relocation, rel->r_addend);
3818 check_relocation_error:
3819 if (r != bfd_reloc_ok)
3824 name = h->root.root.string;
3827 name = bfd_elf_string_from_elf_section (input_bfd,
3828 symtab_hdr->sh_link,
3833 name = bfd_section_name (input_bfd, sec);
3836 if (r == bfd_reloc_overflow)
3838 if (converted_reloc)
3840 info->callbacks->einfo
3841 (_("%F%P: failed to convert GOTPCREL relocation; relink with --no-relax\n"));
3844 (*info->callbacks->reloc_overflow)
3845 (info, (h ? &h->root : NULL), name, howto->name,
3846 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
3851 /* xgettext:c-format */
3852 (_("%pB(%pA+%#" PRIx64 "): reloc against `%s': error %d"),
3853 input_bfd, input_section,
3854 (uint64_t) rel->r_offset, name, (int) r);
3865 Elf_Internal_Shdr *rel_hdr;
3866 size_t deleted = rel - wrel;
3868 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
3869 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
3870 if (rel_hdr->sh_size == 0)
3872 /* It is too late to remove an empty reloc section. Leave
3874 ??? What is wrong with an empty section??? */
3875 rel_hdr->sh_size = rel_hdr->sh_entsize;
3878 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
3879 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
3880 input_section->reloc_count -= deleted;
3886 /* Finish up dynamic symbol handling. We set the contents of various
3887 dynamic sections here. */
3890 elf_x86_64_finish_dynamic_symbol (bfd *output_bfd,
3891 struct bfd_link_info *info,
3892 struct elf_link_hash_entry *h,
3893 Elf_Internal_Sym *sym)
3895 struct elf_x86_link_hash_table *htab;
3896 bfd_boolean use_plt_second;
3897 struct elf_x86_link_hash_entry *eh;
3898 bfd_boolean local_undefweak;
3900 htab = elf_x86_hash_table (info, X86_64_ELF_DATA);
3904 /* Use the second PLT section only if there is .plt section. */
3905 use_plt_second = htab->elf.splt != NULL && htab->plt_second != NULL;
3907 eh = (struct elf_x86_link_hash_entry *) h;
3908 if (eh->no_finish_dynamic_symbol)
3911 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
3912 resolved undefined weak symbols in executable so that their
3913 references have value 0 at run-time. */
3914 local_undefweak = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info, eh);
3916 if (h->plt.offset != (bfd_vma) -1)
3919 bfd_vma got_offset, plt_offset;
3920 Elf_Internal_Rela rela;
3922 asection *plt, *gotplt, *relplt, *resolved_plt;
3923 const struct elf_backend_data *bed;
3924 bfd_vma plt_got_pcrel_offset;
3926 /* When building a static executable, use .iplt, .igot.plt and
3927 .rela.iplt sections for STT_GNU_IFUNC symbols. */
3928 if (htab->elf.splt != NULL)
3930 plt = htab->elf.splt;
3931 gotplt = htab->elf.sgotplt;
3932 relplt = htab->elf.srelplt;
3936 plt = htab->elf.iplt;
3937 gotplt = htab->elf.igotplt;
3938 relplt = htab->elf.irelplt;
3941 VERIFY_PLT_ENTRY (info, h, plt, gotplt, relplt, local_undefweak)
3943 /* Get the index in the procedure linkage table which
3944 corresponds to this symbol. This is the index of this symbol
3945 in all the symbols for which we are making plt entries. The
3946 first entry in the procedure linkage table is reserved.
3948 Get the offset into the .got table of the entry that
3949 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
3950 bytes. The first three are reserved for the dynamic linker.
3952 For static executables, we don't reserve anything. */
3954 if (plt == htab->elf.splt)
3956 got_offset = (h->plt.offset / htab->plt.plt_entry_size
3957 - htab->plt.has_plt0);
3958 got_offset = (got_offset + 3) * GOT_ENTRY_SIZE;
3962 got_offset = h->plt.offset / htab->plt.plt_entry_size;
3963 got_offset = got_offset * GOT_ENTRY_SIZE;
3966 /* Fill in the entry in the procedure linkage table. */
3967 memcpy (plt->contents + h->plt.offset, htab->plt.plt_entry,
3968 htab->plt.plt_entry_size);
3971 memcpy (htab->plt_second->contents + eh->plt_second.offset,
3972 htab->non_lazy_plt->plt_entry,
3973 htab->non_lazy_plt->plt_entry_size);
3975 resolved_plt = htab->plt_second;
3976 plt_offset = eh->plt_second.offset;
3981 plt_offset = h->plt.offset;
3984 /* Insert the relocation positions of the plt section. */
3986 /* Put offset the PC-relative instruction referring to the GOT entry,
3987 subtracting the size of that instruction. */
3988 plt_got_pcrel_offset = (gotplt->output_section->vma
3989 + gotplt->output_offset
3991 - resolved_plt->output_section->vma
3992 - resolved_plt->output_offset
3994 - htab->plt.plt_got_insn_size);
3996 /* Check PC-relative offset overflow in PLT entry. */
3997 if ((plt_got_pcrel_offset + 0x80000000) > 0xffffffff)
3998 /* xgettext:c-format */
3999 info->callbacks->einfo (_("%F%pB: PC-relative offset overflow in PLT entry for `%s'\n"),
4000 output_bfd, h->root.root.string);
4002 bfd_put_32 (output_bfd, plt_got_pcrel_offset,
4003 (resolved_plt->contents + plt_offset
4004 + htab->plt.plt_got_offset));
4006 /* Fill in the entry in the global offset table, initially this
4007 points to the second part of the PLT entry. Leave the entry
4008 as zero for undefined weak symbol in PIE. No PLT relocation
4009 against undefined weak symbol in PIE. */
4010 if (!local_undefweak)
4012 if (htab->plt.has_plt0)
4013 bfd_put_64 (output_bfd, (plt->output_section->vma
4014 + plt->output_offset
4016 + htab->lazy_plt->plt_lazy_offset),
4017 gotplt->contents + got_offset);
4019 /* Fill in the entry in the .rela.plt section. */
4020 rela.r_offset = (gotplt->output_section->vma
4021 + gotplt->output_offset
4023 if (PLT_LOCAL_IFUNC_P (info, h))
4025 info->callbacks->minfo (_("Local IFUNC function `%s' in %pB\n"),
4026 h->root.root.string,
4027 h->root.u.def.section->owner);
4029 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4030 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
4031 rela.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
4032 rela.r_addend = (h->root.u.def.value
4033 + h->root.u.def.section->output_section->vma
4034 + h->root.u.def.section->output_offset);
4035 /* R_X86_64_IRELATIVE comes last. */
4036 plt_index = htab->next_irelative_index--;
4040 rela.r_info = htab->r_info (h->dynindx, R_X86_64_JUMP_SLOT);
4042 plt_index = htab->next_jump_slot_index++;
4045 /* Don't fill the second and third slots in PLT entry for
4046 static executables nor without PLT0. */
4047 if (plt == htab->elf.splt && htab->plt.has_plt0)
4050 = h->plt.offset + htab->lazy_plt->plt_plt_insn_end;
4052 /* Put relocation index. */
4053 bfd_put_32 (output_bfd, plt_index,
4054 (plt->contents + h->plt.offset
4055 + htab->lazy_plt->plt_reloc_offset));
4057 /* Put offset for jmp .PLT0 and check for overflow. We don't
4058 check relocation index for overflow since branch displacement
4059 will overflow first. */
4060 if (plt0_offset > 0x80000000)
4061 /* xgettext:c-format */
4062 info->callbacks->einfo (_("%F%pB: branch displacement overflow in PLT entry for `%s'\n"),
4063 output_bfd, h->root.root.string);
4064 bfd_put_32 (output_bfd, - plt0_offset,
4065 (plt->contents + h->plt.offset
4066 + htab->lazy_plt->plt_plt_offset));
4069 bed = get_elf_backend_data (output_bfd);
4070 loc = relplt->contents + plt_index * bed->s->sizeof_rela;
4071 bed->s->swap_reloca_out (output_bfd, &rela, loc);
4074 else if (eh->plt_got.offset != (bfd_vma) -1)
4076 bfd_vma got_offset, plt_offset;
4077 asection *plt, *got;
4078 bfd_boolean got_after_plt;
4079 int32_t got_pcrel_offset;
4081 /* Set the entry in the GOT procedure linkage table. */
4082 plt = htab->plt_got;
4083 got = htab->elf.sgot;
4084 got_offset = h->got.offset;
4086 if (got_offset == (bfd_vma) -1
4087 || (h->type == STT_GNU_IFUNC && h->def_regular)
4092 /* Use the non-lazy PLT entry template for the GOT PLT since they
4093 are the identical. */
4094 /* Fill in the entry in the GOT procedure linkage table. */
4095 plt_offset = eh->plt_got.offset;
4096 memcpy (plt->contents + plt_offset,
4097 htab->non_lazy_plt->plt_entry,
4098 htab->non_lazy_plt->plt_entry_size);
4100 /* Put offset the PC-relative instruction referring to the GOT
4101 entry, subtracting the size of that instruction. */
4102 got_pcrel_offset = (got->output_section->vma
4103 + got->output_offset
4105 - plt->output_section->vma
4106 - plt->output_offset
4108 - htab->non_lazy_plt->plt_got_insn_size);
4110 /* Check PC-relative offset overflow in GOT PLT entry. */
4111 got_after_plt = got->output_section->vma > plt->output_section->vma;
4112 if ((got_after_plt && got_pcrel_offset < 0)
4113 || (!got_after_plt && got_pcrel_offset > 0))
4114 /* xgettext:c-format */
4115 info->callbacks->einfo (_("%F%pB: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
4116 output_bfd, h->root.root.string);
4118 bfd_put_32 (output_bfd, got_pcrel_offset,
4119 (plt->contents + plt_offset
4120 + htab->non_lazy_plt->plt_got_offset));
4123 if (!local_undefweak
4125 && (h->plt.offset != (bfd_vma) -1
4126 || eh->plt_got.offset != (bfd_vma) -1))
4128 /* Mark the symbol as undefined, rather than as defined in
4129 the .plt section. Leave the value if there were any
4130 relocations where pointer equality matters (this is a clue
4131 for the dynamic linker, to make function pointer
4132 comparisons work between an application and shared
4133 library), otherwise set it to zero. If a function is only
4134 called from a binary, there is no need to slow down
4135 shared libraries because of that. */
4136 sym->st_shndx = SHN_UNDEF;
4137 if (!h->pointer_equality_needed)
4141 /* Don't generate dynamic GOT relocation against undefined weak
4142 symbol in executable. */
4143 if (h->got.offset != (bfd_vma) -1
4144 && ! GOT_TLS_GD_ANY_P (elf_x86_hash_entry (h)->tls_type)
4145 && elf_x86_hash_entry (h)->tls_type != GOT_TLS_IE
4146 && !local_undefweak)
4148 Elf_Internal_Rela rela;
4149 asection *relgot = htab->elf.srelgot;
4151 /* This symbol has an entry in the global offset table. Set it
4153 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
4156 rela.r_offset = (htab->elf.sgot->output_section->vma
4157 + htab->elf.sgot->output_offset
4158 + (h->got.offset &~ (bfd_vma) 1));
4160 /* If this is a static link, or it is a -Bsymbolic link and the
4161 symbol is defined locally or was forced to be local because
4162 of a version file, we just want to emit a RELATIVE reloc.
4163 The entry in the global offset table will already have been
4164 initialized in the relocate_section function. */
4166 && h->type == STT_GNU_IFUNC)
4168 if (h->plt.offset == (bfd_vma) -1)
4170 /* STT_GNU_IFUNC is referenced without PLT. */
4171 if (htab->elf.splt == NULL)
4173 /* use .rel[a].iplt section to store .got relocations
4174 in static executable. */
4175 relgot = htab->elf.irelplt;
4177 if (SYMBOL_REFERENCES_LOCAL_P (info, h))
4179 info->callbacks->minfo (_("Local IFUNC function `%s' in %pB\n"),
4180 h->root.root.string,
4181 h->root.u.def.section->owner);
4183 rela.r_info = htab->r_info (0,
4184 R_X86_64_IRELATIVE);
4185 rela.r_addend = (h->root.u.def.value
4186 + h->root.u.def.section->output_section->vma
4187 + h->root.u.def.section->output_offset);
4192 else if (bfd_link_pic (info))
4194 /* Generate R_X86_64_GLOB_DAT. */
4202 if (!h->pointer_equality_needed)
4205 /* For non-shared object, we can't use .got.plt, which
4206 contains the real function addres if we need pointer
4207 equality. We load the GOT entry with the PLT entry. */
4208 if (htab->plt_second != NULL)
4210 plt = htab->plt_second;
4211 plt_offset = eh->plt_second.offset;
4215 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4216 plt_offset = h->plt.offset;
4218 bfd_put_64 (output_bfd, (plt->output_section->vma
4219 + plt->output_offset
4221 htab->elf.sgot->contents + h->got.offset);
4225 else if (bfd_link_pic (info)
4226 && SYMBOL_REFERENCES_LOCAL_P (info, h))
4228 if (!(h->def_regular || ELF_COMMON_DEF_P (h)))
4230 BFD_ASSERT((h->got.offset & 1) != 0);
4231 rela.r_info = htab->r_info (0, R_X86_64_RELATIVE);
4232 rela.r_addend = (h->root.u.def.value
4233 + h->root.u.def.section->output_section->vma
4234 + h->root.u.def.section->output_offset);
4238 BFD_ASSERT((h->got.offset & 1) == 0);
4240 bfd_put_64 (output_bfd, (bfd_vma) 0,
4241 htab->elf.sgot->contents + h->got.offset);
4242 rela.r_info = htab->r_info (h->dynindx, R_X86_64_GLOB_DAT);
4246 elf_append_rela (output_bfd, relgot, &rela);
4251 Elf_Internal_Rela rela;
4254 /* This symbol needs a copy reloc. Set it up. */
4255 VERIFY_COPY_RELOC (h, htab)
4257 rela.r_offset = (h->root.u.def.value
4258 + h->root.u.def.section->output_section->vma
4259 + h->root.u.def.section->output_offset);
4260 rela.r_info = htab->r_info (h->dynindx, R_X86_64_COPY);
4262 if (h->root.u.def.section == htab->elf.sdynrelro)
4263 s = htab->elf.sreldynrelro;
4265 s = htab->elf.srelbss;
4266 elf_append_rela (output_bfd, s, &rela);
4272 /* Finish up local dynamic symbol handling. We set the contents of
4273 various dynamic sections here. */
4276 elf_x86_64_finish_local_dynamic_symbol (void **slot, void *inf)
4278 struct elf_link_hash_entry *h
4279 = (struct elf_link_hash_entry *) *slot;
4280 struct bfd_link_info *info
4281 = (struct bfd_link_info *) inf;
4283 return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
4287 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
4288 here since undefined weak symbol may not be dynamic and may not be
4289 called for elf_x86_64_finish_dynamic_symbol. */
4292 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry *bh,
4295 struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
4296 struct bfd_link_info *info = (struct bfd_link_info *) inf;
4298 if (h->root.type != bfd_link_hash_undefweak
4299 || h->dynindx != -1)
4302 return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
4306 /* Used to decide how to sort relocs in an optimal manner for the
4307 dynamic linker, before writing them out. */
4309 static enum elf_reloc_type_class
4310 elf_x86_64_reloc_type_class (const struct bfd_link_info *info,
4311 const asection *rel_sec ATTRIBUTE_UNUSED,
4312 const Elf_Internal_Rela *rela)
4314 bfd *abfd = info->output_bfd;
4315 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4316 struct elf_x86_link_hash_table *htab
4317 = elf_x86_hash_table (info, X86_64_ELF_DATA);
4319 if (htab->elf.dynsym != NULL
4320 && htab->elf.dynsym->contents != NULL)
4322 /* Check relocation against STT_GNU_IFUNC symbol if there are
4324 unsigned long r_symndx = htab->r_sym (rela->r_info);
4325 if (r_symndx != STN_UNDEF)
4327 Elf_Internal_Sym sym;
4328 if (!bed->s->swap_symbol_in (abfd,
4329 (htab->elf.dynsym->contents
4330 + r_symndx * bed->s->sizeof_sym),
4334 if (ELF_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
4335 return reloc_class_ifunc;
4339 switch ((int) ELF32_R_TYPE (rela->r_info))
4341 case R_X86_64_IRELATIVE:
4342 return reloc_class_ifunc;
4343 case R_X86_64_RELATIVE:
4344 case R_X86_64_RELATIVE64:
4345 return reloc_class_relative;
4346 case R_X86_64_JUMP_SLOT:
4347 return reloc_class_plt;
4349 return reloc_class_copy;
4351 return reloc_class_normal;
4355 /* Finish up the dynamic sections. */
4358 elf_x86_64_finish_dynamic_sections (bfd *output_bfd,
4359 struct bfd_link_info *info)
4361 struct elf_x86_link_hash_table *htab;
4363 htab = _bfd_x86_elf_finish_dynamic_sections (output_bfd, info);
4367 if (! htab->elf.dynamic_sections_created)
4370 if (htab->elf.splt && htab->elf.splt->size > 0)
4372 elf_section_data (htab->elf.splt->output_section)
4373 ->this_hdr.sh_entsize = htab->plt.plt_entry_size;
4375 if (htab->plt.has_plt0)
4377 /* Fill in the special first entry in the procedure linkage
4379 memcpy (htab->elf.splt->contents,
4380 htab->lazy_plt->plt0_entry,
4381 htab->lazy_plt->plt0_entry_size);
4382 /* Add offset for pushq GOT+8(%rip), since the instruction
4383 uses 6 bytes subtract this value. */
4384 bfd_put_32 (output_bfd,
4385 (htab->elf.sgotplt->output_section->vma
4386 + htab->elf.sgotplt->output_offset
4388 - htab->elf.splt->output_section->vma
4389 - htab->elf.splt->output_offset
4391 (htab->elf.splt->contents
4392 + htab->lazy_plt->plt0_got1_offset));
4393 /* Add offset for the PC-relative instruction accessing
4394 GOT+16, subtracting the offset to the end of that
4396 bfd_put_32 (output_bfd,
4397 (htab->elf.sgotplt->output_section->vma
4398 + htab->elf.sgotplt->output_offset
4400 - htab->elf.splt->output_section->vma
4401 - htab->elf.splt->output_offset
4402 - htab->lazy_plt->plt0_got2_insn_end),
4403 (htab->elf.splt->contents
4404 + htab->lazy_plt->plt0_got2_offset));
4407 if (htab->tlsdesc_plt)
4409 bfd_put_64 (output_bfd, (bfd_vma) 0,
4410 htab->elf.sgot->contents + htab->tlsdesc_got);
4412 memcpy (htab->elf.splt->contents + htab->tlsdesc_plt,
4413 htab->lazy_plt->plt0_entry,
4414 htab->lazy_plt->plt0_entry_size);
4416 /* Add offset for pushq GOT+8(%rip), since the
4417 instruction uses 6 bytes subtract this value. */
4418 bfd_put_32 (output_bfd,
4419 (htab->elf.sgotplt->output_section->vma
4420 + htab->elf.sgotplt->output_offset
4422 - htab->elf.splt->output_section->vma
4423 - htab->elf.splt->output_offset
4426 (htab->elf.splt->contents
4428 + htab->lazy_plt->plt0_got1_offset));
4429 /* Add offset for the PC-relative instruction accessing
4430 GOT+TDG, where TDG stands for htab->tlsdesc_got,
4431 subtracting the offset to the end of that
4433 bfd_put_32 (output_bfd,
4434 (htab->elf.sgot->output_section->vma
4435 + htab->elf.sgot->output_offset
4437 - htab->elf.splt->output_section->vma
4438 - htab->elf.splt->output_offset
4440 - htab->lazy_plt->plt0_got2_insn_end),
4441 (htab->elf.splt->contents
4443 + htab->lazy_plt->plt0_got2_offset));
4447 /* Fill PLT entries for undefined weak symbols in PIE. */
4448 if (bfd_link_pie (info))
4449 bfd_hash_traverse (&info->hash->table,
4450 elf_x86_64_pie_finish_undefweak_symbol,
4456 /* Fill PLT/GOT entries and allocate dynamic relocations for local
4457 STT_GNU_IFUNC symbols, which aren't in the ELF linker hash table.
4458 It has to be done before elf_link_sort_relocs is called so that
4459 dynamic relocations are properly sorted. */
4462 elf_x86_64_output_arch_local_syms
4463 (bfd *output_bfd ATTRIBUTE_UNUSED,
4464 struct bfd_link_info *info,
4465 void *flaginfo ATTRIBUTE_UNUSED,
4466 int (*func) (void *, const char *,
4469 struct elf_link_hash_entry *) ATTRIBUTE_UNUSED)
4471 struct elf_x86_link_hash_table *htab
4472 = elf_x86_hash_table (info, X86_64_ELF_DATA);
4476 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4477 htab_traverse (htab->loc_hash_table,
4478 elf_x86_64_finish_local_dynamic_symbol,
4484 /* Forward declaration. */
4485 static const struct elf_x86_lazy_plt_layout elf_x86_64_nacl_plt;
4487 /* Similar to _bfd_elf_get_synthetic_symtab. Support PLTs with all
4488 dynamic relocations. */
4491 elf_x86_64_get_synthetic_symtab (bfd *abfd,
4492 long symcount ATTRIBUTE_UNUSED,
4493 asymbol **syms ATTRIBUTE_UNUSED,
4500 bfd_byte *plt_contents;
4502 const struct elf_x86_lazy_plt_layout *lazy_plt;
4503 const struct elf_x86_non_lazy_plt_layout *non_lazy_plt;
4504 const struct elf_x86_lazy_plt_layout *lazy_bnd_plt;
4505 const struct elf_x86_non_lazy_plt_layout *non_lazy_bnd_plt;
4506 const struct elf_x86_lazy_plt_layout *lazy_ibt_plt;
4507 const struct elf_x86_non_lazy_plt_layout *non_lazy_ibt_plt;
4509 enum elf_x86_plt_type plt_type;
4510 struct elf_x86_plt plts[] =
4512 { ".plt", NULL, NULL, plt_unknown, 0, 0, 0, 0 },
4513 { ".plt.got", NULL, NULL, plt_non_lazy, 0, 0, 0, 0 },
4514 { ".plt.sec", NULL, NULL, plt_second, 0, 0, 0, 0 },
4515 { ".plt.bnd", NULL, NULL, plt_second, 0, 0, 0, 0 },
4516 { NULL, NULL, NULL, plt_non_lazy, 0, 0, 0, 0 }
4521 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
4524 if (dynsymcount <= 0)
4527 relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
4531 if (get_elf_x86_backend_data (abfd)->target_os != is_nacl)
4533 lazy_plt = &elf_x86_64_lazy_plt;
4534 non_lazy_plt = &elf_x86_64_non_lazy_plt;
4535 lazy_bnd_plt = &elf_x86_64_lazy_bnd_plt;
4536 non_lazy_bnd_plt = &elf_x86_64_non_lazy_bnd_plt;
4537 if (ABI_64_P (abfd))
4539 lazy_ibt_plt = &elf_x86_64_lazy_ibt_plt;
4540 non_lazy_ibt_plt = &elf_x86_64_non_lazy_ibt_plt;
4544 lazy_ibt_plt = &elf_x32_lazy_ibt_plt;
4545 non_lazy_ibt_plt = &elf_x32_non_lazy_ibt_plt;
4550 lazy_plt = &elf_x86_64_nacl_plt;
4551 non_lazy_plt = NULL;
4552 lazy_bnd_plt = NULL;
4553 non_lazy_bnd_plt = NULL;
4554 lazy_ibt_plt = NULL;
4555 non_lazy_ibt_plt = NULL;
4559 for (j = 0; plts[j].name != NULL; j++)
4561 plt = bfd_get_section_by_name (abfd, plts[j].name);
4562 if (plt == NULL || plt->size == 0)
4565 /* Get the PLT section contents. */
4566 plt_contents = (bfd_byte *) bfd_malloc (plt->size);
4567 if (plt_contents == NULL)
4569 if (!bfd_get_section_contents (abfd, (asection *) plt,
4570 plt_contents, 0, plt->size))
4572 free (plt_contents);
4576 /* Check what kind of PLT it is. */
4577 plt_type = plt_unknown;
4578 if (plts[j].type == plt_unknown
4579 && (plt->size >= (lazy_plt->plt_entry_size
4580 + lazy_plt->plt_entry_size)))
4582 /* Match lazy PLT first. Need to check the first two
4584 if ((memcmp (plt_contents, lazy_plt->plt0_entry,
4585 lazy_plt->plt0_got1_offset) == 0)
4586 && (memcmp (plt_contents + 6, lazy_plt->plt0_entry + 6,
4588 plt_type = plt_lazy;
4589 else if (lazy_bnd_plt != NULL
4590 && (memcmp (plt_contents, lazy_bnd_plt->plt0_entry,
4591 lazy_bnd_plt->plt0_got1_offset) == 0)
4592 && (memcmp (plt_contents + 6,
4593 lazy_bnd_plt->plt0_entry + 6, 3) == 0))
4595 plt_type = plt_lazy | plt_second;
4596 /* The fist entry in the lazy IBT PLT is the same as the
4598 if ((memcmp (plt_contents + lazy_ibt_plt->plt_entry_size,
4599 lazy_ibt_plt->plt_entry,
4600 lazy_ibt_plt->plt_got_offset) == 0))
4601 lazy_plt = lazy_ibt_plt;
4603 lazy_plt = lazy_bnd_plt;
4607 if (non_lazy_plt != NULL
4608 && (plt_type == plt_unknown || plt_type == plt_non_lazy)
4609 && plt->size >= non_lazy_plt->plt_entry_size)
4611 /* Match non-lazy PLT. */
4612 if (memcmp (plt_contents, non_lazy_plt->plt_entry,
4613 non_lazy_plt->plt_got_offset) == 0)
4614 plt_type = plt_non_lazy;
4617 if (plt_type == plt_unknown || plt_type == plt_second)
4619 if (non_lazy_bnd_plt != NULL
4620 && plt->size >= non_lazy_bnd_plt->plt_entry_size
4621 && (memcmp (plt_contents, non_lazy_bnd_plt->plt_entry,
4622 non_lazy_bnd_plt->plt_got_offset) == 0))
4624 /* Match BND PLT. */
4625 plt_type = plt_second;
4626 non_lazy_plt = non_lazy_bnd_plt;
4628 else if (non_lazy_ibt_plt != NULL
4629 && plt->size >= non_lazy_ibt_plt->plt_entry_size
4630 && (memcmp (plt_contents,
4631 non_lazy_ibt_plt->plt_entry,
4632 non_lazy_ibt_plt->plt_got_offset) == 0))
4634 /* Match IBT PLT. */
4635 plt_type = plt_second;
4636 non_lazy_plt = non_lazy_ibt_plt;
4640 if (plt_type == plt_unknown)
4642 free (plt_contents);
4647 plts[j].type = plt_type;
4649 if ((plt_type & plt_lazy))
4651 plts[j].plt_got_offset = lazy_plt->plt_got_offset;
4652 plts[j].plt_got_insn_size = lazy_plt->plt_got_insn_size;
4653 plts[j].plt_entry_size = lazy_plt->plt_entry_size;
4654 /* Skip PLT0 in lazy PLT. */
4659 plts[j].plt_got_offset = non_lazy_plt->plt_got_offset;
4660 plts[j].plt_got_insn_size = non_lazy_plt->plt_got_insn_size;
4661 plts[j].plt_entry_size = non_lazy_plt->plt_entry_size;
4665 /* Skip lazy PLT when the second PLT is used. */
4666 if (plt_type == (plt_lazy | plt_second))
4670 n = plt->size / plts[j].plt_entry_size;
4675 plts[j].contents = plt_contents;
4678 return _bfd_x86_elf_get_synthetic_symtab (abfd, count, relsize,
4679 (bfd_vma) 0, plts, dynsyms,
4683 /* Handle an x86-64 specific section when reading an object file. This
4684 is called when elfcode.h finds a section with an unknown type. */
4687 elf_x86_64_section_from_shdr (bfd *abfd, Elf_Internal_Shdr *hdr,
4688 const char *name, int shindex)
4690 if (hdr->sh_type != SHT_X86_64_UNWIND)
4693 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
4699 /* Hook called by the linker routine which adds symbols from an object
4700 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
4704 elf_x86_64_add_symbol_hook (bfd *abfd,
4705 struct bfd_link_info *info ATTRIBUTE_UNUSED,
4706 Elf_Internal_Sym *sym,
4707 const char **namep ATTRIBUTE_UNUSED,
4708 flagword *flagsp ATTRIBUTE_UNUSED,
4714 switch (sym->st_shndx)
4716 case SHN_X86_64_LCOMMON:
4717 lcomm = bfd_get_section_by_name (abfd, "LARGE_COMMON");
4720 lcomm = bfd_make_section_with_flags (abfd,
4724 | SEC_LINKER_CREATED));
4727 elf_section_flags (lcomm) |= SHF_X86_64_LARGE;
4730 *valp = sym->st_size;
4738 /* Given a BFD section, try to locate the corresponding ELF section
4742 elf_x86_64_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
4743 asection *sec, int *index_return)
4745 if (sec == &_bfd_elf_large_com_section)
4747 *index_return = SHN_X86_64_LCOMMON;
4753 /* Process a symbol. */
4756 elf_x86_64_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
4759 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
4761 switch (elfsym->internal_elf_sym.st_shndx)
4763 case SHN_X86_64_LCOMMON:
4764 asym->section = &_bfd_elf_large_com_section;
4765 asym->value = elfsym->internal_elf_sym.st_size;
4766 /* Common symbol doesn't set BSF_GLOBAL. */
4767 asym->flags &= ~BSF_GLOBAL;
4773 elf_x86_64_common_definition (Elf_Internal_Sym *sym)
4775 return (sym->st_shndx == SHN_COMMON
4776 || sym->st_shndx == SHN_X86_64_LCOMMON);
4780 elf_x86_64_common_section_index (asection *sec)
4782 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
4785 return SHN_X86_64_LCOMMON;
4789 elf_x86_64_common_section (asection *sec)
4791 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
4792 return bfd_com_section_ptr;
4794 return &_bfd_elf_large_com_section;
4798 elf_x86_64_merge_symbol (struct elf_link_hash_entry *h,
4799 const Elf_Internal_Sym *sym,
4804 const asection *oldsec)
4806 /* A normal common symbol and a large common symbol result in a
4807 normal common symbol. We turn the large common symbol into a
4810 && h->root.type == bfd_link_hash_common
4812 && bfd_is_com_section (*psec)
4815 if (sym->st_shndx == SHN_COMMON
4816 && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) != 0)
4818 h->root.u.c.p->section
4819 = bfd_make_section_old_way (oldbfd, "COMMON");
4820 h->root.u.c.p->section->flags = SEC_ALLOC;
4822 else if (sym->st_shndx == SHN_X86_64_LCOMMON
4823 && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) == 0)
4824 *psec = bfd_com_section_ptr;
4831 elf_x86_64_additional_program_headers (bfd *abfd,
4832 struct bfd_link_info *info ATTRIBUTE_UNUSED)
4837 /* Check to see if we need a large readonly segment. */
4838 s = bfd_get_section_by_name (abfd, ".lrodata");
4839 if (s && (s->flags & SEC_LOAD))
4842 /* Check to see if we need a large data segment. Since .lbss sections
4843 is placed right after the .bss section, there should be no need for
4844 a large data segment just because of .lbss. */
4845 s = bfd_get_section_by_name (abfd, ".ldata");
4846 if (s && (s->flags & SEC_LOAD))
4852 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
4855 elf_x86_64_relocs_compatible (const bfd_target *input,
4856 const bfd_target *output)
4858 return ((xvec_get_elf_backend_data (input)->s->elfclass
4859 == xvec_get_elf_backend_data (output)->s->elfclass)
4860 && _bfd_elf_relocs_compatible (input, output));
4863 /* Set up x86-64 GNU properties. Return the first relocatable ELF input
4864 with GNU properties if found. Otherwise, return NULL. */
4867 elf_x86_64_link_setup_gnu_properties (struct bfd_link_info *info)
4869 struct elf_x86_init_table init_table;
4871 if ((int) R_X86_64_standard >= (int) R_X86_64_converted_reloc_bit
4872 || (int) R_X86_64_max <= (int) R_X86_64_converted_reloc_bit
4873 || ((int) (R_X86_64_GNU_VTINHERIT | R_X86_64_converted_reloc_bit)
4874 != (int) R_X86_64_GNU_VTINHERIT)
4875 || ((int) (R_X86_64_GNU_VTENTRY | R_X86_64_converted_reloc_bit)
4876 != (int) R_X86_64_GNU_VTENTRY))
4879 /* This is unused for x86-64. */
4880 init_table.plt0_pad_byte = 0x90;
4882 if (get_elf_x86_backend_data (info->output_bfd)->target_os != is_nacl)
4886 init_table.lazy_plt = &elf_x86_64_lazy_bnd_plt;
4887 init_table.non_lazy_plt = &elf_x86_64_non_lazy_bnd_plt;
4891 init_table.lazy_plt = &elf_x86_64_lazy_plt;
4892 init_table.non_lazy_plt = &elf_x86_64_non_lazy_plt;
4895 if (ABI_64_P (info->output_bfd))
4897 init_table.lazy_ibt_plt = &elf_x86_64_lazy_ibt_plt;
4898 init_table.non_lazy_ibt_plt = &elf_x86_64_non_lazy_ibt_plt;
4902 init_table.lazy_ibt_plt = &elf_x32_lazy_ibt_plt;
4903 init_table.non_lazy_ibt_plt = &elf_x32_non_lazy_ibt_plt;
4908 init_table.lazy_plt = &elf_x86_64_nacl_plt;
4909 init_table.non_lazy_plt = NULL;
4910 init_table.lazy_ibt_plt = NULL;
4911 init_table.non_lazy_ibt_plt = NULL;
4914 if (ABI_64_P (info->output_bfd))
4916 init_table.r_info = elf64_r_info;
4917 init_table.r_sym = elf64_r_sym;
4921 init_table.r_info = elf32_r_info;
4922 init_table.r_sym = elf32_r_sym;
4925 return _bfd_x86_elf_link_setup_gnu_properties (info, &init_table);
4928 static const struct bfd_elf_special_section
4929 elf_x86_64_special_sections[]=
4931 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
4932 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
4933 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR + SHF_X86_64_LARGE},
4934 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
4935 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
4936 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
4937 { NULL, 0, 0, 0, 0 }
4940 #define TARGET_LITTLE_SYM x86_64_elf64_vec
4941 #define TARGET_LITTLE_NAME "elf64-x86-64"
4942 #define ELF_ARCH bfd_arch_i386
4943 #define ELF_TARGET_ID X86_64_ELF_DATA
4944 #define ELF_MACHINE_CODE EM_X86_64
4945 #if DEFAULT_LD_Z_SEPARATE_CODE
4946 # define ELF_MAXPAGESIZE 0x1000
4948 # define ELF_MAXPAGESIZE 0x200000
4950 #define ELF_MINPAGESIZE 0x1000
4951 #define ELF_COMMONPAGESIZE 0x1000
4953 #define elf_backend_can_gc_sections 1
4954 #define elf_backend_can_refcount 1
4955 #define elf_backend_want_got_plt 1
4956 #define elf_backend_plt_readonly 1
4957 #define elf_backend_want_plt_sym 0
4958 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
4959 #define elf_backend_rela_normal 1
4960 #define elf_backend_plt_alignment 4
4961 #define elf_backend_extern_protected_data 1
4962 #define elf_backend_caches_rawsize 1
4963 #define elf_backend_dtrel_excludes_plt 1
4964 #define elf_backend_want_dynrelro 1
4966 #define elf_info_to_howto elf_x86_64_info_to_howto
4968 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
4969 #define bfd_elf64_bfd_reloc_name_lookup \
4970 elf_x86_64_reloc_name_lookup
4972 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
4973 #define elf_backend_check_relocs elf_x86_64_check_relocs
4974 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
4975 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
4976 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
4977 #define elf_backend_output_arch_local_syms elf_x86_64_output_arch_local_syms
4978 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
4979 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
4981 #define elf_backend_write_core_note elf_x86_64_write_core_note
4983 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
4984 #define elf_backend_relocate_section elf_x86_64_relocate_section
4985 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
4986 #define elf_backend_object_p elf64_x86_64_elf_object_p
4987 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
4989 #define elf_backend_section_from_shdr \
4990 elf_x86_64_section_from_shdr
4992 #define elf_backend_section_from_bfd_section \
4993 elf_x86_64_elf_section_from_bfd_section
4994 #define elf_backend_add_symbol_hook \
4995 elf_x86_64_add_symbol_hook
4996 #define elf_backend_symbol_processing \
4997 elf_x86_64_symbol_processing
4998 #define elf_backend_common_section_index \
4999 elf_x86_64_common_section_index
5000 #define elf_backend_common_section \
5001 elf_x86_64_common_section
5002 #define elf_backend_common_definition \
5003 elf_x86_64_common_definition
5004 #define elf_backend_merge_symbol \
5005 elf_x86_64_merge_symbol
5006 #define elf_backend_special_sections \
5007 elf_x86_64_special_sections
5008 #define elf_backend_additional_program_headers \
5009 elf_x86_64_additional_program_headers
5010 #define elf_backend_setup_gnu_properties \
5011 elf_x86_64_link_setup_gnu_properties
5012 #define elf_backend_hide_symbol \
5013 _bfd_x86_elf_hide_symbol
5015 #include "elf64-target.h"
5017 /* CloudABI support. */
5019 #undef TARGET_LITTLE_SYM
5020 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
5021 #undef TARGET_LITTLE_NAME
5022 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
5025 #define ELF_OSABI ELFOSABI_CLOUDABI
5028 #define elf64_bed elf64_x86_64_cloudabi_bed
5030 #include "elf64-target.h"
5032 /* FreeBSD support. */
5034 #undef TARGET_LITTLE_SYM
5035 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
5036 #undef TARGET_LITTLE_NAME
5037 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
5040 #define ELF_OSABI ELFOSABI_FREEBSD
5043 #define elf64_bed elf64_x86_64_fbsd_bed
5045 #include "elf64-target.h"
5047 /* Solaris 2 support. */
5049 #undef TARGET_LITTLE_SYM
5050 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
5051 #undef TARGET_LITTLE_NAME
5052 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
5054 static const struct elf_x86_backend_data elf_x86_64_solaris_arch_bed =
5059 #undef elf_backend_arch_data
5060 #define elf_backend_arch_data &elf_x86_64_solaris_arch_bed
5062 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5063 objects won't be recognized. */
5067 #define elf64_bed elf64_x86_64_sol2_bed
5069 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
5071 #undef elf_backend_static_tls_alignment
5072 #define elf_backend_static_tls_alignment 16
5074 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5076 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5078 #undef elf_backend_want_plt_sym
5079 #define elf_backend_want_plt_sym 1
5081 #undef elf_backend_strtab_flags
5082 #define elf_backend_strtab_flags SHF_STRINGS
5085 elf64_x86_64_copy_solaris_special_section_fields (const bfd *ibfd ATTRIBUTE_UNUSED,
5086 bfd *obfd ATTRIBUTE_UNUSED,
5087 const Elf_Internal_Shdr *isection ATTRIBUTE_UNUSED,
5088 Elf_Internal_Shdr *osection ATTRIBUTE_UNUSED)
5090 /* PR 19938: FIXME: Need to add code for setting the sh_info
5091 and sh_link fields of Solaris specific section types. */
5095 #undef elf_backend_copy_special_section_fields
5096 #define elf_backend_copy_special_section_fields elf64_x86_64_copy_solaris_special_section_fields
5098 #include "elf64-target.h"
5100 /* Native Client support. */
5103 elf64_x86_64_nacl_elf_object_p (bfd *abfd)
5105 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
5106 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64_nacl);
5110 #undef TARGET_LITTLE_SYM
5111 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
5112 #undef TARGET_LITTLE_NAME
5113 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
5115 #define elf64_bed elf64_x86_64_nacl_bed
5117 #undef ELF_MAXPAGESIZE
5118 #undef ELF_MINPAGESIZE
5119 #undef ELF_COMMONPAGESIZE
5120 #define ELF_MAXPAGESIZE 0x10000
5121 #define ELF_MINPAGESIZE 0x10000
5122 #define ELF_COMMONPAGESIZE 0x10000
5124 /* Restore defaults. */
5126 #undef elf_backend_static_tls_alignment
5127 #undef elf_backend_want_plt_sym
5128 #define elf_backend_want_plt_sym 0
5129 #undef elf_backend_strtab_flags
5130 #undef elf_backend_copy_special_section_fields
5132 /* NaCl uses substantially different PLT entries for the same effects. */
5134 #undef elf_backend_plt_alignment
5135 #define elf_backend_plt_alignment 5
5136 #define NACL_PLT_ENTRY_SIZE 64
5137 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
5139 static const bfd_byte elf_x86_64_nacl_plt0_entry[NACL_PLT_ENTRY_SIZE] =
5141 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
5142 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
5143 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */
5144 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5145 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5147 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
5148 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
5150 /* 32 bytes of nop to pad out to the standard size. */
5151 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
5152 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5153 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
5154 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5155 0x66, /* excess data16 prefix */
5159 static const bfd_byte elf_x86_64_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
5161 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
5162 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */
5163 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5164 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5166 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
5167 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
5168 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5170 /* Lazy GOT entries point here (32-byte aligned). */
5171 0x68, /* pushq immediate */
5172 0, 0, 0, 0, /* replaced with index into relocation table. */
5173 0xe9, /* jmp relative */
5174 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
5176 /* 22 bytes of nop to pad out to the standard size. */
5177 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
5178 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5179 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
5182 /* .eh_frame covering the .plt section. */
5184 static const bfd_byte elf_x86_64_nacl_eh_frame_plt[] =
5186 #if (PLT_CIE_LENGTH != 20 \
5187 || PLT_FDE_LENGTH != 36 \
5188 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
5189 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
5190 # error "Need elf_x86_backend_data parameters for eh_frame_plt offsets!"
5192 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
5193 0, 0, 0, 0, /* CIE ID */
5194 1, /* CIE version */
5195 'z', 'R', 0, /* Augmentation string */
5196 1, /* Code alignment factor */
5197 0x78, /* Data alignment factor */
5198 16, /* Return address column */
5199 1, /* Augmentation size */
5200 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
5201 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
5202 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
5203 DW_CFA_nop, DW_CFA_nop,
5205 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
5206 PLT_CIE_LENGTH + 8, 0, 0, 0,/* CIE pointer */
5207 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
5208 0, 0, 0, 0, /* .plt size goes here */
5209 0, /* Augmentation size */
5210 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
5211 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
5212 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
5213 DW_CFA_advance_loc + 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
5214 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
5215 13, /* Block length */
5216 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
5217 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
5218 DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
5219 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
5220 DW_CFA_nop, DW_CFA_nop
5223 static const struct elf_x86_lazy_plt_layout elf_x86_64_nacl_plt =
5225 elf_x86_64_nacl_plt0_entry, /* plt0_entry */
5226 NACL_PLT_ENTRY_SIZE, /* plt0_entry_size */
5227 elf_x86_64_nacl_plt_entry, /* plt_entry */
5228 NACL_PLT_ENTRY_SIZE, /* plt_entry_size */
5229 2, /* plt0_got1_offset */
5230 9, /* plt0_got2_offset */
5231 13, /* plt0_got2_insn_end */
5232 3, /* plt_got_offset */
5233 33, /* plt_reloc_offset */
5234 38, /* plt_plt_offset */
5235 7, /* plt_got_insn_size */
5236 42, /* plt_plt_insn_end */
5237 32, /* plt_lazy_offset */
5238 elf_x86_64_nacl_plt0_entry, /* pic_plt0_entry */
5239 elf_x86_64_nacl_plt_entry, /* pic_plt_entry */
5240 elf_x86_64_nacl_eh_frame_plt, /* eh_frame_plt */
5241 sizeof (elf_x86_64_nacl_eh_frame_plt) /* eh_frame_plt_size */
5244 static const struct elf_x86_backend_data elf_x86_64_nacl_arch_bed =
5249 #undef elf_backend_arch_data
5250 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
5252 #undef elf_backend_object_p
5253 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
5254 #undef elf_backend_modify_segment_map
5255 #define elf_backend_modify_segment_map nacl_modify_segment_map
5256 #undef elf_backend_modify_program_headers
5257 #define elf_backend_modify_program_headers nacl_modify_program_headers
5258 #undef elf_backend_final_write_processing
5259 #define elf_backend_final_write_processing nacl_final_write_processing
5261 #include "elf64-target.h"
5263 /* Native Client x32 support. */
5266 elf32_x86_64_nacl_elf_object_p (bfd *abfd)
5268 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
5269 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32_nacl);
5273 #undef TARGET_LITTLE_SYM
5274 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
5275 #undef TARGET_LITTLE_NAME
5276 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
5278 #define elf32_bed elf32_x86_64_nacl_bed
5280 #define bfd_elf32_bfd_reloc_type_lookup \
5281 elf_x86_64_reloc_type_lookup
5282 #define bfd_elf32_bfd_reloc_name_lookup \
5283 elf_x86_64_reloc_name_lookup
5284 #define bfd_elf32_get_synthetic_symtab \
5285 elf_x86_64_get_synthetic_symtab
5287 #undef elf_backend_object_p
5288 #define elf_backend_object_p \
5289 elf32_x86_64_nacl_elf_object_p
5291 #undef elf_backend_bfd_from_remote_memory
5292 #define elf_backend_bfd_from_remote_memory \
5293 _bfd_elf32_bfd_from_remote_memory
5295 #undef elf_backend_size_info
5296 #define elf_backend_size_info \
5297 _bfd_elf32_size_info
5299 #include "elf32-target.h"
5301 /* Restore defaults. */
5302 #undef elf_backend_object_p
5303 #define elf_backend_object_p elf64_x86_64_elf_object_p
5304 #undef elf_backend_bfd_from_remote_memory
5305 #undef elf_backend_size_info
5306 #undef elf_backend_modify_segment_map
5307 #undef elf_backend_modify_program_headers
5308 #undef elf_backend_final_write_processing
5310 /* Intel L1OM support. */
5313 elf64_l1om_elf_object_p (bfd *abfd)
5315 /* Set the right machine number for an L1OM elf64 file. */
5316 bfd_default_set_arch_mach (abfd, bfd_arch_l1om, bfd_mach_l1om);
5320 #undef TARGET_LITTLE_SYM
5321 #define TARGET_LITTLE_SYM l1om_elf64_vec
5322 #undef TARGET_LITTLE_NAME
5323 #define TARGET_LITTLE_NAME "elf64-l1om"
5325 #define ELF_ARCH bfd_arch_l1om
5327 #undef ELF_MACHINE_CODE
5328 #define ELF_MACHINE_CODE EM_L1OM
5333 #define elf64_bed elf64_l1om_bed
5335 #undef elf_backend_object_p
5336 #define elf_backend_object_p elf64_l1om_elf_object_p
5338 /* Restore defaults. */
5339 #undef ELF_MAXPAGESIZE
5340 #undef ELF_MINPAGESIZE
5341 #undef ELF_COMMONPAGESIZE
5342 #if DEFAULT_LD_Z_SEPARATE_CODE
5343 # define ELF_MAXPAGESIZE 0x1000
5345 # define ELF_MAXPAGESIZE 0x200000
5347 #define ELF_MINPAGESIZE 0x1000
5348 #define ELF_COMMONPAGESIZE 0x1000
5349 #undef elf_backend_plt_alignment
5350 #define elf_backend_plt_alignment 4
5351 #undef elf_backend_arch_data
5352 #define elf_backend_arch_data &elf_x86_64_arch_bed
5354 #include "elf64-target.h"
5356 /* FreeBSD L1OM support. */
5358 #undef TARGET_LITTLE_SYM
5359 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
5360 #undef TARGET_LITTLE_NAME
5361 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
5364 #define ELF_OSABI ELFOSABI_FREEBSD
5367 #define elf64_bed elf64_l1om_fbsd_bed
5369 #include "elf64-target.h"
5371 /* Intel K1OM support. */
5374 elf64_k1om_elf_object_p (bfd *abfd)
5376 /* Set the right machine number for an K1OM elf64 file. */
5377 bfd_default_set_arch_mach (abfd, bfd_arch_k1om, bfd_mach_k1om);
5381 #undef TARGET_LITTLE_SYM
5382 #define TARGET_LITTLE_SYM k1om_elf64_vec
5383 #undef TARGET_LITTLE_NAME
5384 #define TARGET_LITTLE_NAME "elf64-k1om"
5386 #define ELF_ARCH bfd_arch_k1om
5388 #undef ELF_MACHINE_CODE
5389 #define ELF_MACHINE_CODE EM_K1OM
5394 #define elf64_bed elf64_k1om_bed
5396 #undef elf_backend_object_p
5397 #define elf_backend_object_p elf64_k1om_elf_object_p
5399 #undef elf_backend_static_tls_alignment
5401 #undef elf_backend_want_plt_sym
5402 #define elf_backend_want_plt_sym 0
5404 #include "elf64-target.h"
5406 /* FreeBSD K1OM support. */
5408 #undef TARGET_LITTLE_SYM
5409 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
5410 #undef TARGET_LITTLE_NAME
5411 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
5414 #define ELF_OSABI ELFOSABI_FREEBSD
5417 #define elf64_bed elf64_k1om_fbsd_bed
5419 #include "elf64-target.h"
5421 /* 32bit x86-64 support. */
5423 #undef TARGET_LITTLE_SYM
5424 #define TARGET_LITTLE_SYM x86_64_elf32_vec
5425 #undef TARGET_LITTLE_NAME
5426 #define TARGET_LITTLE_NAME "elf32-x86-64"
5430 #define ELF_ARCH bfd_arch_i386
5432 #undef ELF_MACHINE_CODE
5433 #define ELF_MACHINE_CODE EM_X86_64
5437 #undef elf_backend_object_p
5438 #define elf_backend_object_p \
5439 elf32_x86_64_elf_object_p
5441 #undef elf_backend_bfd_from_remote_memory
5442 #define elf_backend_bfd_from_remote_memory \
5443 _bfd_elf32_bfd_from_remote_memory
5445 #undef elf_backend_size_info
5446 #define elf_backend_size_info \
5447 _bfd_elf32_size_info
5449 #include "elf32-target.h"