1 /* X86-64 specific support for ELF
2 Copyright (C) 2000-2014 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka <jh@suse.cz>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
28 #include "bfd_stdint.h"
32 #include "libiberty.h"
34 #include "elf/x86-64.h"
41 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
42 #define MINUS_ONE (~ (bfd_vma) 0)
44 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
45 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
46 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
47 since they are the same. */
49 #define ABI_64_P(abfd) \
50 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
52 /* The relocation "howto" table. Order of fields:
53 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
54 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
55 static reloc_howto_type x86_64_elf_howto_table[] =
57 HOWTO(R_X86_64_NONE, 0, 3, 0, FALSE, 0, complain_overflow_dont,
58 bfd_elf_generic_reloc, "R_X86_64_NONE", FALSE, 0x00000000, 0x00000000,
60 HOWTO(R_X86_64_64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
61 bfd_elf_generic_reloc, "R_X86_64_64", FALSE, MINUS_ONE, MINUS_ONE,
63 HOWTO(R_X86_64_PC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
64 bfd_elf_generic_reloc, "R_X86_64_PC32", FALSE, 0xffffffff, 0xffffffff,
66 HOWTO(R_X86_64_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
67 bfd_elf_generic_reloc, "R_X86_64_GOT32", FALSE, 0xffffffff, 0xffffffff,
69 HOWTO(R_X86_64_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
70 bfd_elf_generic_reloc, "R_X86_64_PLT32", FALSE, 0xffffffff, 0xffffffff,
72 HOWTO(R_X86_64_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
73 bfd_elf_generic_reloc, "R_X86_64_COPY", FALSE, 0xffffffff, 0xffffffff,
75 HOWTO(R_X86_64_GLOB_DAT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
76 bfd_elf_generic_reloc, "R_X86_64_GLOB_DAT", FALSE, MINUS_ONE,
78 HOWTO(R_X86_64_JUMP_SLOT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
79 bfd_elf_generic_reloc, "R_X86_64_JUMP_SLOT", FALSE, MINUS_ONE,
81 HOWTO(R_X86_64_RELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
82 bfd_elf_generic_reloc, "R_X86_64_RELATIVE", FALSE, MINUS_ONE,
84 HOWTO(R_X86_64_GOTPCREL, 0, 2, 32, TRUE, 0, complain_overflow_signed,
85 bfd_elf_generic_reloc, "R_X86_64_GOTPCREL", FALSE, 0xffffffff,
87 HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
88 bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
90 HOWTO(R_X86_64_32S, 0, 2, 32, FALSE, 0, complain_overflow_signed,
91 bfd_elf_generic_reloc, "R_X86_64_32S", FALSE, 0xffffffff, 0xffffffff,
93 HOWTO(R_X86_64_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
94 bfd_elf_generic_reloc, "R_X86_64_16", FALSE, 0xffff, 0xffff, FALSE),
95 HOWTO(R_X86_64_PC16,0, 1, 16, TRUE, 0, complain_overflow_bitfield,
96 bfd_elf_generic_reloc, "R_X86_64_PC16", FALSE, 0xffff, 0xffff, TRUE),
97 HOWTO(R_X86_64_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
98 bfd_elf_generic_reloc, "R_X86_64_8", FALSE, 0xff, 0xff, FALSE),
99 HOWTO(R_X86_64_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
100 bfd_elf_generic_reloc, "R_X86_64_PC8", FALSE, 0xff, 0xff, TRUE),
101 HOWTO(R_X86_64_DTPMOD64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
102 bfd_elf_generic_reloc, "R_X86_64_DTPMOD64", FALSE, MINUS_ONE,
104 HOWTO(R_X86_64_DTPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
105 bfd_elf_generic_reloc, "R_X86_64_DTPOFF64", FALSE, MINUS_ONE,
107 HOWTO(R_X86_64_TPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
108 bfd_elf_generic_reloc, "R_X86_64_TPOFF64", FALSE, MINUS_ONE,
110 HOWTO(R_X86_64_TLSGD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
111 bfd_elf_generic_reloc, "R_X86_64_TLSGD", FALSE, 0xffffffff,
113 HOWTO(R_X86_64_TLSLD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
114 bfd_elf_generic_reloc, "R_X86_64_TLSLD", FALSE, 0xffffffff,
116 HOWTO(R_X86_64_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
117 bfd_elf_generic_reloc, "R_X86_64_DTPOFF32", FALSE, 0xffffffff,
119 HOWTO(R_X86_64_GOTTPOFF, 0, 2, 32, TRUE, 0, complain_overflow_signed,
120 bfd_elf_generic_reloc, "R_X86_64_GOTTPOFF", FALSE, 0xffffffff,
122 HOWTO(R_X86_64_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
123 bfd_elf_generic_reloc, "R_X86_64_TPOFF32", FALSE, 0xffffffff,
125 HOWTO(R_X86_64_PC64, 0, 4, 64, TRUE, 0, complain_overflow_bitfield,
126 bfd_elf_generic_reloc, "R_X86_64_PC64", FALSE, MINUS_ONE, MINUS_ONE,
128 HOWTO(R_X86_64_GOTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
129 bfd_elf_generic_reloc, "R_X86_64_GOTOFF64",
130 FALSE, MINUS_ONE, MINUS_ONE, FALSE),
131 HOWTO(R_X86_64_GOTPC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
132 bfd_elf_generic_reloc, "R_X86_64_GOTPC32",
133 FALSE, 0xffffffff, 0xffffffff, TRUE),
134 HOWTO(R_X86_64_GOT64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
135 bfd_elf_generic_reloc, "R_X86_64_GOT64", FALSE, MINUS_ONE, MINUS_ONE,
137 HOWTO(R_X86_64_GOTPCREL64, 0, 4, 64, TRUE, 0, complain_overflow_signed,
138 bfd_elf_generic_reloc, "R_X86_64_GOTPCREL64", FALSE, MINUS_ONE,
140 HOWTO(R_X86_64_GOTPC64, 0, 4, 64, TRUE, 0, complain_overflow_signed,
141 bfd_elf_generic_reloc, "R_X86_64_GOTPC64",
142 FALSE, MINUS_ONE, MINUS_ONE, TRUE),
143 HOWTO(R_X86_64_GOTPLT64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
144 bfd_elf_generic_reloc, "R_X86_64_GOTPLT64", FALSE, MINUS_ONE,
146 HOWTO(R_X86_64_PLTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
147 bfd_elf_generic_reloc, "R_X86_64_PLTOFF64", FALSE, MINUS_ONE,
149 HOWTO(R_X86_64_SIZE32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
150 bfd_elf_generic_reloc, "R_X86_64_SIZE32", FALSE, 0xffffffff, 0xffffffff,
152 HOWTO(R_X86_64_SIZE64, 0, 4, 64, FALSE, 0, complain_overflow_unsigned,
153 bfd_elf_generic_reloc, "R_X86_64_SIZE64", FALSE, MINUS_ONE, MINUS_ONE,
155 HOWTO(R_X86_64_GOTPC32_TLSDESC, 0, 2, 32, TRUE, 0,
156 complain_overflow_bitfield, bfd_elf_generic_reloc,
157 "R_X86_64_GOTPC32_TLSDESC",
158 FALSE, 0xffffffff, 0xffffffff, TRUE),
159 HOWTO(R_X86_64_TLSDESC_CALL, 0, 0, 0, FALSE, 0,
160 complain_overflow_dont, bfd_elf_generic_reloc,
161 "R_X86_64_TLSDESC_CALL",
163 HOWTO(R_X86_64_TLSDESC, 0, 4, 64, FALSE, 0,
164 complain_overflow_bitfield, bfd_elf_generic_reloc,
166 FALSE, MINUS_ONE, MINUS_ONE, FALSE),
167 HOWTO(R_X86_64_IRELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
168 bfd_elf_generic_reloc, "R_X86_64_IRELATIVE", FALSE, MINUS_ONE,
170 HOWTO(R_X86_64_RELATIVE64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
171 bfd_elf_generic_reloc, "R_X86_64_RELATIVE64", FALSE, MINUS_ONE,
173 HOWTO(R_X86_64_PC32_BND, 0, 2, 32, TRUE, 0, complain_overflow_signed,
174 bfd_elf_generic_reloc, "R_X86_64_PC32_BND", FALSE, 0xffffffff, 0xffffffff,
176 HOWTO(R_X86_64_PLT32_BND, 0, 2, 32, TRUE, 0, complain_overflow_signed,
177 bfd_elf_generic_reloc, "R_X86_64_PLT32_BND", FALSE, 0xffffffff, 0xffffffff,
180 /* We have a gap in the reloc numbers here.
181 R_X86_64_standard counts the number up to this point, and
182 R_X86_64_vt_offset is the value to subtract from a reloc type of
183 R_X86_64_GNU_VT* to form an index into this table. */
184 #define R_X86_64_standard (R_X86_64_PLT32_BND + 1)
185 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
187 /* GNU extension to record C++ vtable hierarchy. */
188 HOWTO (R_X86_64_GNU_VTINHERIT, 0, 4, 0, FALSE, 0, complain_overflow_dont,
189 NULL, "R_X86_64_GNU_VTINHERIT", FALSE, 0, 0, FALSE),
191 /* GNU extension to record C++ vtable member usage. */
192 HOWTO (R_X86_64_GNU_VTENTRY, 0, 4, 0, FALSE, 0, complain_overflow_dont,
193 _bfd_elf_rel_vtable_reloc_fn, "R_X86_64_GNU_VTENTRY", FALSE, 0, 0,
196 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
197 HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
198 bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
202 #define IS_X86_64_PCREL_TYPE(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 /* Map BFD relocs to the x86_64 elf relocs. */
212 bfd_reloc_code_real_type bfd_reloc_val;
213 unsigned char elf_reloc_val;
216 static const struct elf_reloc_map x86_64_reloc_map[] =
218 { BFD_RELOC_NONE, R_X86_64_NONE, },
219 { BFD_RELOC_64, R_X86_64_64, },
220 { BFD_RELOC_32_PCREL, R_X86_64_PC32, },
221 { BFD_RELOC_X86_64_GOT32, R_X86_64_GOT32,},
222 { BFD_RELOC_X86_64_PLT32, R_X86_64_PLT32,},
223 { BFD_RELOC_X86_64_COPY, R_X86_64_COPY, },
224 { BFD_RELOC_X86_64_GLOB_DAT, R_X86_64_GLOB_DAT, },
225 { BFD_RELOC_X86_64_JUMP_SLOT, R_X86_64_JUMP_SLOT, },
226 { BFD_RELOC_X86_64_RELATIVE, R_X86_64_RELATIVE, },
227 { BFD_RELOC_X86_64_GOTPCREL, R_X86_64_GOTPCREL, },
228 { BFD_RELOC_32, R_X86_64_32, },
229 { BFD_RELOC_X86_64_32S, R_X86_64_32S, },
230 { BFD_RELOC_16, R_X86_64_16, },
231 { BFD_RELOC_16_PCREL, R_X86_64_PC16, },
232 { BFD_RELOC_8, R_X86_64_8, },
233 { BFD_RELOC_8_PCREL, R_X86_64_PC8, },
234 { BFD_RELOC_X86_64_DTPMOD64, R_X86_64_DTPMOD64, },
235 { BFD_RELOC_X86_64_DTPOFF64, R_X86_64_DTPOFF64, },
236 { BFD_RELOC_X86_64_TPOFF64, R_X86_64_TPOFF64, },
237 { BFD_RELOC_X86_64_TLSGD, R_X86_64_TLSGD, },
238 { BFD_RELOC_X86_64_TLSLD, R_X86_64_TLSLD, },
239 { BFD_RELOC_X86_64_DTPOFF32, R_X86_64_DTPOFF32, },
240 { BFD_RELOC_X86_64_GOTTPOFF, R_X86_64_GOTTPOFF, },
241 { BFD_RELOC_X86_64_TPOFF32, R_X86_64_TPOFF32, },
242 { BFD_RELOC_64_PCREL, R_X86_64_PC64, },
243 { BFD_RELOC_X86_64_GOTOFF64, R_X86_64_GOTOFF64, },
244 { BFD_RELOC_X86_64_GOTPC32, R_X86_64_GOTPC32, },
245 { BFD_RELOC_X86_64_GOT64, R_X86_64_GOT64, },
246 { BFD_RELOC_X86_64_GOTPCREL64,R_X86_64_GOTPCREL64, },
247 { BFD_RELOC_X86_64_GOTPC64, R_X86_64_GOTPC64, },
248 { BFD_RELOC_X86_64_GOTPLT64, R_X86_64_GOTPLT64, },
249 { BFD_RELOC_X86_64_PLTOFF64, R_X86_64_PLTOFF64, },
250 { BFD_RELOC_SIZE32, R_X86_64_SIZE32, },
251 { BFD_RELOC_SIZE64, R_X86_64_SIZE64, },
252 { BFD_RELOC_X86_64_GOTPC32_TLSDESC, R_X86_64_GOTPC32_TLSDESC, },
253 { BFD_RELOC_X86_64_TLSDESC_CALL, R_X86_64_TLSDESC_CALL, },
254 { BFD_RELOC_X86_64_TLSDESC, R_X86_64_TLSDESC, },
255 { BFD_RELOC_X86_64_IRELATIVE, R_X86_64_IRELATIVE, },
256 { BFD_RELOC_X86_64_PC32_BND, R_X86_64_PC32_BND,},
257 { BFD_RELOC_X86_64_PLT32_BND, R_X86_64_PLT32_BND,},
258 { BFD_RELOC_VTABLE_INHERIT, R_X86_64_GNU_VTINHERIT, },
259 { BFD_RELOC_VTABLE_ENTRY, R_X86_64_GNU_VTENTRY, },
262 static reloc_howto_type *
263 elf_x86_64_rtype_to_howto (bfd *abfd, unsigned r_type)
267 if (r_type == (unsigned int) R_X86_64_32)
272 i = ARRAY_SIZE (x86_64_elf_howto_table) - 1;
274 else if (r_type < (unsigned int) R_X86_64_GNU_VTINHERIT
275 || r_type >= (unsigned int) R_X86_64_max)
277 if (r_type >= (unsigned int) R_X86_64_standard)
279 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
281 r_type = R_X86_64_NONE;
286 i = r_type - (unsigned int) R_X86_64_vt_offset;
287 BFD_ASSERT (x86_64_elf_howto_table[i].type == r_type);
288 return &x86_64_elf_howto_table[i];
291 /* Given a BFD reloc type, return a HOWTO structure. */
292 static reloc_howto_type *
293 elf_x86_64_reloc_type_lookup (bfd *abfd,
294 bfd_reloc_code_real_type code)
298 for (i = 0; i < sizeof (x86_64_reloc_map) / sizeof (struct elf_reloc_map);
301 if (x86_64_reloc_map[i].bfd_reloc_val == code)
302 return elf_x86_64_rtype_to_howto (abfd,
303 x86_64_reloc_map[i].elf_reloc_val);
308 static reloc_howto_type *
309 elf_x86_64_reloc_name_lookup (bfd *abfd,
314 if (!ABI_64_P (abfd) && strcasecmp (r_name, "R_X86_64_32") == 0)
316 /* Get x32 R_X86_64_32. */
317 reloc_howto_type *reloc
318 = &x86_64_elf_howto_table[ARRAY_SIZE (x86_64_elf_howto_table) - 1];
319 BFD_ASSERT (reloc->type == (unsigned int) R_X86_64_32);
323 for (i = 0; i < ARRAY_SIZE (x86_64_elf_howto_table); i++)
324 if (x86_64_elf_howto_table[i].name != NULL
325 && strcasecmp (x86_64_elf_howto_table[i].name, r_name) == 0)
326 return &x86_64_elf_howto_table[i];
331 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
334 elf_x86_64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
335 Elf_Internal_Rela *dst)
339 r_type = ELF32_R_TYPE (dst->r_info);
340 cache_ptr->howto = elf_x86_64_rtype_to_howto (abfd, r_type);
341 BFD_ASSERT (r_type == cache_ptr->howto->type);
344 /* Support for core dump NOTE sections. */
346 elf_x86_64_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
351 switch (note->descsz)
356 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
358 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
361 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
369 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
371 elf_tdata (abfd)->core->signal
372 = bfd_get_16 (abfd, note->descdata + 12);
375 elf_tdata (abfd)->core->lwpid
376 = bfd_get_32 (abfd, note->descdata + 32);
385 /* Make a ".reg/999" section. */
386 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
387 size, note->descpos + offset);
391 elf_x86_64_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
393 switch (note->descsz)
398 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
399 elf_tdata (abfd)->core->pid
400 = bfd_get_32 (abfd, note->descdata + 12);
401 elf_tdata (abfd)->core->program
402 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
403 elf_tdata (abfd)->core->command
404 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
407 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
408 elf_tdata (abfd)->core->pid
409 = bfd_get_32 (abfd, note->descdata + 24);
410 elf_tdata (abfd)->core->program
411 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
412 elf_tdata (abfd)->core->command
413 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
416 /* Note that for some reason, a spurious space is tacked
417 onto the end of the args in some (at least one anyway)
418 implementations, so strip it off if it exists. */
421 char *command = elf_tdata (abfd)->core->command;
422 int n = strlen (command);
424 if (0 < n && command[n - 1] == ' ')
425 command[n - 1] = '\0';
433 elf_x86_64_write_core_note (bfd *abfd, char *buf, int *bufsiz,
436 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
438 const char *fname, *psargs;
449 va_start (ap, note_type);
450 fname = va_arg (ap, const char *);
451 psargs = va_arg (ap, const char *);
454 if (bed->s->elfclass == ELFCLASS32)
457 memset (&data, 0, sizeof (data));
458 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
459 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
460 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
461 &data, sizeof (data));
466 memset (&data, 0, sizeof (data));
467 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
468 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
469 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
470 &data, sizeof (data));
475 va_start (ap, note_type);
476 pid = va_arg (ap, long);
477 cursig = va_arg (ap, int);
478 gregs = va_arg (ap, const void *);
481 if (bed->s->elfclass == ELFCLASS32)
483 if (bed->elf_machine_code == EM_X86_64)
485 prstatusx32_t prstat;
486 memset (&prstat, 0, sizeof (prstat));
488 prstat.pr_cursig = cursig;
489 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
490 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
491 &prstat, sizeof (prstat));
496 memset (&prstat, 0, sizeof (prstat));
498 prstat.pr_cursig = cursig;
499 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
500 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
501 &prstat, sizeof (prstat));
507 memset (&prstat, 0, sizeof (prstat));
509 prstat.pr_cursig = cursig;
510 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
511 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
512 &prstat, sizeof (prstat));
519 /* Functions for the x86-64 ELF linker. */
521 /* The name of the dynamic interpreter. This is put in the .interp
524 #define ELF64_DYNAMIC_INTERPRETER "/libexec/ld-elf.so.2"
525 #define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
527 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
528 copying dynamic variables from a shared lib into an app's dynbss
529 section, and instead use a dynamic relocation to point into the
531 #define ELIMINATE_COPY_RELOCS 1
533 /* The size in bytes of an entry in the global offset table. */
535 #define GOT_ENTRY_SIZE 8
537 /* The size in bytes of an entry in the procedure linkage table. */
539 #define PLT_ENTRY_SIZE 16
541 /* The first entry in a procedure linkage table looks like this. See the
542 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
544 static const bfd_byte elf_x86_64_plt0_entry[PLT_ENTRY_SIZE] =
546 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
547 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
548 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
551 /* Subsequent entries in a procedure linkage table look like this. */
553 static const bfd_byte elf_x86_64_plt_entry[PLT_ENTRY_SIZE] =
555 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
556 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
557 0x68, /* pushq immediate */
558 0, 0, 0, 0, /* replaced with index into relocation table. */
559 0xe9, /* jmp relative */
560 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
563 /* The first entry in a procedure linkage table with BND relocations
566 static const bfd_byte elf_x86_64_bnd_plt0_entry[PLT_ENTRY_SIZE] =
568 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
569 0xf2, 0xff, 0x25, 16, 0, 0, 0, /* bnd jmpq *GOT+16(%rip) */
570 0x0f, 0x1f, 0 /* nopl (%rax) */
573 /* Subsequent entries for legacy branches in a procedure linkage table
574 with BND relocations look like this. */
576 static const bfd_byte elf_x86_64_legacy_plt_entry[PLT_ENTRY_SIZE] =
578 0x68, 0, 0, 0, 0, /* pushq immediate */
579 0xe9, 0, 0, 0, 0, /* jmpq relative */
580 0x66, 0x0f, 0x1f, 0x44, 0, 0 /* nopw (%rax,%rax,1) */
583 /* Subsequent entries for branches with BND prefx in a procedure linkage
584 table with BND relocations look like this. */
586 static const bfd_byte elf_x86_64_bnd_plt_entry[PLT_ENTRY_SIZE] =
588 0x68, 0, 0, 0, 0, /* pushq immediate */
589 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
590 0x0f, 0x1f, 0x44, 0, 0 /* nopl 0(%rax,%rax,1) */
593 /* Entries for legacy branches in the second procedure linkage table
596 static const bfd_byte elf_x86_64_legacy_plt2_entry[8] =
598 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
599 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
600 0x66, 0x90 /* xchg %ax,%ax */
603 /* Entries for branches with BND prefix in the second procedure linkage
604 table look like this. */
606 static const bfd_byte elf_x86_64_bnd_plt2_entry[8] =
608 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
609 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
613 /* .eh_frame covering the .plt section. */
615 static const bfd_byte elf_x86_64_eh_frame_plt[] =
617 #define PLT_CIE_LENGTH 20
618 #define PLT_FDE_LENGTH 36
619 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
620 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
621 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
622 0, 0, 0, 0, /* CIE ID */
624 'z', 'R', 0, /* Augmentation string */
625 1, /* Code alignment factor */
626 0x78, /* Data alignment factor */
627 16, /* Return address column */
628 1, /* Augmentation size */
629 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
630 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
631 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
632 DW_CFA_nop, DW_CFA_nop,
634 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
635 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
636 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
637 0, 0, 0, 0, /* .plt size goes here */
638 0, /* Augmentation size */
639 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
640 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
641 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
642 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
643 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
644 11, /* Block length */
645 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
646 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
647 DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
648 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
649 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
652 /* Architecture-specific backend data for x86-64. */
654 struct elf_x86_64_backend_data
656 /* Templates for the initial PLT entry and for subsequent entries. */
657 const bfd_byte *plt0_entry;
658 const bfd_byte *plt_entry;
659 unsigned int plt_entry_size; /* Size of each PLT entry. */
661 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
662 unsigned int plt0_got1_offset;
663 unsigned int plt0_got2_offset;
665 /* Offset of the end of the PC-relative instruction containing
667 unsigned int plt0_got2_insn_end;
669 /* Offsets into plt_entry that are to be replaced with... */
670 unsigned int plt_got_offset; /* ... address of this symbol in .got. */
671 unsigned int plt_reloc_offset; /* ... offset into relocation table. */
672 unsigned int plt_plt_offset; /* ... offset to start of .plt. */
674 /* Length of the PC-relative instruction containing plt_got_offset. */
675 unsigned int plt_got_insn_size;
677 /* Offset of the end of the PC-relative jump to plt0_entry. */
678 unsigned int plt_plt_insn_end;
680 /* Offset into plt_entry where the initial value of the GOT entry points. */
681 unsigned int plt_lazy_offset;
683 /* .eh_frame covering the .plt section. */
684 const bfd_byte *eh_frame_plt;
685 unsigned int eh_frame_plt_size;
688 #define get_elf_x86_64_arch_data(bed) \
689 ((const struct elf_x86_64_backend_data *) (bed)->arch_data)
691 #define get_elf_x86_64_backend_data(abfd) \
692 get_elf_x86_64_arch_data (get_elf_backend_data (abfd))
694 #define GET_PLT_ENTRY_SIZE(abfd) \
695 get_elf_x86_64_backend_data (abfd)->plt_entry_size
697 /* These are the standard parameters. */
698 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed =
700 elf_x86_64_plt0_entry, /* plt0_entry */
701 elf_x86_64_plt_entry, /* plt_entry */
702 sizeof (elf_x86_64_plt_entry), /* plt_entry_size */
703 2, /* plt0_got1_offset */
704 8, /* plt0_got2_offset */
705 12, /* plt0_got2_insn_end */
706 2, /* plt_got_offset */
707 7, /* plt_reloc_offset */
708 12, /* plt_plt_offset */
709 6, /* plt_got_insn_size */
710 PLT_ENTRY_SIZE, /* plt_plt_insn_end */
711 6, /* plt_lazy_offset */
712 elf_x86_64_eh_frame_plt, /* eh_frame_plt */
713 sizeof (elf_x86_64_eh_frame_plt), /* eh_frame_plt_size */
716 static const struct elf_x86_64_backend_data elf_x86_64_bnd_arch_bed =
718 elf_x86_64_bnd_plt0_entry, /* plt0_entry */
719 elf_x86_64_bnd_plt_entry, /* plt_entry */
720 sizeof (elf_x86_64_bnd_plt_entry), /* plt_entry_size */
721 2, /* plt0_got1_offset */
722 1+8, /* plt0_got2_offset */
723 1+12, /* plt0_got2_insn_end */
724 1+2, /* plt_got_offset */
725 1, /* plt_reloc_offset */
726 7, /* plt_plt_offset */
727 1+6, /* plt_got_insn_size */
728 11, /* plt_plt_insn_end */
729 0, /* plt_lazy_offset */
730 elf_x86_64_eh_frame_plt, /* eh_frame_plt */
731 sizeof (elf_x86_64_eh_frame_plt), /* eh_frame_plt_size */
734 #define elf_backend_arch_data &elf_x86_64_arch_bed
736 /* x86-64 ELF linker hash entry. */
738 struct elf_x86_64_link_hash_entry
740 struct elf_link_hash_entry elf;
742 /* Track dynamic relocs copied for this symbol. */
743 struct elf_dyn_relocs *dyn_relocs;
745 #define GOT_UNKNOWN 0
749 #define GOT_TLS_GDESC 4
750 #define GOT_TLS_GD_BOTH_P(type) \
751 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
752 #define GOT_TLS_GD_P(type) \
753 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
754 #define GOT_TLS_GDESC_P(type) \
755 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
756 #define GOT_TLS_GD_ANY_P(type) \
757 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
758 unsigned char tls_type;
760 /* TRUE if a weak symbol with a real definition needs a copy reloc.
761 When there is a weak symbol with a real definition, the processor
762 independent code will have arranged for us to see the real
763 definition first. We need to copy the needs_copy bit from the
764 real definition and check it when allowing copy reloc in PIE. */
765 unsigned int needs_copy : 1;
767 /* TRUE if symbol has at least one BND relocation. */
768 unsigned int has_bnd_reloc : 1;
770 /* Information about the second PLT entry. Filled when has_bnd_reloc is
772 union gotplt_union plt_bnd;
774 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
775 starting at the end of the jump table. */
779 #define elf_x86_64_hash_entry(ent) \
780 ((struct elf_x86_64_link_hash_entry *)(ent))
782 struct elf_x86_64_obj_tdata
784 struct elf_obj_tdata root;
786 /* tls_type for each local got entry. */
787 char *local_got_tls_type;
789 /* GOTPLT entries for TLS descriptors. */
790 bfd_vma *local_tlsdesc_gotent;
793 #define elf_x86_64_tdata(abfd) \
794 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
796 #define elf_x86_64_local_got_tls_type(abfd) \
797 (elf_x86_64_tdata (abfd)->local_got_tls_type)
799 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
800 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
802 #define is_x86_64_elf(bfd) \
803 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
804 && elf_tdata (bfd) != NULL \
805 && elf_object_id (bfd) == X86_64_ELF_DATA)
808 elf_x86_64_mkobject (bfd *abfd)
810 return bfd_elf_allocate_object (abfd, sizeof (struct elf_x86_64_obj_tdata),
814 /* x86-64 ELF linker hash table. */
816 struct elf_x86_64_link_hash_table
818 struct elf_link_hash_table elf;
820 /* Short-cuts to get to dynamic linker sections. */
823 asection *plt_eh_frame;
828 bfd_signed_vma refcount;
832 /* The amount of space used by the jump slots in the GOT. */
833 bfd_vma sgotplt_jump_table_size;
835 /* Small local sym cache. */
836 struct sym_cache sym_cache;
838 bfd_vma (*r_info) (bfd_vma, bfd_vma);
839 bfd_vma (*r_sym) (bfd_vma);
840 unsigned int pointer_r_type;
841 const char *dynamic_interpreter;
842 int dynamic_interpreter_size;
844 /* _TLS_MODULE_BASE_ symbol. */
845 struct bfd_link_hash_entry *tls_module_base;
847 /* Used by local STT_GNU_IFUNC symbols. */
848 htab_t loc_hash_table;
849 void * loc_hash_memory;
851 /* The offset into splt of the PLT entry for the TLS descriptor
852 resolver. Special values are 0, if not necessary (or not found
853 to be necessary yet), and -1 if needed but not determined
856 /* The offset into sgot of the GOT entry used by the PLT entry
860 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
861 bfd_vma next_jump_slot_index;
862 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
863 bfd_vma next_irelative_index;
866 /* Get the x86-64 ELF linker hash table from a link_info structure. */
868 #define elf_x86_64_hash_table(p) \
869 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
870 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
872 #define elf_x86_64_compute_jump_table_size(htab) \
873 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
875 /* Create an entry in an x86-64 ELF linker hash table. */
877 static struct bfd_hash_entry *
878 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry *entry,
879 struct bfd_hash_table *table,
882 /* Allocate the structure if it has not already been allocated by a
886 entry = (struct bfd_hash_entry *)
887 bfd_hash_allocate (table,
888 sizeof (struct elf_x86_64_link_hash_entry));
893 /* Call the allocation method of the superclass. */
894 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
897 struct elf_x86_64_link_hash_entry *eh;
899 eh = (struct elf_x86_64_link_hash_entry *) entry;
900 eh->dyn_relocs = NULL;
901 eh->tls_type = GOT_UNKNOWN;
903 eh->has_bnd_reloc = 0;
904 eh->plt_bnd.offset = (bfd_vma) -1;
905 eh->tlsdesc_got = (bfd_vma) -1;
911 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
912 for local symbol so that we can handle local STT_GNU_IFUNC symbols
913 as global symbol. We reuse indx and dynstr_index for local symbol
914 hash since they aren't used by global symbols in this backend. */
917 elf_x86_64_local_htab_hash (const void *ptr)
919 struct elf_link_hash_entry *h
920 = (struct elf_link_hash_entry *) ptr;
921 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
924 /* Compare local hash entries. */
927 elf_x86_64_local_htab_eq (const void *ptr1, const void *ptr2)
929 struct elf_link_hash_entry *h1
930 = (struct elf_link_hash_entry *) ptr1;
931 struct elf_link_hash_entry *h2
932 = (struct elf_link_hash_entry *) ptr2;
934 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
937 /* Find and/or create a hash entry for local symbol. */
939 static struct elf_link_hash_entry *
940 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table *htab,
941 bfd *abfd, const Elf_Internal_Rela *rel,
944 struct elf_x86_64_link_hash_entry e, *ret;
945 asection *sec = abfd->sections;
946 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
947 htab->r_sym (rel->r_info));
950 e.elf.indx = sec->id;
951 e.elf.dynstr_index = htab->r_sym (rel->r_info);
952 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
953 create ? INSERT : NO_INSERT);
960 ret = (struct elf_x86_64_link_hash_entry *) *slot;
964 ret = (struct elf_x86_64_link_hash_entry *)
965 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
966 sizeof (struct elf_x86_64_link_hash_entry));
969 memset (ret, 0, sizeof (*ret));
970 ret->elf.indx = sec->id;
971 ret->elf.dynstr_index = htab->r_sym (rel->r_info);
972 ret->elf.dynindx = -1;
978 /* Destroy an X86-64 ELF linker hash table. */
981 elf_x86_64_link_hash_table_free (bfd *obfd)
983 struct elf_x86_64_link_hash_table *htab
984 = (struct elf_x86_64_link_hash_table *) obfd->link.hash;
986 if (htab->loc_hash_table)
987 htab_delete (htab->loc_hash_table);
988 if (htab->loc_hash_memory)
989 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
990 _bfd_elf_link_hash_table_free (obfd);
993 /* Create an X86-64 ELF linker hash table. */
995 static struct bfd_link_hash_table *
996 elf_x86_64_link_hash_table_create (bfd *abfd)
998 struct elf_x86_64_link_hash_table *ret;
999 bfd_size_type amt = sizeof (struct elf_x86_64_link_hash_table);
1001 ret = (struct elf_x86_64_link_hash_table *) bfd_zmalloc (amt);
1005 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
1006 elf_x86_64_link_hash_newfunc,
1007 sizeof (struct elf_x86_64_link_hash_entry),
1014 if (ABI_64_P (abfd))
1016 ret->r_info = elf64_r_info;
1017 ret->r_sym = elf64_r_sym;
1018 ret->pointer_r_type = R_X86_64_64;
1019 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
1020 ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
1024 ret->r_info = elf32_r_info;
1025 ret->r_sym = elf32_r_sym;
1026 ret->pointer_r_type = R_X86_64_32;
1027 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
1028 ret->dynamic_interpreter_size = sizeof ELF32_DYNAMIC_INTERPRETER;
1031 ret->loc_hash_table = htab_try_create (1024,
1032 elf_x86_64_local_htab_hash,
1033 elf_x86_64_local_htab_eq,
1035 ret->loc_hash_memory = objalloc_create ();
1036 if (!ret->loc_hash_table || !ret->loc_hash_memory)
1038 elf_x86_64_link_hash_table_free (abfd);
1041 ret->elf.root.hash_table_free = elf_x86_64_link_hash_table_free;
1043 return &ret->elf.root;
1046 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1047 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1051 elf_x86_64_create_dynamic_sections (bfd *dynobj,
1052 struct bfd_link_info *info)
1054 struct elf_x86_64_link_hash_table *htab;
1056 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1059 htab = elf_x86_64_hash_table (info);
1063 htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
1067 if (info->executable)
1069 /* Always allow copy relocs for building executables. */
1070 asection *s = bfd_get_linker_section (dynobj, ".rela.bss");
1073 const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
1074 s = bfd_make_section_anyway_with_flags (dynobj,
1076 (bed->dynamic_sec_flags
1079 || ! bfd_set_section_alignment (dynobj, s,
1080 bed->s->log_file_align))
1086 if (!info->no_ld_generated_unwind_info
1087 && htab->plt_eh_frame == NULL
1088 && htab->elf.splt != NULL)
1090 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
1091 | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1092 | SEC_LINKER_CREATED);
1094 = bfd_make_section_anyway_with_flags (dynobj, ".eh_frame", flags);
1095 if (htab->plt_eh_frame == NULL
1096 || !bfd_set_section_alignment (dynobj, htab->plt_eh_frame, 3))
1102 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1105 elf_x86_64_copy_indirect_symbol (struct bfd_link_info *info,
1106 struct elf_link_hash_entry *dir,
1107 struct elf_link_hash_entry *ind)
1109 struct elf_x86_64_link_hash_entry *edir, *eind;
1111 edir = (struct elf_x86_64_link_hash_entry *) dir;
1112 eind = (struct elf_x86_64_link_hash_entry *) ind;
1114 if (!edir->has_bnd_reloc)
1115 edir->has_bnd_reloc = eind->has_bnd_reloc;
1117 if (eind->dyn_relocs != NULL)
1119 if (edir->dyn_relocs != NULL)
1121 struct elf_dyn_relocs **pp;
1122 struct elf_dyn_relocs *p;
1124 /* Add reloc counts against the indirect sym to the direct sym
1125 list. Merge any entries against the same section. */
1126 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1128 struct elf_dyn_relocs *q;
1130 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1131 if (q->sec == p->sec)
1133 q->pc_count += p->pc_count;
1134 q->count += p->count;
1141 *pp = edir->dyn_relocs;
1144 edir->dyn_relocs = eind->dyn_relocs;
1145 eind->dyn_relocs = NULL;
1148 if (ind->root.type == bfd_link_hash_indirect
1149 && dir->got.refcount <= 0)
1151 edir->tls_type = eind->tls_type;
1152 eind->tls_type = GOT_UNKNOWN;
1155 if (ELIMINATE_COPY_RELOCS
1156 && ind->root.type != bfd_link_hash_indirect
1157 && dir->dynamic_adjusted)
1159 /* If called to transfer flags for a weakdef during processing
1160 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1161 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1162 dir->ref_dynamic |= ind->ref_dynamic;
1163 dir->ref_regular |= ind->ref_regular;
1164 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1165 dir->needs_plt |= ind->needs_plt;
1166 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1169 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1173 elf64_x86_64_elf_object_p (bfd *abfd)
1175 /* Set the right machine number for an x86-64 elf64 file. */
1176 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64);
1181 elf32_x86_64_elf_object_p (bfd *abfd)
1183 /* Set the right machine number for an x86-64 elf32 file. */
1184 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32);
1188 /* Return TRUE if the TLS access code sequence support transition
1192 elf_x86_64_check_tls_transition (bfd *abfd,
1193 struct bfd_link_info *info,
1196 Elf_Internal_Shdr *symtab_hdr,
1197 struct elf_link_hash_entry **sym_hashes,
1198 unsigned int r_type,
1199 const Elf_Internal_Rela *rel,
1200 const Elf_Internal_Rela *relend)
1203 unsigned long r_symndx;
1204 bfd_boolean largepic = FALSE;
1205 struct elf_link_hash_entry *h;
1207 struct elf_x86_64_link_hash_table *htab;
1209 /* Get the section contents. */
1210 if (contents == NULL)
1212 if (elf_section_data (sec)->this_hdr.contents != NULL)
1213 contents = elf_section_data (sec)->this_hdr.contents;
1216 /* FIXME: How to better handle error condition? */
1217 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1220 /* Cache the section contents for elf_link_input_bfd. */
1221 elf_section_data (sec)->this_hdr.contents = contents;
1225 htab = elf_x86_64_hash_table (info);
1226 offset = rel->r_offset;
1229 case R_X86_64_TLSGD:
1230 case R_X86_64_TLSLD:
1231 if ((rel + 1) >= relend)
1234 if (r_type == R_X86_64_TLSGD)
1236 /* Check transition from GD access model. For 64bit, only
1237 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1238 .word 0x6666; rex64; call __tls_get_addr
1239 can transit to different access model. For 32bit, only
1240 leaq foo@tlsgd(%rip), %rdi
1241 .word 0x6666; rex64; call __tls_get_addr
1242 can transit to different access model. For largepic
1244 leaq foo@tlsgd(%rip), %rdi
1245 movabsq $__tls_get_addr@pltoff, %rax
1249 static const unsigned char call[] = { 0x66, 0x66, 0x48, 0xe8 };
1250 static const unsigned char leaq[] = { 0x66, 0x48, 0x8d, 0x3d };
1252 if ((offset + 12) > sec->size)
1255 if (memcmp (contents + offset + 4, call, 4) != 0)
1257 if (!ABI_64_P (abfd)
1258 || (offset + 19) > sec->size
1260 || memcmp (contents + offset - 3, leaq + 1, 3) != 0
1261 || memcmp (contents + offset + 4, "\x48\xb8", 2) != 0
1262 || memcmp (contents + offset + 14, "\x48\x01\xd8\xff\xd0", 5)
1267 else if (ABI_64_P (abfd))
1270 || memcmp (contents + offset - 4, leaq, 4) != 0)
1276 || memcmp (contents + offset - 3, leaq + 1, 3) != 0)
1282 /* Check transition from LD access model. Only
1283 leaq foo@tlsld(%rip), %rdi;
1285 can transit to different access model. For largepic
1287 leaq foo@tlsld(%rip), %rdi
1288 movabsq $__tls_get_addr@pltoff, %rax
1292 static const unsigned char lea[] = { 0x48, 0x8d, 0x3d };
1294 if (offset < 3 || (offset + 9) > sec->size)
1297 if (memcmp (contents + offset - 3, lea, 3) != 0)
1300 if (0xe8 != *(contents + offset + 4))
1302 if (!ABI_64_P (abfd)
1303 || (offset + 19) > sec->size
1304 || memcmp (contents + offset + 4, "\x48\xb8", 2) != 0
1305 || memcmp (contents + offset + 14, "\x48\x01\xd8\xff\xd0", 5)
1312 r_symndx = htab->r_sym (rel[1].r_info);
1313 if (r_symndx < symtab_hdr->sh_info)
1316 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1317 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1318 may be versioned. */
1320 && h->root.root.string != NULL
1322 ? ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PLTOFF64
1323 : (ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PC32
1324 || ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PLT32))
1325 && (strncmp (h->root.root.string,
1326 "__tls_get_addr", 14) == 0));
1328 case R_X86_64_GOTTPOFF:
1329 /* Check transition from IE access model:
1330 mov foo@gottpoff(%rip), %reg
1331 add foo@gottpoff(%rip), %reg
1334 /* Check REX prefix first. */
1335 if (offset >= 3 && (offset + 4) <= sec->size)
1337 val = bfd_get_8 (abfd, contents + offset - 3);
1338 if (val != 0x48 && val != 0x4c)
1340 /* X32 may have 0x44 REX prefix or no REX prefix. */
1341 if (ABI_64_P (abfd))
1347 /* X32 may not have any REX prefix. */
1348 if (ABI_64_P (abfd))
1350 if (offset < 2 || (offset + 3) > sec->size)
1354 val = bfd_get_8 (abfd, contents + offset - 2);
1355 if (val != 0x8b && val != 0x03)
1358 val = bfd_get_8 (abfd, contents + offset - 1);
1359 return (val & 0xc7) == 5;
1361 case R_X86_64_GOTPC32_TLSDESC:
1362 /* Check transition from GDesc access model:
1363 leaq x@tlsdesc(%rip), %rax
1365 Make sure it's a leaq adding rip to a 32-bit offset
1366 into any register, although it's probably almost always
1369 if (offset < 3 || (offset + 4) > sec->size)
1372 val = bfd_get_8 (abfd, contents + offset - 3);
1373 if ((val & 0xfb) != 0x48)
1376 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1379 val = bfd_get_8 (abfd, contents + offset - 1);
1380 return (val & 0xc7) == 0x05;
1382 case R_X86_64_TLSDESC_CALL:
1383 /* Check transition from GDesc access model:
1384 call *x@tlsdesc(%rax)
1386 if (offset + 2 <= sec->size)
1388 /* Make sure that it's a call *x@tlsdesc(%rax). */
1389 static const unsigned char call[] = { 0xff, 0x10 };
1390 return memcmp (contents + offset, call, 2) == 0;
1400 /* Return TRUE if the TLS access transition is OK or no transition
1401 will be performed. Update R_TYPE if there is a transition. */
1404 elf_x86_64_tls_transition (struct bfd_link_info *info, bfd *abfd,
1405 asection *sec, bfd_byte *contents,
1406 Elf_Internal_Shdr *symtab_hdr,
1407 struct elf_link_hash_entry **sym_hashes,
1408 unsigned int *r_type, int tls_type,
1409 const Elf_Internal_Rela *rel,
1410 const Elf_Internal_Rela *relend,
1411 struct elf_link_hash_entry *h,
1412 unsigned long r_symndx)
1414 unsigned int from_type = *r_type;
1415 unsigned int to_type = from_type;
1416 bfd_boolean check = TRUE;
1418 /* Skip TLS transition for functions. */
1420 && (h->type == STT_FUNC
1421 || h->type == STT_GNU_IFUNC))
1426 case R_X86_64_TLSGD:
1427 case R_X86_64_GOTPC32_TLSDESC:
1428 case R_X86_64_TLSDESC_CALL:
1429 case R_X86_64_GOTTPOFF:
1430 if (info->executable)
1433 to_type = R_X86_64_TPOFF32;
1435 to_type = R_X86_64_GOTTPOFF;
1438 /* When we are called from elf_x86_64_relocate_section,
1439 CONTENTS isn't NULL and there may be additional transitions
1440 based on TLS_TYPE. */
1441 if (contents != NULL)
1443 unsigned int new_to_type = to_type;
1445 if (info->executable
1448 && tls_type == GOT_TLS_IE)
1449 new_to_type = R_X86_64_TPOFF32;
1451 if (to_type == R_X86_64_TLSGD
1452 || to_type == R_X86_64_GOTPC32_TLSDESC
1453 || to_type == R_X86_64_TLSDESC_CALL)
1455 if (tls_type == GOT_TLS_IE)
1456 new_to_type = R_X86_64_GOTTPOFF;
1459 /* We checked the transition before when we were called from
1460 elf_x86_64_check_relocs. We only want to check the new
1461 transition which hasn't been checked before. */
1462 check = new_to_type != to_type && from_type == to_type;
1463 to_type = new_to_type;
1468 case R_X86_64_TLSLD:
1469 if (info->executable)
1470 to_type = R_X86_64_TPOFF32;
1477 /* Return TRUE if there is no transition. */
1478 if (from_type == to_type)
1481 /* Check if the transition can be performed. */
1483 && ! elf_x86_64_check_tls_transition (abfd, info, sec, contents,
1484 symtab_hdr, sym_hashes,
1485 from_type, rel, relend))
1487 reloc_howto_type *from, *to;
1490 from = elf_x86_64_rtype_to_howto (abfd, from_type);
1491 to = elf_x86_64_rtype_to_howto (abfd, to_type);
1494 name = h->root.root.string;
1497 struct elf_x86_64_link_hash_table *htab;
1499 htab = elf_x86_64_hash_table (info);
1504 Elf_Internal_Sym *isym;
1506 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1508 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1512 (*_bfd_error_handler)
1513 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1514 "in section `%A' failed"),
1515 abfd, sec, from->name, to->name, name,
1516 (unsigned long) rel->r_offset);
1517 bfd_set_error (bfd_error_bad_value);
1525 /* Look through the relocs for a section during the first phase, and
1526 calculate needed space in the global offset table, procedure
1527 linkage table, and dynamic reloc sections. */
1530 elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info,
1532 const Elf_Internal_Rela *relocs)
1534 struct elf_x86_64_link_hash_table *htab;
1535 Elf_Internal_Shdr *symtab_hdr;
1536 struct elf_link_hash_entry **sym_hashes;
1537 const Elf_Internal_Rela *rel;
1538 const Elf_Internal_Rela *rel_end;
1541 if (info->relocatable)
1544 BFD_ASSERT (is_x86_64_elf (abfd));
1546 htab = elf_x86_64_hash_table (info);
1550 symtab_hdr = &elf_symtab_hdr (abfd);
1551 sym_hashes = elf_sym_hashes (abfd);
1555 rel_end = relocs + sec->reloc_count;
1556 for (rel = relocs; rel < rel_end; rel++)
1558 unsigned int r_type;
1559 unsigned long r_symndx;
1560 struct elf_link_hash_entry *h;
1561 Elf_Internal_Sym *isym;
1563 bfd_boolean size_reloc;
1565 r_symndx = htab->r_sym (rel->r_info);
1566 r_type = ELF32_R_TYPE (rel->r_info);
1568 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1570 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1575 if (r_symndx < symtab_hdr->sh_info)
1577 /* A local symbol. */
1578 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1583 /* Check relocation against local STT_GNU_IFUNC symbol. */
1584 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1586 h = elf_x86_64_get_local_sym_hash (htab, abfd, rel,
1591 /* Fake a STT_GNU_IFUNC symbol. */
1592 h->type = STT_GNU_IFUNC;
1595 h->forced_local = 1;
1596 h->root.type = bfd_link_hash_defined;
1604 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1605 while (h->root.type == bfd_link_hash_indirect
1606 || h->root.type == bfd_link_hash_warning)
1607 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1610 /* Check invalid x32 relocations. */
1611 if (!ABI_64_P (abfd))
1617 case R_X86_64_DTPOFF64:
1618 case R_X86_64_TPOFF64:
1620 case R_X86_64_GOTOFF64:
1621 case R_X86_64_GOT64:
1622 case R_X86_64_GOTPCREL64:
1623 case R_X86_64_GOTPC64:
1624 case R_X86_64_GOTPLT64:
1625 case R_X86_64_PLTOFF64:
1628 name = h->root.root.string;
1630 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1632 (*_bfd_error_handler)
1633 (_("%B: relocation %s against symbol `%s' isn't "
1634 "supported in x32 mode"), abfd,
1635 x86_64_elf_howto_table[r_type].name, name);
1636 bfd_set_error (bfd_error_bad_value);
1644 /* Create the ifunc sections for static executables. If we
1645 never see an indirect function symbol nor we are building
1646 a static executable, those sections will be empty and
1647 won't appear in output. */
1653 case R_X86_64_PC32_BND:
1654 case R_X86_64_PLT32_BND:
1656 case R_X86_64_PLT32:
1659 /* MPX PLT is supported only if elf_x86_64_arch_bed
1660 is used in 64-bit mode. */
1663 && (get_elf_x86_64_backend_data (abfd)
1664 == &elf_x86_64_arch_bed))
1666 elf_x86_64_hash_entry (h)->has_bnd_reloc = 1;
1668 /* Create the second PLT for Intel MPX support. */
1669 if (htab->plt_bnd == NULL)
1671 unsigned int plt_bnd_align;
1672 const struct elf_backend_data *bed;
1674 bed = get_elf_backend_data (info->output_bfd);
1675 switch (sizeof (elf_x86_64_bnd_plt2_entry))
1687 if (htab->elf.dynobj == NULL)
1688 htab->elf.dynobj = abfd;
1690 = bfd_make_section_anyway_with_flags (htab->elf.dynobj,
1692 (bed->dynamic_sec_flags
1697 if (htab->plt_bnd == NULL
1698 || !bfd_set_section_alignment (htab->elf.dynobj,
1707 case R_X86_64_GOTPCREL:
1708 case R_X86_64_GOTPCREL64:
1709 if (htab->elf.dynobj == NULL)
1710 htab->elf.dynobj = abfd;
1711 if (!_bfd_elf_create_ifunc_sections (htab->elf.dynobj, info))
1716 /* It is referenced by a non-shared object. */
1718 h->root.non_ir_ref = 1;
1721 if (! elf_x86_64_tls_transition (info, abfd, sec, NULL,
1722 symtab_hdr, sym_hashes,
1723 &r_type, GOT_UNKNOWN,
1724 rel, rel_end, h, r_symndx))
1729 case R_X86_64_TLSLD:
1730 htab->tls_ld_got.refcount += 1;
1733 case R_X86_64_TPOFF32:
1734 if (!info->executable && ABI_64_P (abfd))
1737 name = h->root.root.string;
1739 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1741 (*_bfd_error_handler)
1742 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1744 x86_64_elf_howto_table[r_type].name, name);
1745 bfd_set_error (bfd_error_bad_value);
1750 case R_X86_64_GOTTPOFF:
1751 if (!info->executable)
1752 info->flags |= DF_STATIC_TLS;
1755 case R_X86_64_GOT32:
1756 case R_X86_64_GOTPCREL:
1757 case R_X86_64_TLSGD:
1758 case R_X86_64_GOT64:
1759 case R_X86_64_GOTPCREL64:
1760 case R_X86_64_GOTPLT64:
1761 case R_X86_64_GOTPC32_TLSDESC:
1762 case R_X86_64_TLSDESC_CALL:
1763 /* This symbol requires a global offset table entry. */
1765 int tls_type, old_tls_type;
1769 default: tls_type = GOT_NORMAL; break;
1770 case R_X86_64_TLSGD: tls_type = GOT_TLS_GD; break;
1771 case R_X86_64_GOTTPOFF: tls_type = GOT_TLS_IE; break;
1772 case R_X86_64_GOTPC32_TLSDESC:
1773 case R_X86_64_TLSDESC_CALL:
1774 tls_type = GOT_TLS_GDESC; break;
1779 if (r_type == R_X86_64_GOTPLT64)
1781 /* This relocation indicates that we also need
1782 a PLT entry, as this is a function. We don't need
1783 a PLT entry for local symbols. */
1785 h->plt.refcount += 1;
1787 h->got.refcount += 1;
1788 old_tls_type = elf_x86_64_hash_entry (h)->tls_type;
1792 bfd_signed_vma *local_got_refcounts;
1794 /* This is a global offset table entry for a local symbol. */
1795 local_got_refcounts = elf_local_got_refcounts (abfd);
1796 if (local_got_refcounts == NULL)
1800 size = symtab_hdr->sh_info;
1801 size *= sizeof (bfd_signed_vma)
1802 + sizeof (bfd_vma) + sizeof (char);
1803 local_got_refcounts = ((bfd_signed_vma *)
1804 bfd_zalloc (abfd, size));
1805 if (local_got_refcounts == NULL)
1807 elf_local_got_refcounts (abfd) = local_got_refcounts;
1808 elf_x86_64_local_tlsdesc_gotent (abfd)
1809 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
1810 elf_x86_64_local_got_tls_type (abfd)
1811 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
1813 local_got_refcounts[r_symndx] += 1;
1815 = elf_x86_64_local_got_tls_type (abfd) [r_symndx];
1818 /* If a TLS symbol is accessed using IE at least once,
1819 there is no point to use dynamic model for it. */
1820 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1821 && (! GOT_TLS_GD_ANY_P (old_tls_type)
1822 || tls_type != GOT_TLS_IE))
1824 if (old_tls_type == GOT_TLS_IE && GOT_TLS_GD_ANY_P (tls_type))
1825 tls_type = old_tls_type;
1826 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1827 && GOT_TLS_GD_ANY_P (tls_type))
1828 tls_type |= old_tls_type;
1832 name = h->root.root.string;
1834 name = bfd_elf_sym_name (abfd, symtab_hdr,
1836 (*_bfd_error_handler)
1837 (_("%B: '%s' accessed both as normal and thread local symbol"),
1839 bfd_set_error (bfd_error_bad_value);
1844 if (old_tls_type != tls_type)
1847 elf_x86_64_hash_entry (h)->tls_type = tls_type;
1849 elf_x86_64_local_got_tls_type (abfd) [r_symndx] = tls_type;
1854 case R_X86_64_GOTOFF64:
1855 case R_X86_64_GOTPC32:
1856 case R_X86_64_GOTPC64:
1858 if (htab->elf.sgot == NULL)
1860 if (htab->elf.dynobj == NULL)
1861 htab->elf.dynobj = abfd;
1862 if (!_bfd_elf_create_got_section (htab->elf.dynobj,
1868 case R_X86_64_PLT32:
1869 case R_X86_64_PLT32_BND:
1870 /* This symbol requires a procedure linkage table entry. We
1871 actually build the entry in adjust_dynamic_symbol,
1872 because this might be a case of linking PIC code which is
1873 never referenced by a dynamic object, in which case we
1874 don't need to generate a procedure linkage table entry
1877 /* If this is a local symbol, we resolve it directly without
1878 creating a procedure linkage table entry. */
1883 h->plt.refcount += 1;
1886 case R_X86_64_PLTOFF64:
1887 /* This tries to form the 'address' of a function relative
1888 to GOT. For global symbols we need a PLT entry. */
1892 h->plt.refcount += 1;
1896 case R_X86_64_SIZE32:
1897 case R_X86_64_SIZE64:
1902 if (!ABI_64_P (abfd))
1907 /* Let's help debug shared library creation. These relocs
1908 cannot be used in shared libs. Don't error out for
1909 sections we don't care about, such as debug sections or
1910 non-constant sections. */
1912 && (sec->flags & SEC_ALLOC) != 0
1913 && (sec->flags & SEC_READONLY) != 0)
1916 name = h->root.root.string;
1918 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1919 (*_bfd_error_handler)
1920 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1921 abfd, x86_64_elf_howto_table[r_type].name, name);
1922 bfd_set_error (bfd_error_bad_value);
1930 case R_X86_64_PC32_BND:
1934 if (h != NULL && info->executable)
1936 /* If this reloc is in a read-only section, we might
1937 need a copy reloc. We can't check reliably at this
1938 stage whether the section is read-only, as input
1939 sections have not yet been mapped to output sections.
1940 Tentatively set the flag for now, and correct in
1941 adjust_dynamic_symbol. */
1944 /* We may need a .plt entry if the function this reloc
1945 refers to is in a shared lib. */
1946 h->plt.refcount += 1;
1947 if (r_type != R_X86_64_PC32
1948 && r_type != R_X86_64_PC32_BND
1949 && r_type != R_X86_64_PC64)
1950 h->pointer_equality_needed = 1;
1955 /* If we are creating a shared library, and this is a reloc
1956 against a global symbol, or a non PC relative reloc
1957 against a local symbol, then we need to copy the reloc
1958 into the shared library. However, if we are linking with
1959 -Bsymbolic, we do not need to copy a reloc against a
1960 global symbol which is defined in an object we are
1961 including in the link (i.e., DEF_REGULAR is set). At
1962 this point we have not seen all the input files, so it is
1963 possible that DEF_REGULAR is not set now but will be set
1964 later (it is never cleared). In case of a weak definition,
1965 DEF_REGULAR may be cleared later by a strong definition in
1966 a shared library. We account for that possibility below by
1967 storing information in the relocs_copied field of the hash
1968 table entry. A similar situation occurs when creating
1969 shared libraries and symbol visibility changes render the
1972 If on the other hand, we are creating an executable, we
1973 may need to keep relocations for symbols satisfied by a
1974 dynamic library if we manage to avoid copy relocs for the
1977 && (sec->flags & SEC_ALLOC) != 0
1978 && (! IS_X86_64_PCREL_TYPE (r_type)
1980 && (! SYMBOLIC_BIND (info, h)
1981 || h->root.type == bfd_link_hash_defweak
1982 || !h->def_regular))))
1983 || (ELIMINATE_COPY_RELOCS
1985 && (sec->flags & SEC_ALLOC) != 0
1987 && (h->root.type == bfd_link_hash_defweak
1988 || !h->def_regular)))
1990 struct elf_dyn_relocs *p;
1991 struct elf_dyn_relocs **head;
1993 /* We must copy these reloc types into the output file.
1994 Create a reloc section in dynobj and make room for
1998 if (htab->elf.dynobj == NULL)
1999 htab->elf.dynobj = abfd;
2001 sreloc = _bfd_elf_make_dynamic_reloc_section
2002 (sec, htab->elf.dynobj, ABI_64_P (abfd) ? 3 : 2,
2003 abfd, /*rela?*/ TRUE);
2009 /* If this is a global symbol, we count the number of
2010 relocations we need for this symbol. */
2013 head = &((struct elf_x86_64_link_hash_entry *) h)->dyn_relocs;
2017 /* Track dynamic relocs needed for local syms too.
2018 We really need local syms available to do this
2023 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2028 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
2032 /* Beware of type punned pointers vs strict aliasing
2034 vpp = &(elf_section_data (s)->local_dynrel);
2035 head = (struct elf_dyn_relocs **)vpp;
2039 if (p == NULL || p->sec != sec)
2041 bfd_size_type amt = sizeof *p;
2043 p = ((struct elf_dyn_relocs *)
2044 bfd_alloc (htab->elf.dynobj, amt));
2055 /* Count size relocation as PC-relative relocation. */
2056 if (IS_X86_64_PCREL_TYPE (r_type) || size_reloc)
2061 /* This relocation describes the C++ object vtable hierarchy.
2062 Reconstruct it for later use during GC. */
2063 case R_X86_64_GNU_VTINHERIT:
2064 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2068 /* This relocation describes which C++ vtable entries are actually
2069 used. Record for later use during GC. */
2070 case R_X86_64_GNU_VTENTRY:
2071 BFD_ASSERT (h != NULL);
2073 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2085 /* Return the section that should be marked against GC for a given
2089 elf_x86_64_gc_mark_hook (asection *sec,
2090 struct bfd_link_info *info,
2091 Elf_Internal_Rela *rel,
2092 struct elf_link_hash_entry *h,
2093 Elf_Internal_Sym *sym)
2096 switch (ELF32_R_TYPE (rel->r_info))
2098 case R_X86_64_GNU_VTINHERIT:
2099 case R_X86_64_GNU_VTENTRY:
2103 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2106 /* Update the got entry reference counts for the section being removed. */
2109 elf_x86_64_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
2111 const Elf_Internal_Rela *relocs)
2113 struct elf_x86_64_link_hash_table *htab;
2114 Elf_Internal_Shdr *symtab_hdr;
2115 struct elf_link_hash_entry **sym_hashes;
2116 bfd_signed_vma *local_got_refcounts;
2117 const Elf_Internal_Rela *rel, *relend;
2119 if (info->relocatable)
2122 htab = elf_x86_64_hash_table (info);
2126 elf_section_data (sec)->local_dynrel = NULL;
2128 symtab_hdr = &elf_symtab_hdr (abfd);
2129 sym_hashes = elf_sym_hashes (abfd);
2130 local_got_refcounts = elf_local_got_refcounts (abfd);
2132 htab = elf_x86_64_hash_table (info);
2133 relend = relocs + sec->reloc_count;
2134 for (rel = relocs; rel < relend; rel++)
2136 unsigned long r_symndx;
2137 unsigned int r_type;
2138 struct elf_link_hash_entry *h = NULL;
2140 r_symndx = htab->r_sym (rel->r_info);
2141 if (r_symndx >= symtab_hdr->sh_info)
2143 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2144 while (h->root.type == bfd_link_hash_indirect
2145 || h->root.type == bfd_link_hash_warning)
2146 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2150 /* A local symbol. */
2151 Elf_Internal_Sym *isym;
2153 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2156 /* Check relocation against local STT_GNU_IFUNC symbol. */
2158 && ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
2160 h = elf_x86_64_get_local_sym_hash (htab, abfd, rel, FALSE);
2168 struct elf_x86_64_link_hash_entry *eh;
2169 struct elf_dyn_relocs **pp;
2170 struct elf_dyn_relocs *p;
2172 eh = (struct elf_x86_64_link_hash_entry *) h;
2174 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
2177 /* Everything must go for SEC. */
2183 r_type = ELF32_R_TYPE (rel->r_info);
2184 if (! elf_x86_64_tls_transition (info, abfd, sec, NULL,
2185 symtab_hdr, sym_hashes,
2186 &r_type, GOT_UNKNOWN,
2187 rel, relend, h, r_symndx))
2192 case R_X86_64_TLSLD:
2193 if (htab->tls_ld_got.refcount > 0)
2194 htab->tls_ld_got.refcount -= 1;
2197 case R_X86_64_TLSGD:
2198 case R_X86_64_GOTPC32_TLSDESC:
2199 case R_X86_64_TLSDESC_CALL:
2200 case R_X86_64_GOTTPOFF:
2201 case R_X86_64_GOT32:
2202 case R_X86_64_GOTPCREL:
2203 case R_X86_64_GOT64:
2204 case R_X86_64_GOTPCREL64:
2205 case R_X86_64_GOTPLT64:
2208 if (r_type == R_X86_64_GOTPLT64 && h->plt.refcount > 0)
2209 h->plt.refcount -= 1;
2210 if (h->got.refcount > 0)
2211 h->got.refcount -= 1;
2212 if (h->type == STT_GNU_IFUNC)
2214 if (h->plt.refcount > 0)
2215 h->plt.refcount -= 1;
2218 else if (local_got_refcounts != NULL)
2220 if (local_got_refcounts[r_symndx] > 0)
2221 local_got_refcounts[r_symndx] -= 1;
2233 case R_X86_64_PC32_BND:
2235 case R_X86_64_SIZE32:
2236 case R_X86_64_SIZE64:
2238 && (h == NULL || h->type != STT_GNU_IFUNC))
2242 case R_X86_64_PLT32:
2243 case R_X86_64_PLT32_BND:
2244 case R_X86_64_PLTOFF64:
2247 if (h->plt.refcount > 0)
2248 h->plt.refcount -= 1;
2260 /* Adjust a symbol defined by a dynamic object and referenced by a
2261 regular object. The current definition is in some section of the
2262 dynamic object, but we're not including those sections. We have to
2263 change the definition to something the rest of the link can
2267 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info *info,
2268 struct elf_link_hash_entry *h)
2270 struct elf_x86_64_link_hash_table *htab;
2272 struct elf_x86_64_link_hash_entry *eh;
2273 struct elf_dyn_relocs *p;
2275 /* STT_GNU_IFUNC symbol must go through PLT. */
2276 if (h->type == STT_GNU_IFUNC)
2278 /* All local STT_GNU_IFUNC references must be treate as local
2279 calls via local PLT. */
2281 && SYMBOL_CALLS_LOCAL (info, h))
2283 bfd_size_type pc_count = 0, count = 0;
2284 struct elf_dyn_relocs **pp;
2286 eh = (struct elf_x86_64_link_hash_entry *) h;
2287 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2289 pc_count += p->pc_count;
2290 p->count -= p->pc_count;
2299 if (pc_count || count)
2303 if (h->plt.refcount <= 0)
2304 h->plt.refcount = 1;
2306 h->plt.refcount += 1;
2310 if (h->plt.refcount <= 0)
2312 h->plt.offset = (bfd_vma) -1;
2318 /* If this is a function, put it in the procedure linkage table. We
2319 will fill in the contents of the procedure linkage table later,
2320 when we know the address of the .got section. */
2321 if (h->type == STT_FUNC
2324 if (h->plt.refcount <= 0
2325 || SYMBOL_CALLS_LOCAL (info, h)
2326 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2327 && h->root.type == bfd_link_hash_undefweak))
2329 /* This case can occur if we saw a PLT32 reloc in an input
2330 file, but the symbol was never referred to by a dynamic
2331 object, or if all references were garbage collected. In
2332 such a case, we don't actually need to build a procedure
2333 linkage table, and we can just do a PC32 reloc instead. */
2334 h->plt.offset = (bfd_vma) -1;
2341 /* It's possible that we incorrectly decided a .plt reloc was
2342 needed for an R_X86_64_PC32 reloc to a non-function sym in
2343 check_relocs. We can't decide accurately between function and
2344 non-function syms in check-relocs; Objects loaded later in
2345 the link may change h->type. So fix it now. */
2346 h->plt.offset = (bfd_vma) -1;
2348 /* If this is a weak symbol, and there is a real definition, the
2349 processor independent code will have arranged for us to see the
2350 real definition first, and we can just use the same value. */
2351 if (h->u.weakdef != NULL)
2353 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2354 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2355 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2356 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2357 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
2359 eh = (struct elf_x86_64_link_hash_entry *) h;
2360 h->non_got_ref = h->u.weakdef->non_got_ref;
2361 eh->needs_copy = h->u.weakdef->needs_copy;
2366 /* This is a reference to a symbol defined by a dynamic object which
2367 is not a function. */
2369 /* If we are creating a shared library, we must presume that the
2370 only references to the symbol are via the global offset table.
2371 For such cases we need not do anything here; the relocations will
2372 be handled correctly by relocate_section. */
2373 if (!info->executable)
2376 /* If there are no references to this symbol that do not use the
2377 GOT, we don't need to generate a copy reloc. */
2378 if (!h->non_got_ref)
2381 /* If -z nocopyreloc was given, we won't generate them either. */
2382 if (info->nocopyreloc)
2388 if (ELIMINATE_COPY_RELOCS)
2390 eh = (struct elf_x86_64_link_hash_entry *) h;
2391 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2393 s = p->sec->output_section;
2394 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2398 /* If we didn't find any dynamic relocs in read-only sections, then
2399 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2407 /* We must allocate the symbol in our .dynbss section, which will
2408 become part of the .bss section of the executable. There will be
2409 an entry for this symbol in the .dynsym section. The dynamic
2410 object will contain position independent code, so all references
2411 from the dynamic object to this symbol will go through the global
2412 offset table. The dynamic linker will use the .dynsym entry to
2413 determine the address it must put in the global offset table, so
2414 both the dynamic object and the regular object will refer to the
2415 same memory location for the variable. */
2417 htab = elf_x86_64_hash_table (info);
2421 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2422 to copy the initial value out of the dynamic object and into the
2423 runtime process image. */
2424 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2426 const struct elf_backend_data *bed;
2427 bed = get_elf_backend_data (info->output_bfd);
2428 htab->srelbss->size += bed->s->sizeof_rela;
2434 return _bfd_elf_adjust_dynamic_copy (info, h, s);
2437 /* Allocate space in .plt, .got and associated reloc sections for
2441 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2443 struct bfd_link_info *info;
2444 struct elf_x86_64_link_hash_table *htab;
2445 struct elf_x86_64_link_hash_entry *eh;
2446 struct elf_dyn_relocs *p;
2447 const struct elf_backend_data *bed;
2448 unsigned int plt_entry_size;
2450 if (h->root.type == bfd_link_hash_indirect)
2453 eh = (struct elf_x86_64_link_hash_entry *) h;
2455 info = (struct bfd_link_info *) inf;
2456 htab = elf_x86_64_hash_table (info);
2459 bed = get_elf_backend_data (info->output_bfd);
2460 plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
2462 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2463 here if it is defined and referenced in a non-shared object. */
2464 if (h->type == STT_GNU_IFUNC
2467 if (_bfd_elf_allocate_ifunc_dyn_relocs (info, h,
2473 asection *s = htab->plt_bnd;
2474 if (h->plt.offset != (bfd_vma) -1 && s != NULL)
2476 /* Use the .plt.bnd section if it is created. */
2477 eh->plt_bnd.offset = s->size;
2479 /* Make room for this entry in the .plt.bnd section. */
2480 s->size += sizeof (elf_x86_64_legacy_plt2_entry);
2488 else if (htab->elf.dynamic_sections_created
2489 && h->plt.refcount > 0)
2491 /* Make sure this symbol is output as a dynamic symbol.
2492 Undefined weak syms won't yet be marked as dynamic. */
2493 if (h->dynindx == -1
2494 && !h->forced_local)
2496 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2501 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2503 asection *s = htab->elf.splt;
2504 asection *bnd_s = htab->plt_bnd;
2506 /* If this is the first .plt entry, make room for the special
2509 s->size = plt_entry_size;
2511 h->plt.offset = s->size;
2513 eh->plt_bnd.offset = bnd_s->size;
2515 /* If this symbol is not defined in a regular file, and we are
2516 not generating a shared library, then set the symbol to this
2517 location in the .plt. This is required to make function
2518 pointers compare as equal between the normal executable and
2519 the shared library. */
2525 /* We need to make a call to the entry of the second
2526 PLT instead of regular PLT entry. */
2527 h->root.u.def.section = bnd_s;
2528 h->root.u.def.value = eh->plt_bnd.offset;
2532 h->root.u.def.section = s;
2533 h->root.u.def.value = h->plt.offset;
2537 /* Make room for this entry. */
2538 s->size += plt_entry_size;
2541 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry)
2542 == sizeof (elf_x86_64_legacy_plt2_entry));
2543 bnd_s->size += sizeof (elf_x86_64_legacy_plt2_entry);
2546 /* We also need to make an entry in the .got.plt section, which
2547 will be placed in the .got section by the linker script. */
2548 htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
2550 /* We also need to make an entry in the .rela.plt section. */
2551 htab->elf.srelplt->size += bed->s->sizeof_rela;
2552 htab->elf.srelplt->reloc_count++;
2556 h->plt.offset = (bfd_vma) -1;
2562 h->plt.offset = (bfd_vma) -1;
2566 eh->tlsdesc_got = (bfd_vma) -1;
2568 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2569 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2570 if (h->got.refcount > 0
2573 && elf_x86_64_hash_entry (h)->tls_type == GOT_TLS_IE)
2575 h->got.offset = (bfd_vma) -1;
2577 else if (h->got.refcount > 0)
2581 int tls_type = elf_x86_64_hash_entry (h)->tls_type;
2583 /* Make sure this symbol is output as a dynamic symbol.
2584 Undefined weak syms won't yet be marked as dynamic. */
2585 if (h->dynindx == -1
2586 && !h->forced_local)
2588 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2592 if (GOT_TLS_GDESC_P (tls_type))
2594 eh->tlsdesc_got = htab->elf.sgotplt->size
2595 - elf_x86_64_compute_jump_table_size (htab);
2596 htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
2597 h->got.offset = (bfd_vma) -2;
2599 if (! GOT_TLS_GDESC_P (tls_type)
2600 || GOT_TLS_GD_P (tls_type))
2603 h->got.offset = s->size;
2604 s->size += GOT_ENTRY_SIZE;
2605 if (GOT_TLS_GD_P (tls_type))
2606 s->size += GOT_ENTRY_SIZE;
2608 dyn = htab->elf.dynamic_sections_created;
2609 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2611 R_X86_64_GOTTPOFF needs one dynamic relocation. */
2612 if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
2613 || tls_type == GOT_TLS_IE)
2614 htab->elf.srelgot->size += bed->s->sizeof_rela;
2615 else if (GOT_TLS_GD_P (tls_type))
2616 htab->elf.srelgot->size += 2 * bed->s->sizeof_rela;
2617 else if (! GOT_TLS_GDESC_P (tls_type)
2618 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2619 || h->root.type != bfd_link_hash_undefweak)
2621 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
2622 htab->elf.srelgot->size += bed->s->sizeof_rela;
2623 if (GOT_TLS_GDESC_P (tls_type))
2625 htab->elf.srelplt->size += bed->s->sizeof_rela;
2626 htab->tlsdesc_plt = (bfd_vma) -1;
2630 h->got.offset = (bfd_vma) -1;
2632 if (eh->dyn_relocs == NULL)
2635 /* In the shared -Bsymbolic case, discard space allocated for
2636 dynamic pc-relative relocs against symbols which turn out to be
2637 defined in regular objects. For the normal shared case, discard
2638 space for pc-relative relocs that have become local due to symbol
2639 visibility changes. */
2643 /* Relocs that use pc_count are those that appear on a call
2644 insn, or certain REL relocs that can generated via assembly.
2645 We want calls to protected symbols to resolve directly to the
2646 function rather than going via the plt. If people want
2647 function pointer comparisons to work as expected then they
2648 should avoid writing weird assembly. */
2649 if (SYMBOL_CALLS_LOCAL (info, h))
2651 struct elf_dyn_relocs **pp;
2653 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2655 p->count -= p->pc_count;
2664 /* Also discard relocs on undefined weak syms with non-default
2666 if (eh->dyn_relocs != NULL)
2668 if (h->root.type == bfd_link_hash_undefweak)
2670 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2671 eh->dyn_relocs = NULL;
2673 /* Make sure undefined weak symbols are output as a dynamic
2675 else if (h->dynindx == -1
2676 && ! h->forced_local
2677 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2680 /* For PIE, discard space for pc-relative relocs against
2681 symbols which turn out to need copy relocs. */
2682 else if (info->executable
2683 && (h->needs_copy || eh->needs_copy)
2687 struct elf_dyn_relocs **pp;
2689 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2691 if (p->pc_count != 0)
2699 else if (ELIMINATE_COPY_RELOCS)
2701 /* For the non-shared case, discard space for relocs against
2702 symbols which turn out to need copy relocs or are not
2708 || (htab->elf.dynamic_sections_created
2709 && (h->root.type == bfd_link_hash_undefweak
2710 || h->root.type == bfd_link_hash_undefined))))
2712 /* Make sure this symbol is output as a dynamic symbol.
2713 Undefined weak syms won't yet be marked as dynamic. */
2714 if (h->dynindx == -1
2715 && ! h->forced_local
2716 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2719 /* If that succeeded, we know we'll be keeping all the
2721 if (h->dynindx != -1)
2725 eh->dyn_relocs = NULL;
2730 /* Finally, allocate space. */
2731 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2735 sreloc = elf_section_data (p->sec)->sreloc;
2737 BFD_ASSERT (sreloc != NULL);
2739 sreloc->size += p->count * bed->s->sizeof_rela;
2745 /* Allocate space in .plt, .got and associated reloc sections for
2746 local dynamic relocs. */
2749 elf_x86_64_allocate_local_dynrelocs (void **slot, void *inf)
2751 struct elf_link_hash_entry *h
2752 = (struct elf_link_hash_entry *) *slot;
2754 if (h->type != STT_GNU_IFUNC
2758 || h->root.type != bfd_link_hash_defined)
2761 return elf_x86_64_allocate_dynrelocs (h, inf);
2764 /* Find any dynamic relocs that apply to read-only sections. */
2767 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry *h,
2770 struct elf_x86_64_link_hash_entry *eh;
2771 struct elf_dyn_relocs *p;
2773 /* Skip local IFUNC symbols. */
2774 if (h->forced_local && h->type == STT_GNU_IFUNC)
2777 eh = (struct elf_x86_64_link_hash_entry *) h;
2778 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2780 asection *s = p->sec->output_section;
2782 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2784 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2786 info->flags |= DF_TEXTREL;
2788 if (info->warn_shared_textrel && info->shared)
2789 info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2790 p->sec->owner, h->root.root.string,
2793 /* Not an error, just cut short the traversal. */
2801 mov foo@GOTPCREL(%rip), %reg
2804 with the local symbol, foo. */
2807 elf_x86_64_convert_mov_to_lea (bfd *abfd, asection *sec,
2808 struct bfd_link_info *link_info)
2810 Elf_Internal_Shdr *symtab_hdr;
2811 Elf_Internal_Rela *internal_relocs;
2812 Elf_Internal_Rela *irel, *irelend;
2814 struct elf_x86_64_link_hash_table *htab;
2815 bfd_boolean changed_contents;
2816 bfd_boolean changed_relocs;
2817 bfd_signed_vma *local_got_refcounts;
2819 /* Don't even try to convert non-ELF outputs. */
2820 if (!is_elf_hash_table (link_info->hash))
2823 /* Nothing to do if there are no codes, no relocations or no output. */
2824 if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
2825 || sec->reloc_count == 0
2826 || bfd_is_abs_section (sec->output_section))
2829 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2831 /* Load the relocations for this section. */
2832 internal_relocs = (_bfd_elf_link_read_relocs
2833 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
2834 link_info->keep_memory));
2835 if (internal_relocs == NULL)
2838 htab = elf_x86_64_hash_table (link_info);
2839 changed_contents = FALSE;
2840 changed_relocs = FALSE;
2841 local_got_refcounts = elf_local_got_refcounts (abfd);
2843 /* Get the section contents. */
2844 if (elf_section_data (sec)->this_hdr.contents != NULL)
2845 contents = elf_section_data (sec)->this_hdr.contents;
2848 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
2852 irelend = internal_relocs + sec->reloc_count;
2853 for (irel = internal_relocs; irel < irelend; irel++)
2855 unsigned int r_type = ELF32_R_TYPE (irel->r_info);
2856 unsigned int r_symndx = htab->r_sym (irel->r_info);
2858 struct elf_link_hash_entry *h;
2860 if (r_type != R_X86_64_GOTPCREL)
2863 /* Get the symbol referred to by the reloc. */
2864 if (r_symndx < symtab_hdr->sh_info)
2866 Elf_Internal_Sym *isym;
2868 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2871 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. */
2872 if (ELF_ST_TYPE (isym->st_info) != STT_GNU_IFUNC
2873 && bfd_get_8 (input_bfd,
2874 contents + irel->r_offset - 2) == 0x8b)
2876 bfd_put_8 (output_bfd, 0x8d,
2877 contents + irel->r_offset - 2);
2878 irel->r_info = htab->r_info (r_symndx, R_X86_64_PC32);
2879 if (local_got_refcounts != NULL
2880 && local_got_refcounts[r_symndx] > 0)
2881 local_got_refcounts[r_symndx] -= 1;
2882 changed_contents = TRUE;
2883 changed_relocs = TRUE;
2888 indx = r_symndx - symtab_hdr->sh_info;
2889 h = elf_sym_hashes (abfd)[indx];
2890 BFD_ASSERT (h != NULL);
2892 while (h->root.type == bfd_link_hash_indirect
2893 || h->root.type == bfd_link_hash_warning)
2894 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2896 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. We also
2897 avoid optimizing _DYNAMIC since ld.so may use its link-time
2900 && h->type != STT_GNU_IFUNC
2901 && h != htab->elf.hdynamic
2902 && SYMBOL_REFERENCES_LOCAL (link_info, h)
2903 && bfd_get_8 (input_bfd,
2904 contents + irel->r_offset - 2) == 0x8b)
2906 bfd_put_8 (output_bfd, 0x8d,
2907 contents + irel->r_offset - 2);
2908 irel->r_info = htab->r_info (r_symndx, R_X86_64_PC32);
2909 if (h->got.refcount > 0)
2910 h->got.refcount -= 1;
2911 changed_contents = TRUE;
2912 changed_relocs = TRUE;
2916 if (contents != NULL
2917 && elf_section_data (sec)->this_hdr.contents != contents)
2919 if (!changed_contents && !link_info->keep_memory)
2923 /* Cache the section contents for elf_link_input_bfd. */
2924 elf_section_data (sec)->this_hdr.contents = contents;
2928 if (elf_section_data (sec)->relocs != internal_relocs)
2930 if (!changed_relocs)
2931 free (internal_relocs);
2933 elf_section_data (sec)->relocs = internal_relocs;
2939 if (contents != NULL
2940 && elf_section_data (sec)->this_hdr.contents != contents)
2942 if (internal_relocs != NULL
2943 && elf_section_data (sec)->relocs != internal_relocs)
2944 free (internal_relocs);
2948 /* Set the sizes of the dynamic sections. */
2951 elf_x86_64_size_dynamic_sections (bfd *output_bfd,
2952 struct bfd_link_info *info)
2954 struct elf_x86_64_link_hash_table *htab;
2959 const struct elf_backend_data *bed;
2961 htab = elf_x86_64_hash_table (info);
2964 bed = get_elf_backend_data (output_bfd);
2966 dynobj = htab->elf.dynobj;
2970 if (htab->elf.dynamic_sections_created)
2972 /* Set the contents of the .interp section to the interpreter. */
2973 if (info->executable)
2975 s = bfd_get_linker_section (dynobj, ".interp");
2978 s->size = htab->dynamic_interpreter_size;
2979 s->contents = (unsigned char *) htab->dynamic_interpreter;
2983 /* Set up .got offsets for local syms, and space for local dynamic
2985 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2987 bfd_signed_vma *local_got;
2988 bfd_signed_vma *end_local_got;
2989 char *local_tls_type;
2990 bfd_vma *local_tlsdesc_gotent;
2991 bfd_size_type locsymcount;
2992 Elf_Internal_Shdr *symtab_hdr;
2995 if (! is_x86_64_elf (ibfd))
2998 for (s = ibfd->sections; s != NULL; s = s->next)
3000 struct elf_dyn_relocs *p;
3002 if (!elf_x86_64_convert_mov_to_lea (ibfd, s, info))
3005 for (p = (struct elf_dyn_relocs *)
3006 (elf_section_data (s)->local_dynrel);
3010 if (!bfd_is_abs_section (p->sec)
3011 && bfd_is_abs_section (p->sec->output_section))
3013 /* Input section has been discarded, either because
3014 it is a copy of a linkonce section or due to
3015 linker script /DISCARD/, so we'll be discarding
3018 else if (p->count != 0)
3020 srel = elf_section_data (p->sec)->sreloc;
3021 srel->size += p->count * bed->s->sizeof_rela;
3022 if ((p->sec->output_section->flags & SEC_READONLY) != 0
3023 && (info->flags & DF_TEXTREL) == 0)
3025 info->flags |= DF_TEXTREL;
3026 if (info->warn_shared_textrel && info->shared)
3027 info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
3028 p->sec->owner, p->sec);
3034 local_got = elf_local_got_refcounts (ibfd);
3038 symtab_hdr = &elf_symtab_hdr (ibfd);
3039 locsymcount = symtab_hdr->sh_info;
3040 end_local_got = local_got + locsymcount;
3041 local_tls_type = elf_x86_64_local_got_tls_type (ibfd);
3042 local_tlsdesc_gotent = elf_x86_64_local_tlsdesc_gotent (ibfd);
3044 srel = htab->elf.srelgot;
3045 for (; local_got < end_local_got;
3046 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
3048 *local_tlsdesc_gotent = (bfd_vma) -1;
3051 if (GOT_TLS_GDESC_P (*local_tls_type))
3053 *local_tlsdesc_gotent = htab->elf.sgotplt->size
3054 - elf_x86_64_compute_jump_table_size (htab);
3055 htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
3056 *local_got = (bfd_vma) -2;
3058 if (! GOT_TLS_GDESC_P (*local_tls_type)
3059 || GOT_TLS_GD_P (*local_tls_type))
3061 *local_got = s->size;
3062 s->size += GOT_ENTRY_SIZE;
3063 if (GOT_TLS_GD_P (*local_tls_type))
3064 s->size += GOT_ENTRY_SIZE;
3067 || GOT_TLS_GD_ANY_P (*local_tls_type)
3068 || *local_tls_type == GOT_TLS_IE)
3070 if (GOT_TLS_GDESC_P (*local_tls_type))
3072 htab->elf.srelplt->size
3073 += bed->s->sizeof_rela;
3074 htab->tlsdesc_plt = (bfd_vma) -1;
3076 if (! GOT_TLS_GDESC_P (*local_tls_type)
3077 || GOT_TLS_GD_P (*local_tls_type))
3078 srel->size += bed->s->sizeof_rela;
3082 *local_got = (bfd_vma) -1;
3086 if (htab->tls_ld_got.refcount > 0)
3088 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3090 htab->tls_ld_got.offset = htab->elf.sgot->size;
3091 htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
3092 htab->elf.srelgot->size += bed->s->sizeof_rela;
3095 htab->tls_ld_got.offset = -1;
3097 /* Allocate global sym .plt and .got entries, and space for global
3098 sym dynamic relocs. */
3099 elf_link_hash_traverse (&htab->elf, elf_x86_64_allocate_dynrelocs,
3102 /* Allocate .plt and .got entries, and space for local symbols. */
3103 htab_traverse (htab->loc_hash_table,
3104 elf_x86_64_allocate_local_dynrelocs,
3107 /* For every jump slot reserved in the sgotplt, reloc_count is
3108 incremented. However, when we reserve space for TLS descriptors,
3109 it's not incremented, so in order to compute the space reserved
3110 for them, it suffices to multiply the reloc count by the jump
3113 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3114 so that R_X86_64_IRELATIVE entries come last. */
3115 if (htab->elf.srelplt)
3117 htab->sgotplt_jump_table_size
3118 = elf_x86_64_compute_jump_table_size (htab);
3119 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
3121 else if (htab->elf.irelplt)
3122 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
3124 if (htab->tlsdesc_plt)
3126 /* If we're not using lazy TLS relocations, don't generate the
3127 PLT and GOT entries they require. */
3128 if ((info->flags & DF_BIND_NOW))
3129 htab->tlsdesc_plt = 0;
3132 htab->tlsdesc_got = htab->elf.sgot->size;
3133 htab->elf.sgot->size += GOT_ENTRY_SIZE;
3134 /* Reserve room for the initial entry.
3135 FIXME: we could probably do away with it in this case. */
3136 if (htab->elf.splt->size == 0)
3137 htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd);
3138 htab->tlsdesc_plt = htab->elf.splt->size;
3139 htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd);
3143 if (htab->elf.sgotplt)
3145 /* Don't allocate .got.plt section if there are no GOT nor PLT
3146 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3147 if ((htab->elf.hgot == NULL
3148 || !htab->elf.hgot->ref_regular_nonweak)
3149 && (htab->elf.sgotplt->size
3150 == get_elf_backend_data (output_bfd)->got_header_size)
3151 && (htab->elf.splt == NULL
3152 || htab->elf.splt->size == 0)
3153 && (htab->elf.sgot == NULL
3154 || htab->elf.sgot->size == 0)
3155 && (htab->elf.iplt == NULL
3156 || htab->elf.iplt->size == 0)
3157 && (htab->elf.igotplt == NULL
3158 || htab->elf.igotplt->size == 0))
3159 htab->elf.sgotplt->size = 0;
3162 if (htab->plt_eh_frame != NULL
3163 && htab->elf.splt != NULL
3164 && htab->elf.splt->size != 0
3165 && !bfd_is_abs_section (htab->elf.splt->output_section)
3166 && _bfd_elf_eh_frame_present (info))
3168 const struct elf_x86_64_backend_data *arch_data
3169 = get_elf_x86_64_arch_data (bed);
3170 htab->plt_eh_frame->size = arch_data->eh_frame_plt_size;
3173 /* We now have determined the sizes of the various dynamic sections.
3174 Allocate memory for them. */
3176 for (s = dynobj->sections; s != NULL; s = s->next)
3178 if ((s->flags & SEC_LINKER_CREATED) == 0)
3181 if (s == htab->elf.splt
3182 || s == htab->elf.sgot
3183 || s == htab->elf.sgotplt
3184 || s == htab->elf.iplt
3185 || s == htab->elf.igotplt
3186 || s == htab->plt_bnd
3187 || s == htab->plt_eh_frame
3188 || s == htab->sdynbss)
3190 /* Strip this section if we don't need it; see the
3193 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
3195 if (s->size != 0 && s != htab->elf.srelplt)
3198 /* We use the reloc_count field as a counter if we need
3199 to copy relocs into the output file. */
3200 if (s != htab->elf.srelplt)
3205 /* It's not one of our sections, so don't allocate space. */
3211 /* If we don't need this section, strip it from the
3212 output file. This is mostly to handle .rela.bss and
3213 .rela.plt. We must create both sections in
3214 create_dynamic_sections, because they must be created
3215 before the linker maps input sections to output
3216 sections. The linker does that before
3217 adjust_dynamic_symbol is called, and it is that
3218 function which decides whether anything needs to go
3219 into these sections. */
3221 s->flags |= SEC_EXCLUDE;
3225 if ((s->flags & SEC_HAS_CONTENTS) == 0)
3228 /* Allocate memory for the section contents. We use bfd_zalloc
3229 here in case unused entries are not reclaimed before the
3230 section's contents are written out. This should not happen,
3231 but this way if it does, we get a R_X86_64_NONE reloc instead
3233 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3234 if (s->contents == NULL)
3238 if (htab->plt_eh_frame != NULL
3239 && htab->plt_eh_frame->contents != NULL)
3241 const struct elf_x86_64_backend_data *arch_data
3242 = get_elf_x86_64_arch_data (bed);
3244 memcpy (htab->plt_eh_frame->contents,
3245 arch_data->eh_frame_plt, htab->plt_eh_frame->size);
3246 bfd_put_32 (dynobj, htab->elf.splt->size,
3247 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
3250 if (htab->elf.dynamic_sections_created)
3252 /* Add some entries to the .dynamic section. We fill in the
3253 values later, in elf_x86_64_finish_dynamic_sections, but we
3254 must add the entries now so that we get the correct size for
3255 the .dynamic section. The DT_DEBUG entry is filled in by the
3256 dynamic linker and used by the debugger. */
3257 #define add_dynamic_entry(TAG, VAL) \
3258 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3260 if (info->executable)
3262 if (!add_dynamic_entry (DT_DEBUG, 0))
3266 if (htab->elf.splt->size != 0)
3268 if (!add_dynamic_entry (DT_PLTGOT, 0)
3269 || !add_dynamic_entry (DT_PLTRELSZ, 0)
3270 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3271 || !add_dynamic_entry (DT_JMPREL, 0))
3274 if (htab->tlsdesc_plt
3275 && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
3276 || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
3282 if (!add_dynamic_entry (DT_RELA, 0)
3283 || !add_dynamic_entry (DT_RELASZ, 0)
3284 || !add_dynamic_entry (DT_RELAENT, bed->s->sizeof_rela))
3287 /* If any dynamic relocs apply to a read-only section,
3288 then we need a DT_TEXTREL entry. */
3289 if ((info->flags & DF_TEXTREL) == 0)
3290 elf_link_hash_traverse (&htab->elf,
3291 elf_x86_64_readonly_dynrelocs,
3294 if ((info->flags & DF_TEXTREL) != 0)
3296 if (!add_dynamic_entry (DT_TEXTREL, 0))
3301 #undef add_dynamic_entry
3307 elf_x86_64_always_size_sections (bfd *output_bfd,
3308 struct bfd_link_info *info)
3310 asection *tls_sec = elf_hash_table (info)->tls_sec;
3314 struct elf_link_hash_entry *tlsbase;
3316 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
3317 "_TLS_MODULE_BASE_",
3318 FALSE, FALSE, FALSE);
3320 if (tlsbase && tlsbase->type == STT_TLS)
3322 struct elf_x86_64_link_hash_table *htab;
3323 struct bfd_link_hash_entry *bh = NULL;
3324 const struct elf_backend_data *bed
3325 = get_elf_backend_data (output_bfd);
3327 htab = elf_x86_64_hash_table (info);
3331 if (!(_bfd_generic_link_add_one_symbol
3332 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
3333 tls_sec, 0, NULL, FALSE,
3334 bed->collect, &bh)))
3337 htab->tls_module_base = bh;
3339 tlsbase = (struct elf_link_hash_entry *)bh;
3340 tlsbase->def_regular = 1;
3341 tlsbase->other = STV_HIDDEN;
3342 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
3349 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3350 executables. Rather than setting it to the beginning of the TLS
3351 section, we have to set it to the end. This function may be called
3352 multiple times, it is idempotent. */
3355 elf_x86_64_set_tls_module_base (struct bfd_link_info *info)
3357 struct elf_x86_64_link_hash_table *htab;
3358 struct bfd_link_hash_entry *base;
3360 if (!info->executable)
3363 htab = elf_x86_64_hash_table (info);
3367 base = htab->tls_module_base;
3371 base->u.def.value = htab->elf.tls_size;
3374 /* Return the base VMA address which should be subtracted from real addresses
3375 when resolving @dtpoff relocation.
3376 This is PT_TLS segment p_vaddr. */
3379 elf_x86_64_dtpoff_base (struct bfd_link_info *info)
3381 /* If tls_sec is NULL, we should have signalled an error already. */
3382 if (elf_hash_table (info)->tls_sec == NULL)
3384 return elf_hash_table (info)->tls_sec->vma;
3387 /* Return the relocation value for @tpoff relocation
3388 if STT_TLS virtual address is ADDRESS. */
3391 elf_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address)
3393 struct elf_link_hash_table *htab = elf_hash_table (info);
3394 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3395 bfd_vma static_tls_size;
3397 /* If tls_segment is NULL, we should have signalled an error already. */
3398 if (htab->tls_sec == NULL)
3401 /* Consider special static TLS alignment requirements. */
3402 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3403 return address - static_tls_size - htab->tls_sec->vma;
3406 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
3410 is_32bit_relative_branch (bfd_byte *contents, bfd_vma offset)
3412 /* Opcode Instruction
3415 0x0f 0x8x conditional jump */
3417 && (contents [offset - 1] == 0xe8
3418 || contents [offset - 1] == 0xe9))
3420 && contents [offset - 2] == 0x0f
3421 && (contents [offset - 1] & 0xf0) == 0x80));
3424 /* Relocate an x86_64 ELF section. */
3427 elf_x86_64_relocate_section (bfd *output_bfd,
3428 struct bfd_link_info *info,
3430 asection *input_section,
3432 Elf_Internal_Rela *relocs,
3433 Elf_Internal_Sym *local_syms,
3434 asection **local_sections)
3436 struct elf_x86_64_link_hash_table *htab;
3437 Elf_Internal_Shdr *symtab_hdr;
3438 struct elf_link_hash_entry **sym_hashes;
3439 bfd_vma *local_got_offsets;
3440 bfd_vma *local_tlsdesc_gotents;
3441 Elf_Internal_Rela *rel;
3442 Elf_Internal_Rela *relend;
3443 const unsigned int plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
3445 BFD_ASSERT (is_x86_64_elf (input_bfd));
3447 htab = elf_x86_64_hash_table (info);
3450 symtab_hdr = &elf_symtab_hdr (input_bfd);
3451 sym_hashes = elf_sym_hashes (input_bfd);
3452 local_got_offsets = elf_local_got_offsets (input_bfd);
3453 local_tlsdesc_gotents = elf_x86_64_local_tlsdesc_gotent (input_bfd);
3455 elf_x86_64_set_tls_module_base (info);
3458 relend = relocs + input_section->reloc_count;
3459 for (; rel < relend; rel++)
3461 unsigned int r_type;
3462 reloc_howto_type *howto;
3463 unsigned long r_symndx;
3464 struct elf_link_hash_entry *h;
3465 struct elf_x86_64_link_hash_entry *eh;
3466 Elf_Internal_Sym *sym;
3468 bfd_vma off, offplt, plt_offset;
3470 bfd_boolean unresolved_reloc;
3471 bfd_reloc_status_type r;
3473 asection *base_got, *resolved_plt;
3476 r_type = ELF32_R_TYPE (rel->r_info);
3477 if (r_type == (int) R_X86_64_GNU_VTINHERIT
3478 || r_type == (int) R_X86_64_GNU_VTENTRY)
3481 if (r_type >= (int) R_X86_64_standard)
3483 (*_bfd_error_handler)
3484 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3485 input_bfd, input_section, r_type);
3486 bfd_set_error (bfd_error_bad_value);
3490 if (r_type != (int) R_X86_64_32
3491 || ABI_64_P (output_bfd))
3492 howto = x86_64_elf_howto_table + r_type;
3494 howto = (x86_64_elf_howto_table
3495 + ARRAY_SIZE (x86_64_elf_howto_table) - 1);
3496 r_symndx = htab->r_sym (rel->r_info);
3500 unresolved_reloc = FALSE;
3501 if (r_symndx < symtab_hdr->sh_info)
3503 sym = local_syms + r_symndx;
3504 sec = local_sections[r_symndx];
3506 relocation = _bfd_elf_rela_local_sym (output_bfd, sym,
3508 st_size = sym->st_size;
3510 /* Relocate against local STT_GNU_IFUNC symbol. */
3511 if (!info->relocatable
3512 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3514 h = elf_x86_64_get_local_sym_hash (htab, input_bfd,
3519 /* Set STT_GNU_IFUNC symbol value. */
3520 h->root.u.def.value = sym->st_value;
3521 h->root.u.def.section = sec;
3526 bfd_boolean warned ATTRIBUTE_UNUSED;
3527 bfd_boolean ignored ATTRIBUTE_UNUSED;
3529 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3530 r_symndx, symtab_hdr, sym_hashes,
3532 unresolved_reloc, warned, ignored);
3536 if (sec != NULL && discarded_section (sec))
3537 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3538 rel, 1, relend, howto, 0, contents);
3540 if (info->relocatable)
3543 if (rel->r_addend == 0 && !ABI_64_P (output_bfd))
3545 if (r_type == R_X86_64_64)
3547 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
3548 zero-extend it to 64bit if addend is zero. */
3549 r_type = R_X86_64_32;
3550 memset (contents + rel->r_offset + 4, 0, 4);
3552 else if (r_type == R_X86_64_SIZE64)
3554 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
3555 zero-extend it to 64bit if addend is zero. */
3556 r_type = R_X86_64_SIZE32;
3557 memset (contents + rel->r_offset + 4, 0, 4);
3561 eh = (struct elf_x86_64_link_hash_entry *) h;
3563 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3564 it here if it is defined in a non-shared object. */
3566 && h->type == STT_GNU_IFUNC
3572 if ((input_section->flags & SEC_ALLOC) == 0
3573 || h->plt.offset == (bfd_vma) -1)
3576 /* STT_GNU_IFUNC symbol must go through PLT. */
3577 if (htab->elf.splt != NULL)
3579 if (htab->plt_bnd != NULL)
3581 resolved_plt = htab->plt_bnd;
3582 plt_offset = eh->plt_bnd.offset;
3586 resolved_plt = htab->elf.splt;
3587 plt_offset = h->plt.offset;
3592 resolved_plt = htab->elf.iplt;
3593 plt_offset = h->plt.offset;
3596 relocation = (resolved_plt->output_section->vma
3597 + resolved_plt->output_offset + plt_offset);
3602 if (h->root.root.string)
3603 name = h->root.root.string;
3605 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3607 (*_bfd_error_handler)
3608 (_("%B: relocation %s against STT_GNU_IFUNC "
3609 "symbol `%s' isn't handled by %s"), input_bfd,
3610 x86_64_elf_howto_table[r_type].name,
3611 name, __FUNCTION__);
3612 bfd_set_error (bfd_error_bad_value);
3621 if (ABI_64_P (output_bfd))
3625 if (rel->r_addend != 0)
3627 if (h->root.root.string)
3628 name = h->root.root.string;
3630 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
3632 (*_bfd_error_handler)
3633 (_("%B: relocation %s against STT_GNU_IFUNC "
3634 "symbol `%s' has non-zero addend: %d"),
3635 input_bfd, x86_64_elf_howto_table[r_type].name,
3636 name, rel->r_addend);
3637 bfd_set_error (bfd_error_bad_value);
3641 /* Generate dynamic relcoation only when there is a
3642 non-GOT reference in a shared object. */
3643 if (info->shared && h->non_got_ref)
3645 Elf_Internal_Rela outrel;
3648 /* Need a dynamic relocation to get the real function
3650 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
3654 if (outrel.r_offset == (bfd_vma) -1
3655 || outrel.r_offset == (bfd_vma) -2)
3658 outrel.r_offset += (input_section->output_section->vma
3659 + input_section->output_offset);
3661 if (h->dynindx == -1
3663 || info->executable)
3665 /* This symbol is resolved locally. */
3666 outrel.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
3667 outrel.r_addend = (h->root.u.def.value
3668 + h->root.u.def.section->output_section->vma
3669 + h->root.u.def.section->output_offset);
3673 outrel.r_info = htab->r_info (h->dynindx, r_type);
3674 outrel.r_addend = 0;
3677 sreloc = htab->elf.irelifunc;
3678 elf_append_rela (output_bfd, sreloc, &outrel);
3680 /* If this reloc is against an external symbol, we
3681 do not want to fiddle with the addend. Otherwise,
3682 we need to include the symbol value so that it
3683 becomes an addend for the dynamic reloc. For an
3684 internal symbol, we have updated addend. */
3689 case R_X86_64_PC32_BND:
3691 case R_X86_64_PLT32:
3692 case R_X86_64_PLT32_BND:
3695 case R_X86_64_GOTPCREL:
3696 case R_X86_64_GOTPCREL64:
3697 base_got = htab->elf.sgot;
3698 off = h->got.offset;
3700 if (base_got == NULL)
3703 if (off == (bfd_vma) -1)
3705 /* We can't use h->got.offset here to save state, or
3706 even just remember the offset, as finish_dynamic_symbol
3707 would use that as offset into .got. */
3709 if (htab->elf.splt != NULL)
3711 plt_index = h->plt.offset / plt_entry_size - 1;
3712 off = (plt_index + 3) * GOT_ENTRY_SIZE;
3713 base_got = htab->elf.sgotplt;
3717 plt_index = h->plt.offset / plt_entry_size;
3718 off = plt_index * GOT_ENTRY_SIZE;
3719 base_got = htab->elf.igotplt;
3722 if (h->dynindx == -1
3726 /* This references the local defitionion. We must
3727 initialize this entry in the global offset table.
3728 Since the offset must always be a multiple of 8,
3729 we use the least significant bit to record
3730 whether we have initialized it already.
3732 When doing a dynamic link, we create a .rela.got
3733 relocation entry to initialize the value. This
3734 is done in the finish_dynamic_symbol routine. */
3739 bfd_put_64 (output_bfd, relocation,
3740 base_got->contents + off);
3741 /* Note that this is harmless for the GOTPLT64
3742 case, as -1 | 1 still is -1. */
3748 relocation = (base_got->output_section->vma
3749 + base_got->output_offset + off);
3755 /* When generating a shared object, the relocations handled here are
3756 copied into the output file to be resolved at run time. */
3759 case R_X86_64_GOT32:
3760 case R_X86_64_GOT64:
3761 /* Relocation is to the entry for this symbol in the global
3763 case R_X86_64_GOTPCREL:
3764 case R_X86_64_GOTPCREL64:
3765 /* Use global offset table entry as symbol value. */
3766 case R_X86_64_GOTPLT64:
3767 /* This is the same as GOT64 for relocation purposes, but
3768 indicates the existence of a PLT entry. The difficulty is,
3769 that we must calculate the GOT slot offset from the PLT
3770 offset, if this symbol got a PLT entry (it was global).
3771 Additionally if it's computed from the PLT entry, then that
3772 GOT offset is relative to .got.plt, not to .got. */
3773 base_got = htab->elf.sgot;
3775 if (htab->elf.sgot == NULL)
3782 off = h->got.offset;
3784 && h->plt.offset != (bfd_vma)-1
3785 && off == (bfd_vma)-1)
3787 /* We can't use h->got.offset here to save
3788 state, or even just remember the offset, as
3789 finish_dynamic_symbol would use that as offset into
3791 bfd_vma plt_index = h->plt.offset / plt_entry_size - 1;
3792 off = (plt_index + 3) * GOT_ENTRY_SIZE;
3793 base_got = htab->elf.sgotplt;
3796 dyn = htab->elf.dynamic_sections_created;
3798 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3800 && SYMBOL_REFERENCES_LOCAL (info, h))
3801 || (ELF_ST_VISIBILITY (h->other)
3802 && h->root.type == bfd_link_hash_undefweak))
3804 /* This is actually a static link, or it is a -Bsymbolic
3805 link and the symbol is defined locally, or the symbol
3806 was forced to be local because of a version file. We
3807 must initialize this entry in the global offset table.
3808 Since the offset must always be a multiple of 8, we
3809 use the least significant bit to record whether we
3810 have initialized it already.
3812 When doing a dynamic link, we create a .rela.got
3813 relocation entry to initialize the value. This is
3814 done in the finish_dynamic_symbol routine. */
3819 bfd_put_64 (output_bfd, relocation,
3820 base_got->contents + off);
3821 /* Note that this is harmless for the GOTPLT64 case,
3822 as -1 | 1 still is -1. */
3827 unresolved_reloc = FALSE;
3831 if (local_got_offsets == NULL)
3834 off = local_got_offsets[r_symndx];
3836 /* The offset must always be a multiple of 8. We use
3837 the least significant bit to record whether we have
3838 already generated the necessary reloc. */
3843 bfd_put_64 (output_bfd, relocation,
3844 base_got->contents + off);
3849 Elf_Internal_Rela outrel;
3851 /* We need to generate a R_X86_64_RELATIVE reloc
3852 for the dynamic linker. */
3853 s = htab->elf.srelgot;
3857 outrel.r_offset = (base_got->output_section->vma
3858 + base_got->output_offset
3860 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
3861 outrel.r_addend = relocation;
3862 elf_append_rela (output_bfd, s, &outrel);
3865 local_got_offsets[r_symndx] |= 1;
3869 if (off >= (bfd_vma) -2)
3872 relocation = base_got->output_section->vma
3873 + base_got->output_offset + off;
3874 if (r_type != R_X86_64_GOTPCREL && r_type != R_X86_64_GOTPCREL64)
3875 relocation -= htab->elf.sgotplt->output_section->vma
3876 - htab->elf.sgotplt->output_offset;
3880 case R_X86_64_GOTOFF64:
3881 /* Relocation is relative to the start of the global offset
3884 /* Check to make sure it isn't a protected function symbol
3885 for shared library since it may not be local when used
3886 as function address. */
3887 if (!info->executable
3889 && !SYMBOLIC_BIND (info, h)
3891 && h->type == STT_FUNC
3892 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
3894 (*_bfd_error_handler)
3895 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
3896 input_bfd, h->root.root.string);
3897 bfd_set_error (bfd_error_bad_value);
3901 /* Note that sgot is not involved in this
3902 calculation. We always want the start of .got.plt. If we
3903 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3904 permitted by the ABI, we might have to change this
3906 relocation -= htab->elf.sgotplt->output_section->vma
3907 + htab->elf.sgotplt->output_offset;
3910 case R_X86_64_GOTPC32:
3911 case R_X86_64_GOTPC64:
3912 /* Use global offset table as symbol value. */
3913 relocation = htab->elf.sgotplt->output_section->vma
3914 + htab->elf.sgotplt->output_offset;
3915 unresolved_reloc = FALSE;
3918 case R_X86_64_PLTOFF64:
3919 /* Relocation is PLT entry relative to GOT. For local
3920 symbols it's the symbol itself relative to GOT. */
3922 /* See PLT32 handling. */
3923 && h->plt.offset != (bfd_vma) -1
3924 && htab->elf.splt != NULL)
3926 if (htab->plt_bnd != NULL)
3928 resolved_plt = htab->plt_bnd;
3929 plt_offset = eh->plt_bnd.offset;
3933 resolved_plt = htab->elf.splt;
3934 plt_offset = h->plt.offset;
3937 relocation = (resolved_plt->output_section->vma
3938 + resolved_plt->output_offset
3940 unresolved_reloc = FALSE;
3943 relocation -= htab->elf.sgotplt->output_section->vma
3944 + htab->elf.sgotplt->output_offset;
3947 case R_X86_64_PLT32:
3948 case R_X86_64_PLT32_BND:
3949 /* Relocation is to the entry for this symbol in the
3950 procedure linkage table. */
3952 /* Resolve a PLT32 reloc against a local symbol directly,
3953 without using the procedure linkage table. */
3957 if (h->plt.offset == (bfd_vma) -1
3958 || htab->elf.splt == NULL)
3960 /* We didn't make a PLT entry for this symbol. This
3961 happens when statically linking PIC code, or when
3962 using -Bsymbolic. */
3966 if (htab->plt_bnd != NULL)
3968 resolved_plt = htab->plt_bnd;
3969 plt_offset = eh->plt_bnd.offset;
3973 resolved_plt = htab->elf.splt;
3974 plt_offset = h->plt.offset;
3977 relocation = (resolved_plt->output_section->vma
3978 + resolved_plt->output_offset
3980 unresolved_reloc = FALSE;
3983 case R_X86_64_SIZE32:
3984 case R_X86_64_SIZE64:
3985 /* Set to symbol size. */
3986 relocation = st_size;
3992 case R_X86_64_PC32_BND:
3994 && (input_section->flags & SEC_ALLOC) != 0
3995 && (input_section->flags & SEC_READONLY) != 0
3998 bfd_boolean fail = FALSE;
4000 = ((r_type == R_X86_64_PC32
4001 || r_type == R_X86_64_PC32_BND)
4002 && is_32bit_relative_branch (contents, rel->r_offset));
4004 if (SYMBOL_REFERENCES_LOCAL (info, h))
4006 /* Symbol is referenced locally. Make sure it is
4007 defined locally or for a branch. */
4008 fail = !h->def_regular && !branch;
4010 else if (!(info->executable
4011 && (h->needs_copy || eh->needs_copy)))
4013 /* Symbol doesn't need copy reloc and isn't referenced
4014 locally. We only allow branch to symbol with
4015 non-default visibility. */
4017 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT);
4024 const char *pic = "";
4026 switch (ELF_ST_VISIBILITY (h->other))
4029 v = _("hidden symbol");
4032 v = _("internal symbol");
4035 v = _("protected symbol");
4039 pic = _("; recompile with -fPIC");
4044 fmt = _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
4046 fmt = _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
4048 (*_bfd_error_handler) (fmt, input_bfd,
4049 x86_64_elf_howto_table[r_type].name,
4050 v, h->root.root.string, pic);
4051 bfd_set_error (bfd_error_bad_value);
4062 /* FIXME: The ABI says the linker should make sure the value is
4063 the same when it's zeroextended to 64 bit. */
4066 if ((input_section->flags & SEC_ALLOC) == 0)
4069 /* Don't copy a pc-relative relocation into the output file
4070 if the symbol needs copy reloc. */
4072 && !(info->executable
4074 && (h->needs_copy || eh->needs_copy)
4075 && IS_X86_64_PCREL_TYPE (r_type))
4077 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4078 || h->root.type != bfd_link_hash_undefweak)
4079 && ((! IS_X86_64_PCREL_TYPE (r_type)
4080 && r_type != R_X86_64_SIZE32
4081 && r_type != R_X86_64_SIZE64)
4082 || ! SYMBOL_CALLS_LOCAL (info, h)))
4083 || (ELIMINATE_COPY_RELOCS
4090 || h->root.type == bfd_link_hash_undefweak
4091 || h->root.type == bfd_link_hash_undefined)))
4093 Elf_Internal_Rela outrel;
4094 bfd_boolean skip, relocate;
4097 /* When generating a shared object, these relocations
4098 are copied into the output file to be resolved at run
4104 _bfd_elf_section_offset (output_bfd, info, input_section,
4106 if (outrel.r_offset == (bfd_vma) -1)
4108 else if (outrel.r_offset == (bfd_vma) -2)
4109 skip = TRUE, relocate = TRUE;
4111 outrel.r_offset += (input_section->output_section->vma
4112 + input_section->output_offset);
4115 memset (&outrel, 0, sizeof outrel);
4117 /* h->dynindx may be -1 if this symbol was marked to
4121 && (IS_X86_64_PCREL_TYPE (r_type)
4123 || ! SYMBOLIC_BIND (info, h)
4124 || ! h->def_regular))
4126 outrel.r_info = htab->r_info (h->dynindx, r_type);
4127 outrel.r_addend = rel->r_addend;
4131 /* This symbol is local, or marked to become local. */
4132 if (r_type == htab->pointer_r_type)
4135 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
4136 outrel.r_addend = relocation + rel->r_addend;
4138 else if (r_type == R_X86_64_64
4139 && !ABI_64_P (output_bfd))
4142 outrel.r_info = htab->r_info (0,
4143 R_X86_64_RELATIVE64);
4144 outrel.r_addend = relocation + rel->r_addend;
4145 /* Check addend overflow. */
4146 if ((outrel.r_addend & 0x80000000)
4147 != (rel->r_addend & 0x80000000))
4150 int addend = rel->r_addend;
4151 if (h && h->root.root.string)
4152 name = h->root.root.string;
4154 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
4157 (*_bfd_error_handler)
4158 (_("%B: addend -0x%x in relocation %s against "
4159 "symbol `%s' at 0x%lx in section `%A' is "
4161 input_bfd, input_section, addend,
4162 x86_64_elf_howto_table[r_type].name,
4163 name, (unsigned long) rel->r_offset);
4165 (*_bfd_error_handler)
4166 (_("%B: addend 0x%x in relocation %s against "
4167 "symbol `%s' at 0x%lx in section `%A' is "
4169 input_bfd, input_section, addend,
4170 x86_64_elf_howto_table[r_type].name,
4171 name, (unsigned long) rel->r_offset);
4172 bfd_set_error (bfd_error_bad_value);
4180 if (bfd_is_abs_section (sec))
4182 else if (sec == NULL || sec->owner == NULL)
4184 bfd_set_error (bfd_error_bad_value);
4191 /* We are turning this relocation into one
4192 against a section symbol. It would be
4193 proper to subtract the symbol's value,
4194 osec->vma, from the emitted reloc addend,
4195 but ld.so expects buggy relocs. */
4196 osec = sec->output_section;
4197 sindx = elf_section_data (osec)->dynindx;
4200 asection *oi = htab->elf.text_index_section;
4201 sindx = elf_section_data (oi)->dynindx;
4203 BFD_ASSERT (sindx != 0);
4206 outrel.r_info = htab->r_info (sindx, r_type);
4207 outrel.r_addend = relocation + rel->r_addend;
4211 sreloc = elf_section_data (input_section)->sreloc;
4213 if (sreloc == NULL || sreloc->contents == NULL)
4215 r = bfd_reloc_notsupported;
4216 goto check_relocation_error;
4219 elf_append_rela (output_bfd, sreloc, &outrel);
4221 /* If this reloc is against an external symbol, we do
4222 not want to fiddle with the addend. Otherwise, we
4223 need to include the symbol value so that it becomes
4224 an addend for the dynamic reloc. */
4231 case R_X86_64_TLSGD:
4232 case R_X86_64_GOTPC32_TLSDESC:
4233 case R_X86_64_TLSDESC_CALL:
4234 case R_X86_64_GOTTPOFF:
4235 tls_type = GOT_UNKNOWN;
4236 if (h == NULL && local_got_offsets)
4237 tls_type = elf_x86_64_local_got_tls_type (input_bfd) [r_symndx];
4239 tls_type = elf_x86_64_hash_entry (h)->tls_type;
4241 if (! elf_x86_64_tls_transition (info, input_bfd,
4242 input_section, contents,
4243 symtab_hdr, sym_hashes,
4244 &r_type, tls_type, rel,
4245 relend, h, r_symndx))
4248 if (r_type == R_X86_64_TPOFF32)
4250 bfd_vma roff = rel->r_offset;
4252 BFD_ASSERT (! unresolved_reloc);
4254 if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
4256 /* GD->LE transition. For 64bit, change
4257 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4258 .word 0x6666; rex64; call __tls_get_addr
4261 leaq foo@tpoff(%rax), %rax
4263 leaq foo@tlsgd(%rip), %rdi
4264 .word 0x6666; rex64; call __tls_get_addr
4267 leaq foo@tpoff(%rax), %rax
4268 For largepic, change:
4269 leaq foo@tlsgd(%rip), %rdi
4270 movabsq $__tls_get_addr@pltoff, %rax
4275 leaq foo@tpoff(%rax), %rax
4276 nopw 0x0(%rax,%rax,1) */
4278 if (ABI_64_P (output_bfd)
4279 && contents[roff + 5] == (bfd_byte) '\xb8')
4281 memcpy (contents + roff - 3,
4282 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
4283 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4286 else if (ABI_64_P (output_bfd))
4287 memcpy (contents + roff - 4,
4288 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4291 memcpy (contents + roff - 3,
4292 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4294 bfd_put_32 (output_bfd,
4295 elf_x86_64_tpoff (info, relocation),
4296 contents + roff + 8 + largepic);
4297 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4301 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
4303 /* GDesc -> LE transition.
4304 It's originally something like:
4305 leaq x@tlsdesc(%rip), %rax
4308 movl $x@tpoff, %rax. */
4310 unsigned int val, type;
4312 type = bfd_get_8 (input_bfd, contents + roff - 3);
4313 val = bfd_get_8 (input_bfd, contents + roff - 1);
4314 bfd_put_8 (output_bfd, 0x48 | ((type >> 2) & 1),
4315 contents + roff - 3);
4316 bfd_put_8 (output_bfd, 0xc7, contents + roff - 2);
4317 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4318 contents + roff - 1);
4319 bfd_put_32 (output_bfd,
4320 elf_x86_64_tpoff (info, relocation),
4324 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
4326 /* GDesc -> LE transition.
4331 bfd_put_8 (output_bfd, 0x66, contents + roff);
4332 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4335 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTTPOFF)
4337 /* IE->LE transition:
4338 For 64bit, originally it can be one of:
4339 movq foo@gottpoff(%rip), %reg
4340 addq foo@gottpoff(%rip), %reg
4343 leaq foo(%reg), %reg
4345 For 32bit, originally it can be one of:
4346 movq foo@gottpoff(%rip), %reg
4347 addl foo@gottpoff(%rip), %reg
4350 leal foo(%reg), %reg
4353 unsigned int val, type, reg;
4356 val = bfd_get_8 (input_bfd, contents + roff - 3);
4359 type = bfd_get_8 (input_bfd, contents + roff - 2);
4360 reg = bfd_get_8 (input_bfd, contents + roff - 1);
4366 bfd_put_8 (output_bfd, 0x49,
4367 contents + roff - 3);
4368 else if (!ABI_64_P (output_bfd) && val == 0x44)
4369 bfd_put_8 (output_bfd, 0x41,
4370 contents + roff - 3);
4371 bfd_put_8 (output_bfd, 0xc7,
4372 contents + roff - 2);
4373 bfd_put_8 (output_bfd, 0xc0 | reg,
4374 contents + roff - 1);
4378 /* addq/addl -> addq/addl - addressing with %rsp/%r12
4381 bfd_put_8 (output_bfd, 0x49,
4382 contents + roff - 3);
4383 else if (!ABI_64_P (output_bfd) && val == 0x44)
4384 bfd_put_8 (output_bfd, 0x41,
4385 contents + roff - 3);
4386 bfd_put_8 (output_bfd, 0x81,
4387 contents + roff - 2);
4388 bfd_put_8 (output_bfd, 0xc0 | reg,
4389 contents + roff - 1);
4393 /* addq/addl -> leaq/leal */
4395 bfd_put_8 (output_bfd, 0x4d,
4396 contents + roff - 3);
4397 else if (!ABI_64_P (output_bfd) && val == 0x44)
4398 bfd_put_8 (output_bfd, 0x45,
4399 contents + roff - 3);
4400 bfd_put_8 (output_bfd, 0x8d,
4401 contents + roff - 2);
4402 bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
4403 contents + roff - 1);
4405 bfd_put_32 (output_bfd,
4406 elf_x86_64_tpoff (info, relocation),
4414 if (htab->elf.sgot == NULL)
4419 off = h->got.offset;
4420 offplt = elf_x86_64_hash_entry (h)->tlsdesc_got;
4424 if (local_got_offsets == NULL)
4427 off = local_got_offsets[r_symndx];
4428 offplt = local_tlsdesc_gotents[r_symndx];
4435 Elf_Internal_Rela outrel;
4439 if (htab->elf.srelgot == NULL)
4442 indx = h && h->dynindx != -1 ? h->dynindx : 0;
4444 if (GOT_TLS_GDESC_P (tls_type))
4446 outrel.r_info = htab->r_info (indx, R_X86_64_TLSDESC);
4447 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt
4448 + 2 * GOT_ENTRY_SIZE <= htab->elf.sgotplt->size);
4449 outrel.r_offset = (htab->elf.sgotplt->output_section->vma
4450 + htab->elf.sgotplt->output_offset
4452 + htab->sgotplt_jump_table_size);
4453 sreloc = htab->elf.srelplt;
4455 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
4457 outrel.r_addend = 0;
4458 elf_append_rela (output_bfd, sreloc, &outrel);
4461 sreloc = htab->elf.srelgot;
4463 outrel.r_offset = (htab->elf.sgot->output_section->vma
4464 + htab->elf.sgot->output_offset + off);
4466 if (GOT_TLS_GD_P (tls_type))
4467 dr_type = R_X86_64_DTPMOD64;
4468 else if (GOT_TLS_GDESC_P (tls_type))
4471 dr_type = R_X86_64_TPOFF64;
4473 bfd_put_64 (output_bfd, 0, htab->elf.sgot->contents + off);
4474 outrel.r_addend = 0;
4475 if ((dr_type == R_X86_64_TPOFF64
4476 || dr_type == R_X86_64_TLSDESC) && indx == 0)
4477 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
4478 outrel.r_info = htab->r_info (indx, dr_type);
4480 elf_append_rela (output_bfd, sreloc, &outrel);
4482 if (GOT_TLS_GD_P (tls_type))
4486 BFD_ASSERT (! unresolved_reloc);
4487 bfd_put_64 (output_bfd,
4488 relocation - elf_x86_64_dtpoff_base (info),
4489 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4493 bfd_put_64 (output_bfd, 0,
4494 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4495 outrel.r_info = htab->r_info (indx,
4497 outrel.r_offset += GOT_ENTRY_SIZE;
4498 elf_append_rela (output_bfd, sreloc,
4507 local_got_offsets[r_symndx] |= 1;
4510 if (off >= (bfd_vma) -2
4511 && ! GOT_TLS_GDESC_P (tls_type))
4513 if (r_type == ELF32_R_TYPE (rel->r_info))
4515 if (r_type == R_X86_64_GOTPC32_TLSDESC
4516 || r_type == R_X86_64_TLSDESC_CALL)
4517 relocation = htab->elf.sgotplt->output_section->vma
4518 + htab->elf.sgotplt->output_offset
4519 + offplt + htab->sgotplt_jump_table_size;
4521 relocation = htab->elf.sgot->output_section->vma
4522 + htab->elf.sgot->output_offset + off;
4523 unresolved_reloc = FALSE;
4527 bfd_vma roff = rel->r_offset;
4529 if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
4531 /* GD->IE transition. For 64bit, change
4532 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4533 .word 0x6666; rex64; call __tls_get_addr@plt
4536 addq foo@gottpoff(%rip), %rax
4538 leaq foo@tlsgd(%rip), %rdi
4539 .word 0x6666; rex64; call __tls_get_addr@plt
4542 addq foo@gottpoff(%rip), %rax
4543 For largepic, change:
4544 leaq foo@tlsgd(%rip), %rdi
4545 movabsq $__tls_get_addr@pltoff, %rax
4550 addq foo@gottpoff(%rax), %rax
4551 nopw 0x0(%rax,%rax,1) */
4553 if (ABI_64_P (output_bfd)
4554 && contents[roff + 5] == (bfd_byte) '\xb8')
4556 memcpy (contents + roff - 3,
4557 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
4558 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4561 else if (ABI_64_P (output_bfd))
4562 memcpy (contents + roff - 4,
4563 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4566 memcpy (contents + roff - 3,
4567 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4570 relocation = (htab->elf.sgot->output_section->vma
4571 + htab->elf.sgot->output_offset + off
4574 - input_section->output_section->vma
4575 - input_section->output_offset
4577 bfd_put_32 (output_bfd, relocation,
4578 contents + roff + 8 + largepic);
4579 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4583 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
4585 /* GDesc -> IE transition.
4586 It's originally something like:
4587 leaq x@tlsdesc(%rip), %rax
4590 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
4592 /* Now modify the instruction as appropriate. To
4593 turn a leaq into a movq in the form we use it, it
4594 suffices to change the second byte from 0x8d to
4596 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4598 bfd_put_32 (output_bfd,
4599 htab->elf.sgot->output_section->vma
4600 + htab->elf.sgot->output_offset + off
4602 - input_section->output_section->vma
4603 - input_section->output_offset
4608 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
4610 /* GDesc -> IE transition.
4617 bfd_put_8 (output_bfd, 0x66, contents + roff);
4618 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4626 case R_X86_64_TLSLD:
4627 if (! elf_x86_64_tls_transition (info, input_bfd,
4628 input_section, contents,
4629 symtab_hdr, sym_hashes,
4630 &r_type, GOT_UNKNOWN,
4631 rel, relend, h, r_symndx))
4634 if (r_type != R_X86_64_TLSLD)
4636 /* LD->LE transition:
4637 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
4638 For 64bit, we change it into:
4639 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
4640 For 32bit, we change it into:
4641 nopl 0x0(%rax); movl %fs:0, %eax.
4642 For largepic, change:
4643 leaq foo@tlsgd(%rip), %rdi
4644 movabsq $__tls_get_addr@pltoff, %rax
4648 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
4651 BFD_ASSERT (r_type == R_X86_64_TPOFF32);
4652 if (ABI_64_P (output_bfd)
4653 && contents[rel->r_offset + 5] == (bfd_byte) '\xb8')
4654 memcpy (contents + rel->r_offset - 3,
4655 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
4656 "\x64\x48\x8b\x04\x25\0\0\0", 22);
4657 else if (ABI_64_P (output_bfd))
4658 memcpy (contents + rel->r_offset - 3,
4659 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
4661 memcpy (contents + rel->r_offset - 3,
4662 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
4663 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4668 if (htab->elf.sgot == NULL)
4671 off = htab->tls_ld_got.offset;
4676 Elf_Internal_Rela outrel;
4678 if (htab->elf.srelgot == NULL)
4681 outrel.r_offset = (htab->elf.sgot->output_section->vma
4682 + htab->elf.sgot->output_offset + off);
4684 bfd_put_64 (output_bfd, 0,
4685 htab->elf.sgot->contents + off);
4686 bfd_put_64 (output_bfd, 0,
4687 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4688 outrel.r_info = htab->r_info (0, R_X86_64_DTPMOD64);
4689 outrel.r_addend = 0;
4690 elf_append_rela (output_bfd, htab->elf.srelgot,
4692 htab->tls_ld_got.offset |= 1;
4694 relocation = htab->elf.sgot->output_section->vma
4695 + htab->elf.sgot->output_offset + off;
4696 unresolved_reloc = FALSE;
4699 case R_X86_64_DTPOFF32:
4700 if (!info->executable|| (input_section->flags & SEC_CODE) == 0)
4701 relocation -= elf_x86_64_dtpoff_base (info);
4703 relocation = elf_x86_64_tpoff (info, relocation);
4706 case R_X86_64_TPOFF32:
4707 case R_X86_64_TPOFF64:
4708 BFD_ASSERT (info->executable);
4709 relocation = elf_x86_64_tpoff (info, relocation);
4712 case R_X86_64_DTPOFF64:
4713 BFD_ASSERT ((input_section->flags & SEC_CODE) == 0);
4714 relocation -= elf_x86_64_dtpoff_base (info);
4721 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4722 because such sections are not SEC_ALLOC and thus ld.so will
4723 not process them. */
4724 if (unresolved_reloc
4725 && !((input_section->flags & SEC_DEBUGGING) != 0
4727 && _bfd_elf_section_offset (output_bfd, info, input_section,
4728 rel->r_offset) != (bfd_vma) -1)
4730 (*_bfd_error_handler)
4731 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4734 (long) rel->r_offset,
4736 h->root.root.string);
4741 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4742 contents, rel->r_offset,
4743 relocation, rel->r_addend);
4745 check_relocation_error:
4746 if (r != bfd_reloc_ok)
4751 name = h->root.root.string;
4754 name = bfd_elf_string_from_elf_section (input_bfd,
4755 symtab_hdr->sh_link,
4760 name = bfd_section_name (input_bfd, sec);
4763 if (r == bfd_reloc_overflow)
4765 if (! ((*info->callbacks->reloc_overflow)
4766 (info, (h ? &h->root : NULL), name, howto->name,
4767 (bfd_vma) 0, input_bfd, input_section,
4773 (*_bfd_error_handler)
4774 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4775 input_bfd, input_section,
4776 (long) rel->r_offset, name, (int) r);
4785 /* Finish up dynamic symbol handling. We set the contents of various
4786 dynamic sections here. */
4789 elf_x86_64_finish_dynamic_symbol (bfd *output_bfd,
4790 struct bfd_link_info *info,
4791 struct elf_link_hash_entry *h,
4792 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
4794 struct elf_x86_64_link_hash_table *htab;
4795 const struct elf_x86_64_backend_data *abed;
4796 bfd_boolean use_plt_bnd;
4798 htab = elf_x86_64_hash_table (info);
4802 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
4803 section only if there is .plt section. */
4804 use_plt_bnd = htab->elf.splt != NULL && htab->plt_bnd != NULL;
4806 ? &elf_x86_64_bnd_arch_bed
4807 : get_elf_x86_64_backend_data (output_bfd));
4809 if (h->plt.offset != (bfd_vma) -1)
4812 bfd_vma got_offset, plt_offset, plt_plt_offset, plt_got_offset;
4813 bfd_vma plt_plt_insn_end, plt_got_insn_size;
4814 Elf_Internal_Rela rela;
4816 asection *plt, *gotplt, *relplt, *resolved_plt;
4817 const struct elf_backend_data *bed;
4819 /* When building a static executable, use .iplt, .igot.plt and
4820 .rela.iplt sections for STT_GNU_IFUNC symbols. */
4821 if (htab->elf.splt != NULL)
4823 plt = htab->elf.splt;
4824 gotplt = htab->elf.sgotplt;
4825 relplt = htab->elf.srelplt;
4829 plt = htab->elf.iplt;
4830 gotplt = htab->elf.igotplt;
4831 relplt = htab->elf.irelplt;
4834 /* This symbol has an entry in the procedure linkage table. Set
4836 if ((h->dynindx == -1
4837 && !((h->forced_local || info->executable)
4839 && h->type == STT_GNU_IFUNC))
4845 /* Get the index in the procedure linkage table which
4846 corresponds to this symbol. This is the index of this symbol
4847 in all the symbols for which we are making plt entries. The
4848 first entry in the procedure linkage table is reserved.
4850 Get the offset into the .got table of the entry that
4851 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
4852 bytes. The first three are reserved for the dynamic linker.
4854 For static executables, we don't reserve anything. */
4856 if (plt == htab->elf.splt)
4858 got_offset = h->plt.offset / abed->plt_entry_size - 1;
4859 got_offset = (got_offset + 3) * GOT_ENTRY_SIZE;
4863 got_offset = h->plt.offset / abed->plt_entry_size;
4864 got_offset = got_offset * GOT_ENTRY_SIZE;
4867 plt_plt_insn_end = abed->plt_plt_insn_end;
4868 plt_plt_offset = abed->plt_plt_offset;
4869 plt_got_insn_size = abed->plt_got_insn_size;
4870 plt_got_offset = abed->plt_got_offset;
4873 /* Use the second PLT with BND relocations. */
4874 const bfd_byte *plt_entry, *plt2_entry;
4875 struct elf_x86_64_link_hash_entry *eh
4876 = (struct elf_x86_64_link_hash_entry *) h;
4878 if (eh->has_bnd_reloc)
4880 plt_entry = elf_x86_64_bnd_plt_entry;
4881 plt2_entry = elf_x86_64_bnd_plt2_entry;
4885 plt_entry = elf_x86_64_legacy_plt_entry;
4886 plt2_entry = elf_x86_64_legacy_plt2_entry;
4888 /* Subtract 1 since there is no BND prefix. */
4889 plt_plt_insn_end -= 1;
4890 plt_plt_offset -= 1;
4891 plt_got_insn_size -= 1;
4892 plt_got_offset -= 1;
4895 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry)
4896 == sizeof (elf_x86_64_legacy_plt_entry));
4898 /* Fill in the entry in the procedure linkage table. */
4899 memcpy (plt->contents + h->plt.offset,
4900 plt_entry, sizeof (elf_x86_64_legacy_plt_entry));
4901 /* Fill in the entry in the second PLT. */
4902 memcpy (htab->plt_bnd->contents + eh->plt_bnd.offset,
4903 plt2_entry, sizeof (elf_x86_64_legacy_plt2_entry));
4905 resolved_plt = htab->plt_bnd;
4906 plt_offset = eh->plt_bnd.offset;
4910 /* Fill in the entry in the procedure linkage table. */
4911 memcpy (plt->contents + h->plt.offset, abed->plt_entry,
4912 abed->plt_entry_size);
4915 plt_offset = h->plt.offset;
4918 /* Insert the relocation positions of the plt section. */
4920 /* Put offset the PC-relative instruction referring to the GOT entry,
4921 subtracting the size of that instruction. */
4922 bfd_put_32 (output_bfd,
4923 (gotplt->output_section->vma
4924 + gotplt->output_offset
4926 - resolved_plt->output_section->vma
4927 - resolved_plt->output_offset
4929 - plt_got_insn_size),
4930 resolved_plt->contents + plt_offset + plt_got_offset);
4932 /* Fill in the entry in the global offset table, initially this
4933 points to the second part of the PLT entry. */
4934 bfd_put_64 (output_bfd, (plt->output_section->vma
4935 + plt->output_offset
4936 + h->plt.offset + abed->plt_lazy_offset),
4937 gotplt->contents + got_offset);
4939 /* Fill in the entry in the .rela.plt section. */
4940 rela.r_offset = (gotplt->output_section->vma
4941 + gotplt->output_offset
4943 if (h->dynindx == -1
4944 || ((info->executable
4945 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4947 && h->type == STT_GNU_IFUNC))
4949 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4950 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
4951 rela.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
4952 rela.r_addend = (h->root.u.def.value
4953 + h->root.u.def.section->output_section->vma
4954 + h->root.u.def.section->output_offset);
4955 /* R_X86_64_IRELATIVE comes last. */
4956 plt_index = htab->next_irelative_index--;
4960 rela.r_info = htab->r_info (h->dynindx, R_X86_64_JUMP_SLOT);
4962 plt_index = htab->next_jump_slot_index++;
4965 /* Don't fill PLT entry for static executables. */
4966 if (plt == htab->elf.splt)
4968 /* Put relocation index. */
4969 bfd_put_32 (output_bfd, plt_index,
4970 plt->contents + h->plt.offset + abed->plt_reloc_offset);
4971 /* Put offset for jmp .PLT0. */
4972 bfd_put_32 (output_bfd, - (h->plt.offset + plt_plt_insn_end),
4973 plt->contents + h->plt.offset + plt_plt_offset);
4976 bed = get_elf_backend_data (output_bfd);
4977 loc = relplt->contents + plt_index * bed->s->sizeof_rela;
4978 bed->s->swap_reloca_out (output_bfd, &rela, loc);
4980 if (!h->def_regular)
4982 /* Mark the symbol as undefined, rather than as defined in
4983 the .plt section. Leave the value if there were any
4984 relocations where pointer equality matters (this is a clue
4985 for the dynamic linker, to make function pointer
4986 comparisons work between an application and shared
4987 library), otherwise set it to zero. If a function is only
4988 called from a binary, there is no need to slow down
4989 shared libraries because of that. */
4990 sym->st_shndx = SHN_UNDEF;
4991 if (!h->pointer_equality_needed)
4996 if (h->got.offset != (bfd_vma) -1
4997 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h)->tls_type)
4998 && elf_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE)
5000 Elf_Internal_Rela rela;
5002 /* This symbol has an entry in the global offset table. Set it
5004 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
5007 rela.r_offset = (htab->elf.sgot->output_section->vma
5008 + htab->elf.sgot->output_offset
5009 + (h->got.offset &~ (bfd_vma) 1));
5011 /* If this is a static link, or it is a -Bsymbolic link and the
5012 symbol is defined locally or was forced to be local because
5013 of a version file, we just want to emit a RELATIVE reloc.
5014 The entry in the global offset table will already have been
5015 initialized in the relocate_section function. */
5017 && h->type == STT_GNU_IFUNC)
5021 /* Generate R_X86_64_GLOB_DAT. */
5028 if (!h->pointer_equality_needed)
5031 /* For non-shared object, we can't use .got.plt, which
5032 contains the real function addres if we need pointer
5033 equality. We load the GOT entry with the PLT entry. */
5034 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
5035 bfd_put_64 (output_bfd, (plt->output_section->vma
5036 + plt->output_offset
5038 htab->elf.sgot->contents + h->got.offset);
5042 else if (info->shared
5043 && SYMBOL_REFERENCES_LOCAL (info, h))
5045 if (!h->def_regular)
5047 BFD_ASSERT((h->got.offset & 1) != 0);
5048 rela.r_info = htab->r_info (0, R_X86_64_RELATIVE);
5049 rela.r_addend = (h->root.u.def.value
5050 + h->root.u.def.section->output_section->vma
5051 + h->root.u.def.section->output_offset);
5055 BFD_ASSERT((h->got.offset & 1) == 0);
5057 bfd_put_64 (output_bfd, (bfd_vma) 0,
5058 htab->elf.sgot->contents + h->got.offset);
5059 rela.r_info = htab->r_info (h->dynindx, R_X86_64_GLOB_DAT);
5063 elf_append_rela (output_bfd, htab->elf.srelgot, &rela);
5068 Elf_Internal_Rela rela;
5070 /* This symbol needs a copy reloc. Set it up. */
5072 if (h->dynindx == -1
5073 || (h->root.type != bfd_link_hash_defined
5074 && h->root.type != bfd_link_hash_defweak)
5075 || htab->srelbss == NULL)
5078 rela.r_offset = (h->root.u.def.value
5079 + h->root.u.def.section->output_section->vma
5080 + h->root.u.def.section->output_offset);
5081 rela.r_info = htab->r_info (h->dynindx, R_X86_64_COPY);
5083 elf_append_rela (output_bfd, htab->srelbss, &rela);
5089 /* Finish up local dynamic symbol handling. We set the contents of
5090 various dynamic sections here. */
5093 elf_x86_64_finish_local_dynamic_symbol (void **slot, void *inf)
5095 struct elf_link_hash_entry *h
5096 = (struct elf_link_hash_entry *) *slot;
5097 struct bfd_link_info *info
5098 = (struct bfd_link_info *) inf;
5100 return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
5104 /* Used to decide how to sort relocs in an optimal manner for the
5105 dynamic linker, before writing them out. */
5107 static enum elf_reloc_type_class
5108 elf_x86_64_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
5109 const asection *rel_sec ATTRIBUTE_UNUSED,
5110 const Elf_Internal_Rela *rela)
5112 switch ((int) ELF32_R_TYPE (rela->r_info))
5114 case R_X86_64_RELATIVE:
5115 case R_X86_64_RELATIVE64:
5116 return reloc_class_relative;
5117 case R_X86_64_JUMP_SLOT:
5118 return reloc_class_plt;
5120 return reloc_class_copy;
5122 return reloc_class_normal;
5126 /* Finish up the dynamic sections. */
5129 elf_x86_64_finish_dynamic_sections (bfd *output_bfd,
5130 struct bfd_link_info *info)
5132 struct elf_x86_64_link_hash_table *htab;
5135 const struct elf_x86_64_backend_data *abed;
5137 htab = elf_x86_64_hash_table (info);
5141 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5142 section only if there is .plt section. */
5143 abed = (htab->elf.splt != NULL && htab->plt_bnd != NULL
5144 ? &elf_x86_64_bnd_arch_bed
5145 : get_elf_x86_64_backend_data (output_bfd));
5147 dynobj = htab->elf.dynobj;
5148 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
5150 if (htab->elf.dynamic_sections_created)
5152 bfd_byte *dyncon, *dynconend;
5153 const struct elf_backend_data *bed;
5154 bfd_size_type sizeof_dyn;
5156 if (sdyn == NULL || htab->elf.sgot == NULL)
5159 bed = get_elf_backend_data (dynobj);
5160 sizeof_dyn = bed->s->sizeof_dyn;
5161 dyncon = sdyn->contents;
5162 dynconend = sdyn->contents + sdyn->size;
5163 for (; dyncon < dynconend; dyncon += sizeof_dyn)
5165 Elf_Internal_Dyn dyn;
5168 (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
5176 s = htab->elf.sgotplt;
5177 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5181 dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
5185 s = htab->elf.srelplt->output_section;
5186 dyn.d_un.d_val = s->size;
5190 /* The procedure linkage table relocs (DT_JMPREL) should
5191 not be included in the overall relocs (DT_RELA).
5192 Therefore, we override the DT_RELASZ entry here to
5193 make it not include the JMPREL relocs. Since the
5194 linker script arranges for .rela.plt to follow all
5195 other relocation sections, we don't have to worry
5196 about changing the DT_RELA entry. */
5197 if (htab->elf.srelplt != NULL)
5199 s = htab->elf.srelplt->output_section;
5200 dyn.d_un.d_val -= s->size;
5204 case DT_TLSDESC_PLT:
5206 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
5207 + htab->tlsdesc_plt;
5210 case DT_TLSDESC_GOT:
5212 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
5213 + htab->tlsdesc_got;
5217 (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
5220 /* Fill in the special first entry in the procedure linkage table. */
5221 if (htab->elf.splt && htab->elf.splt->size > 0)
5223 /* Fill in the first entry in the procedure linkage table. */
5224 memcpy (htab->elf.splt->contents,
5225 abed->plt0_entry, abed->plt_entry_size);
5226 /* Add offset for pushq GOT+8(%rip), since the instruction
5227 uses 6 bytes subtract this value. */
5228 bfd_put_32 (output_bfd,
5229 (htab->elf.sgotplt->output_section->vma
5230 + htab->elf.sgotplt->output_offset
5232 - htab->elf.splt->output_section->vma
5233 - htab->elf.splt->output_offset
5235 htab->elf.splt->contents + abed->plt0_got1_offset);
5236 /* Add offset for the PC-relative instruction accessing GOT+16,
5237 subtracting the offset to the end of that instruction. */
5238 bfd_put_32 (output_bfd,
5239 (htab->elf.sgotplt->output_section->vma
5240 + htab->elf.sgotplt->output_offset
5242 - htab->elf.splt->output_section->vma
5243 - htab->elf.splt->output_offset
5244 - abed->plt0_got2_insn_end),
5245 htab->elf.splt->contents + abed->plt0_got2_offset);
5247 elf_section_data (htab->elf.splt->output_section)
5248 ->this_hdr.sh_entsize = abed->plt_entry_size;
5250 if (htab->tlsdesc_plt)
5252 bfd_put_64 (output_bfd, (bfd_vma) 0,
5253 htab->elf.sgot->contents + htab->tlsdesc_got);
5255 memcpy (htab->elf.splt->contents + htab->tlsdesc_plt,
5256 abed->plt0_entry, abed->plt_entry_size);
5258 /* Add offset for pushq GOT+8(%rip), since the
5259 instruction uses 6 bytes subtract this value. */
5260 bfd_put_32 (output_bfd,
5261 (htab->elf.sgotplt->output_section->vma
5262 + htab->elf.sgotplt->output_offset
5264 - htab->elf.splt->output_section->vma
5265 - htab->elf.splt->output_offset
5268 htab->elf.splt->contents
5269 + htab->tlsdesc_plt + abed->plt0_got1_offset);
5270 /* Add offset for the PC-relative instruction accessing GOT+TDG,
5271 where TGD stands for htab->tlsdesc_got, subtracting the offset
5272 to the end of that instruction. */
5273 bfd_put_32 (output_bfd,
5274 (htab->elf.sgot->output_section->vma
5275 + htab->elf.sgot->output_offset
5277 - htab->elf.splt->output_section->vma
5278 - htab->elf.splt->output_offset
5280 - abed->plt0_got2_insn_end),
5281 htab->elf.splt->contents
5282 + htab->tlsdesc_plt + abed->plt0_got2_offset);
5287 if (htab->plt_bnd != NULL)
5288 elf_section_data (htab->plt_bnd->output_section)
5289 ->this_hdr.sh_entsize = sizeof (elf_x86_64_bnd_plt2_entry);
5291 if (htab->elf.sgotplt)
5293 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
5295 (*_bfd_error_handler)
5296 (_("discarded output section: `%A'"), htab->elf.sgotplt);
5300 /* Fill in the first three entries in the global offset table. */
5301 if (htab->elf.sgotplt->size > 0)
5303 /* Set the first entry in the global offset table to the address of
5304 the dynamic section. */
5306 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents);
5308 bfd_put_64 (output_bfd,
5309 sdyn->output_section->vma + sdyn->output_offset,
5310 htab->elf.sgotplt->contents);
5311 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
5312 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
5313 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE*2);
5316 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize =
5320 /* Adjust .eh_frame for .plt section. */
5321 if (htab->plt_eh_frame != NULL
5322 && htab->plt_eh_frame->contents != NULL)
5324 if (htab->elf.splt != NULL
5325 && htab->elf.splt->size != 0
5326 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
5327 && htab->elf.splt->output_section != NULL
5328 && htab->plt_eh_frame->output_section != NULL)
5330 bfd_vma plt_start = htab->elf.splt->output_section->vma;
5331 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
5332 + htab->plt_eh_frame->output_offset
5333 + PLT_FDE_START_OFFSET;
5334 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
5335 htab->plt_eh_frame->contents
5336 + PLT_FDE_START_OFFSET);
5338 if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
5340 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
5342 htab->plt_eh_frame->contents))
5347 if (htab->elf.sgot && htab->elf.sgot->size > 0)
5348 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
5351 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5352 htab_traverse (htab->loc_hash_table,
5353 elf_x86_64_finish_local_dynamic_symbol,
5359 /* Return an array of PLT entry symbol values. */
5362 elf_x86_64_get_plt_sym_val (bfd *abfd, asymbol **dynsyms, asection *plt,
5365 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
5368 bfd_vma *plt_sym_val;
5370 bfd_byte *plt_contents;
5371 const struct elf_x86_64_backend_data *bed;
5372 Elf_Internal_Shdr *hdr;
5375 /* Get the .plt section contents. PLT passed down may point to the
5376 .plt.bnd section. Make sure that PLT always points to the .plt
5378 plt_bnd = bfd_get_section_by_name (abfd, ".plt.bnd");
5383 plt = bfd_get_section_by_name (abfd, ".plt");
5386 bed = &elf_x86_64_bnd_arch_bed;
5389 bed = get_elf_x86_64_backend_data (abfd);
5391 plt_contents = (bfd_byte *) bfd_malloc (plt->size);
5392 if (plt_contents == NULL)
5394 if (!bfd_get_section_contents (abfd, (asection *) plt,
5395 plt_contents, 0, plt->size))
5398 free (plt_contents);
5402 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
5403 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
5406 hdr = &elf_section_data (relplt)->this_hdr;
5407 count = relplt->size / hdr->sh_entsize;
5409 plt_sym_val = (bfd_vma *) bfd_malloc (sizeof (bfd_vma) * count);
5410 if (plt_sym_val == NULL)
5413 for (i = 0; i < count; i++)
5414 plt_sym_val[i] = -1;
5416 plt_offset = bed->plt_entry_size;
5417 p = relplt->relocation;
5418 for (i = 0; i < count; i++, p++)
5422 /* Skip unknown relocation. */
5423 if (p->howto == NULL)
5426 if (p->howto->type != R_X86_64_JUMP_SLOT
5427 && p->howto->type != R_X86_64_IRELATIVE)
5430 reloc_index = H_GET_32 (abfd, (plt_contents + plt_offset
5431 + bed->plt_reloc_offset));
5432 if (reloc_index >= count)
5436 /* This is the index in .plt section. */
5437 long plt_index = plt_offset / bed->plt_entry_size;
5438 /* Store VMA + the offset in .plt.bnd section. */
5439 plt_sym_val[reloc_index] =
5441 + (plt_index - 1) * sizeof (elf_x86_64_legacy_plt2_entry));
5444 plt_sym_val[reloc_index] = plt->vma + plt_offset;
5445 plt_offset += bed->plt_entry_size;
5448 free (plt_contents);
5453 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
5457 elf_x86_64_get_synthetic_symtab (bfd *abfd,
5464 /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
5465 as PLT if it exists. */
5466 asection *plt = bfd_get_section_by_name (abfd, ".plt.bnd");
5468 plt = bfd_get_section_by_name (abfd, ".plt");
5469 return _bfd_elf_ifunc_get_synthetic_symtab (abfd, symcount, syms,
5470 dynsymcount, dynsyms, ret,
5472 elf_x86_64_get_plt_sym_val);
5475 /* Handle an x86-64 specific section when reading an object file. This
5476 is called when elfcode.h finds a section with an unknown type. */
5479 elf_x86_64_section_from_shdr (bfd *abfd, Elf_Internal_Shdr *hdr,
5480 const char *name, int shindex)
5482 if (hdr->sh_type != SHT_X86_64_UNWIND)
5485 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
5491 /* Hook called by the linker routine which adds symbols from an object
5492 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
5496 elf_x86_64_add_symbol_hook (bfd *abfd,
5497 struct bfd_link_info *info,
5498 Elf_Internal_Sym *sym,
5499 const char **namep ATTRIBUTE_UNUSED,
5500 flagword *flagsp ATTRIBUTE_UNUSED,
5506 switch (sym->st_shndx)
5508 case SHN_X86_64_LCOMMON:
5509 lcomm = bfd_get_section_by_name (abfd, "LARGE_COMMON");
5512 lcomm = bfd_make_section_with_flags (abfd,
5516 | SEC_LINKER_CREATED));
5519 elf_section_flags (lcomm) |= SHF_X86_64_LARGE;
5522 *valp = sym->st_size;
5526 if ((ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
5527 || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE)
5528 && (abfd->flags & DYNAMIC) == 0
5529 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
5530 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
5536 /* Given a BFD section, try to locate the corresponding ELF section
5540 elf_x86_64_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
5541 asection *sec, int *index_return)
5543 if (sec == &_bfd_elf_large_com_section)
5545 *index_return = SHN_X86_64_LCOMMON;
5551 /* Process a symbol. */
5554 elf_x86_64_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
5557 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
5559 switch (elfsym->internal_elf_sym.st_shndx)
5561 case SHN_X86_64_LCOMMON:
5562 asym->section = &_bfd_elf_large_com_section;
5563 asym->value = elfsym->internal_elf_sym.st_size;
5564 /* Common symbol doesn't set BSF_GLOBAL. */
5565 asym->flags &= ~BSF_GLOBAL;
5571 elf_x86_64_common_definition (Elf_Internal_Sym *sym)
5573 return (sym->st_shndx == SHN_COMMON
5574 || sym->st_shndx == SHN_X86_64_LCOMMON);
5578 elf_x86_64_common_section_index (asection *sec)
5580 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
5583 return SHN_X86_64_LCOMMON;
5587 elf_x86_64_common_section (asection *sec)
5589 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
5590 return bfd_com_section_ptr;
5592 return &_bfd_elf_large_com_section;
5596 elf_x86_64_merge_symbol (struct elf_link_hash_entry *h,
5597 const Elf_Internal_Sym *sym,
5602 const asection *oldsec)
5604 /* A normal common symbol and a large common symbol result in a
5605 normal common symbol. We turn the large common symbol into a
5608 && h->root.type == bfd_link_hash_common
5610 && bfd_is_com_section (*psec)
5613 if (sym->st_shndx == SHN_COMMON
5614 && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) != 0)
5616 h->root.u.c.p->section
5617 = bfd_make_section_old_way (oldbfd, "COMMON");
5618 h->root.u.c.p->section->flags = SEC_ALLOC;
5620 else if (sym->st_shndx == SHN_X86_64_LCOMMON
5621 && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) == 0)
5622 *psec = bfd_com_section_ptr;
5629 elf_x86_64_additional_program_headers (bfd *abfd,
5630 struct bfd_link_info *info ATTRIBUTE_UNUSED)
5635 /* Check to see if we need a large readonly segment. */
5636 s = bfd_get_section_by_name (abfd, ".lrodata");
5637 if (s && (s->flags & SEC_LOAD))
5640 /* Check to see if we need a large data segment. Since .lbss sections
5641 is placed right after the .bss section, there should be no need for
5642 a large data segment just because of .lbss. */
5643 s = bfd_get_section_by_name (abfd, ".ldata");
5644 if (s && (s->flags & SEC_LOAD))
5650 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5653 elf_x86_64_hash_symbol (struct elf_link_hash_entry *h)
5655 if (h->plt.offset != (bfd_vma) -1
5657 && !h->pointer_equality_needed)
5660 return _bfd_elf_hash_symbol (h);
5663 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
5666 elf_x86_64_relocs_compatible (const bfd_target *input,
5667 const bfd_target *output)
5669 return ((xvec_get_elf_backend_data (input)->s->elfclass
5670 == xvec_get_elf_backend_data (output)->s->elfclass)
5671 && _bfd_elf_relocs_compatible (input, output));
5674 static const struct bfd_elf_special_section
5675 elf_x86_64_special_sections[]=
5677 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5678 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
5679 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR + SHF_X86_64_LARGE},
5680 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5681 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5682 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
5683 { NULL, 0, 0, 0, 0 }
5686 #define TARGET_LITTLE_SYM x86_64_elf64_vec
5687 #define TARGET_LITTLE_NAME "elf64-x86-64"
5688 #define ELF_ARCH bfd_arch_i386
5689 #define ELF_TARGET_ID X86_64_ELF_DATA
5690 #define ELF_MACHINE_CODE EM_X86_64
5691 #define ELF_MAXPAGESIZE 0x200000
5692 #define ELF_MINPAGESIZE 0x1000
5693 #define ELF_COMMONPAGESIZE 0x1000
5695 #define elf_backend_can_gc_sections 1
5696 #define elf_backend_can_refcount 1
5697 #define elf_backend_want_got_plt 1
5698 #define elf_backend_plt_readonly 1
5699 #define elf_backend_want_plt_sym 0
5700 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
5701 #define elf_backend_rela_normal 1
5702 #define elf_backend_plt_alignment 4
5704 #define elf_info_to_howto elf_x86_64_info_to_howto
5706 #define bfd_elf64_bfd_link_hash_table_create \
5707 elf_x86_64_link_hash_table_create
5708 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
5709 #define bfd_elf64_bfd_reloc_name_lookup \
5710 elf_x86_64_reloc_name_lookup
5712 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
5713 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
5714 #define elf_backend_check_relocs elf_x86_64_check_relocs
5715 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
5716 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
5717 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
5718 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
5719 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
5720 #define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
5721 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
5722 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
5724 #define elf_backend_write_core_note elf_x86_64_write_core_note
5726 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
5727 #define elf_backend_relocate_section elf_x86_64_relocate_section
5728 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
5729 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
5730 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
5731 #define elf_backend_object_p elf64_x86_64_elf_object_p
5732 #define bfd_elf64_mkobject elf_x86_64_mkobject
5733 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
5735 #define elf_backend_section_from_shdr \
5736 elf_x86_64_section_from_shdr
5738 #define elf_backend_section_from_bfd_section \
5739 elf_x86_64_elf_section_from_bfd_section
5740 #define elf_backend_add_symbol_hook \
5741 elf_x86_64_add_symbol_hook
5742 #define elf_backend_symbol_processing \
5743 elf_x86_64_symbol_processing
5744 #define elf_backend_common_section_index \
5745 elf_x86_64_common_section_index
5746 #define elf_backend_common_section \
5747 elf_x86_64_common_section
5748 #define elf_backend_common_definition \
5749 elf_x86_64_common_definition
5750 #define elf_backend_merge_symbol \
5751 elf_x86_64_merge_symbol
5752 #define elf_backend_special_sections \
5753 elf_x86_64_special_sections
5754 #define elf_backend_additional_program_headers \
5755 elf_x86_64_additional_program_headers
5756 #define elf_backend_hash_symbol \
5757 elf_x86_64_hash_symbol
5759 #include "elf64-target.h"
5761 /* FreeBSD support. */
5763 #undef TARGET_LITTLE_SYM
5764 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
5765 #undef TARGET_LITTLE_NAME
5766 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
5769 #define ELF_OSABI ELFOSABI_FREEBSD
5772 #define elf64_bed elf64_x86_64_fbsd_bed
5774 #include "elf64-target.h"
5776 /* Solaris 2 support. */
5778 #undef TARGET_LITTLE_SYM
5779 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
5780 #undef TARGET_LITTLE_NAME
5781 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
5783 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5784 objects won't be recognized. */
5788 #define elf64_bed elf64_x86_64_sol2_bed
5790 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
5792 #undef elf_backend_static_tls_alignment
5793 #define elf_backend_static_tls_alignment 16
5795 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5797 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5799 #undef elf_backend_want_plt_sym
5800 #define elf_backend_want_plt_sym 1
5802 #include "elf64-target.h"
5804 /* Native Client support. */
5807 elf64_x86_64_nacl_elf_object_p (bfd *abfd)
5809 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
5810 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64_nacl);
5814 #undef TARGET_LITTLE_SYM
5815 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
5816 #undef TARGET_LITTLE_NAME
5817 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
5819 #define elf64_bed elf64_x86_64_nacl_bed
5821 #undef ELF_MAXPAGESIZE
5822 #undef ELF_MINPAGESIZE
5823 #undef ELF_COMMONPAGESIZE
5824 #define ELF_MAXPAGESIZE 0x10000
5825 #define ELF_MINPAGESIZE 0x10000
5826 #define ELF_COMMONPAGESIZE 0x10000
5828 /* Restore defaults. */
5830 #undef elf_backend_static_tls_alignment
5831 #undef elf_backend_want_plt_sym
5832 #define elf_backend_want_plt_sym 0
5834 /* NaCl uses substantially different PLT entries for the same effects. */
5836 #undef elf_backend_plt_alignment
5837 #define elf_backend_plt_alignment 5
5838 #define NACL_PLT_ENTRY_SIZE 64
5839 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
5841 static const bfd_byte elf_x86_64_nacl_plt0_entry[NACL_PLT_ENTRY_SIZE] =
5843 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
5844 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
5845 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */
5846 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5847 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5849 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
5850 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
5852 /* 32 bytes of nop to pad out to the standard size. */
5853 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5854 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5855 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5856 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5857 0x66, /* excess data32 prefix */
5861 static const bfd_byte elf_x86_64_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
5863 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
5864 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */
5865 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5866 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5868 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
5869 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5870 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5872 /* Lazy GOT entries point here (32-byte aligned). */
5873 0x68, /* pushq immediate */
5874 0, 0, 0, 0, /* replaced with index into relocation table. */
5875 0xe9, /* jmp relative */
5876 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
5878 /* 22 bytes of nop to pad out to the standard size. */
5879 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5880 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5881 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
5884 /* .eh_frame covering the .plt section. */
5886 static const bfd_byte elf_x86_64_nacl_eh_frame_plt[] =
5888 #if (PLT_CIE_LENGTH != 20 \
5889 || PLT_FDE_LENGTH != 36 \
5890 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
5891 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
5892 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
5894 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
5895 0, 0, 0, 0, /* CIE ID */
5896 1, /* CIE version */
5897 'z', 'R', 0, /* Augmentation string */
5898 1, /* Code alignment factor */
5899 0x78, /* Data alignment factor */
5900 16, /* Return address column */
5901 1, /* Augmentation size */
5902 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
5903 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
5904 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
5905 DW_CFA_nop, DW_CFA_nop,
5907 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
5908 PLT_CIE_LENGTH + 8, 0, 0, 0,/* CIE pointer */
5909 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
5910 0, 0, 0, 0, /* .plt size goes here */
5911 0, /* Augmentation size */
5912 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
5913 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
5914 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
5915 DW_CFA_advance_loc + 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
5916 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
5917 13, /* Block length */
5918 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
5919 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
5920 DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
5921 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
5922 DW_CFA_nop, DW_CFA_nop
5925 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed =
5927 elf_x86_64_nacl_plt0_entry, /* plt0_entry */
5928 elf_x86_64_nacl_plt_entry, /* plt_entry */
5929 NACL_PLT_ENTRY_SIZE, /* plt_entry_size */
5930 2, /* plt0_got1_offset */
5931 9, /* plt0_got2_offset */
5932 13, /* plt0_got2_insn_end */
5933 3, /* plt_got_offset */
5934 33, /* plt_reloc_offset */
5935 38, /* plt_plt_offset */
5936 7, /* plt_got_insn_size */
5937 42, /* plt_plt_insn_end */
5938 32, /* plt_lazy_offset */
5939 elf_x86_64_nacl_eh_frame_plt, /* eh_frame_plt */
5940 sizeof (elf_x86_64_nacl_eh_frame_plt), /* eh_frame_plt_size */
5943 #undef elf_backend_arch_data
5944 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
5946 #undef elf_backend_object_p
5947 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
5948 #undef elf_backend_modify_segment_map
5949 #define elf_backend_modify_segment_map nacl_modify_segment_map
5950 #undef elf_backend_modify_program_headers
5951 #define elf_backend_modify_program_headers nacl_modify_program_headers
5952 #undef elf_backend_final_write_processing
5953 #define elf_backend_final_write_processing nacl_final_write_processing
5955 #include "elf64-target.h"
5957 /* Native Client x32 support. */
5960 elf32_x86_64_nacl_elf_object_p (bfd *abfd)
5962 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
5963 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32_nacl);
5967 #undef TARGET_LITTLE_SYM
5968 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
5969 #undef TARGET_LITTLE_NAME
5970 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
5972 #define elf32_bed elf32_x86_64_nacl_bed
5974 #define bfd_elf32_bfd_link_hash_table_create \
5975 elf_x86_64_link_hash_table_create
5976 #define bfd_elf32_bfd_reloc_type_lookup \
5977 elf_x86_64_reloc_type_lookup
5978 #define bfd_elf32_bfd_reloc_name_lookup \
5979 elf_x86_64_reloc_name_lookup
5980 #define bfd_elf32_mkobject \
5982 #define bfd_elf32_get_synthetic_symtab \
5983 elf_x86_64_get_synthetic_symtab
5985 #undef elf_backend_object_p
5986 #define elf_backend_object_p \
5987 elf32_x86_64_nacl_elf_object_p
5989 #undef elf_backend_bfd_from_remote_memory
5990 #define elf_backend_bfd_from_remote_memory \
5991 _bfd_elf32_bfd_from_remote_memory
5993 #undef elf_backend_size_info
5994 #define elf_backend_size_info \
5995 _bfd_elf32_size_info
5997 #include "elf32-target.h"
5999 /* Restore defaults. */
6000 #undef elf_backend_object_p
6001 #define elf_backend_object_p elf64_x86_64_elf_object_p
6002 #undef elf_backend_bfd_from_remote_memory
6003 #undef elf_backend_size_info
6004 #undef elf_backend_modify_segment_map
6005 #undef elf_backend_modify_program_headers
6006 #undef elf_backend_final_write_processing
6008 /* Intel L1OM support. */
6011 elf64_l1om_elf_object_p (bfd *abfd)
6013 /* Set the right machine number for an L1OM elf64 file. */
6014 bfd_default_set_arch_mach (abfd, bfd_arch_l1om, bfd_mach_l1om);
6018 #undef TARGET_LITTLE_SYM
6019 #define TARGET_LITTLE_SYM l1om_elf64_vec
6020 #undef TARGET_LITTLE_NAME
6021 #define TARGET_LITTLE_NAME "elf64-l1om"
6023 #define ELF_ARCH bfd_arch_l1om
6025 #undef ELF_MACHINE_CODE
6026 #define ELF_MACHINE_CODE EM_L1OM
6031 #define elf64_bed elf64_l1om_bed
6033 #undef elf_backend_object_p
6034 #define elf_backend_object_p elf64_l1om_elf_object_p
6036 /* Restore defaults. */
6037 #undef ELF_MAXPAGESIZE
6038 #undef ELF_MINPAGESIZE
6039 #undef ELF_COMMONPAGESIZE
6040 #define ELF_MAXPAGESIZE 0x200000
6041 #define ELF_MINPAGESIZE 0x1000
6042 #define ELF_COMMONPAGESIZE 0x1000
6043 #undef elf_backend_plt_alignment
6044 #define elf_backend_plt_alignment 4
6045 #undef elf_backend_arch_data
6046 #define elf_backend_arch_data &elf_x86_64_arch_bed
6048 #include "elf64-target.h"
6050 /* FreeBSD L1OM support. */
6052 #undef TARGET_LITTLE_SYM
6053 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
6054 #undef TARGET_LITTLE_NAME
6055 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
6058 #define ELF_OSABI ELFOSABI_FREEBSD
6061 #define elf64_bed elf64_l1om_fbsd_bed
6063 #include "elf64-target.h"
6065 /* Intel K1OM support. */
6068 elf64_k1om_elf_object_p (bfd *abfd)
6070 /* Set the right machine number for an K1OM elf64 file. */
6071 bfd_default_set_arch_mach (abfd, bfd_arch_k1om, bfd_mach_k1om);
6075 #undef TARGET_LITTLE_SYM
6076 #define TARGET_LITTLE_SYM k1om_elf64_vec
6077 #undef TARGET_LITTLE_NAME
6078 #define TARGET_LITTLE_NAME "elf64-k1om"
6080 #define ELF_ARCH bfd_arch_k1om
6082 #undef ELF_MACHINE_CODE
6083 #define ELF_MACHINE_CODE EM_K1OM
6088 #define elf64_bed elf64_k1om_bed
6090 #undef elf_backend_object_p
6091 #define elf_backend_object_p elf64_k1om_elf_object_p
6093 #undef elf_backend_static_tls_alignment
6095 #undef elf_backend_want_plt_sym
6096 #define elf_backend_want_plt_sym 0
6098 #include "elf64-target.h"
6100 /* FreeBSD K1OM support. */
6102 #undef TARGET_LITTLE_SYM
6103 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
6104 #undef TARGET_LITTLE_NAME
6105 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
6108 #define ELF_OSABI ELFOSABI_FREEBSD
6111 #define elf64_bed elf64_k1om_fbsd_bed
6113 #include "elf64-target.h"
6115 /* 32bit x86-64 support. */
6117 #undef TARGET_LITTLE_SYM
6118 #define TARGET_LITTLE_SYM x86_64_elf32_vec
6119 #undef TARGET_LITTLE_NAME
6120 #define TARGET_LITTLE_NAME "elf32-x86-64"
6124 #define ELF_ARCH bfd_arch_i386
6126 #undef ELF_MACHINE_CODE
6127 #define ELF_MACHINE_CODE EM_X86_64
6131 #undef elf_backend_object_p
6132 #define elf_backend_object_p \
6133 elf32_x86_64_elf_object_p
6135 #undef elf_backend_bfd_from_remote_memory
6136 #define elf_backend_bfd_from_remote_memory \
6137 _bfd_elf32_bfd_from_remote_memory
6139 #undef elf_backend_size_info
6140 #define elf_backend_size_info \
6141 _bfd_elf32_size_info
6143 #include "elf32-target.h"