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, 0, 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 "/lib/ld64.so.1"
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 (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 relocs against symbols which
2681 turn out to need copy relocs. */
2682 else if (info->executable
2683 && (h->needs_copy || eh->needs_copy)
2686 eh->dyn_relocs = NULL;
2689 else if (ELIMINATE_COPY_RELOCS)
2691 /* For the non-shared case, discard space for relocs against
2692 symbols which turn out to need copy relocs or are not
2698 || (htab->elf.dynamic_sections_created
2699 && (h->root.type == bfd_link_hash_undefweak
2700 || h->root.type == bfd_link_hash_undefined))))
2702 /* Make sure this symbol is output as a dynamic symbol.
2703 Undefined weak syms won't yet be marked as dynamic. */
2704 if (h->dynindx == -1
2705 && ! h->forced_local
2706 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2709 /* If that succeeded, we know we'll be keeping all the
2711 if (h->dynindx != -1)
2715 eh->dyn_relocs = NULL;
2720 /* Finally, allocate space. */
2721 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2725 sreloc = elf_section_data (p->sec)->sreloc;
2727 BFD_ASSERT (sreloc != NULL);
2729 sreloc->size += p->count * bed->s->sizeof_rela;
2735 /* Allocate space in .plt, .got and associated reloc sections for
2736 local dynamic relocs. */
2739 elf_x86_64_allocate_local_dynrelocs (void **slot, void *inf)
2741 struct elf_link_hash_entry *h
2742 = (struct elf_link_hash_entry *) *slot;
2744 if (h->type != STT_GNU_IFUNC
2748 || h->root.type != bfd_link_hash_defined)
2751 return elf_x86_64_allocate_dynrelocs (h, inf);
2754 /* Find any dynamic relocs that apply to read-only sections. */
2757 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry *h,
2760 struct elf_x86_64_link_hash_entry *eh;
2761 struct elf_dyn_relocs *p;
2763 /* Skip local IFUNC symbols. */
2764 if (h->forced_local && h->type == STT_GNU_IFUNC)
2767 eh = (struct elf_x86_64_link_hash_entry *) h;
2768 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2770 asection *s = p->sec->output_section;
2772 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2774 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2776 info->flags |= DF_TEXTREL;
2778 if (info->warn_shared_textrel && info->shared)
2779 info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2780 p->sec->owner, h->root.root.string,
2783 /* Not an error, just cut short the traversal. */
2791 mov foo@GOTPCREL(%rip), %reg
2794 with the local symbol, foo. */
2797 elf_x86_64_convert_mov_to_lea (bfd *abfd, asection *sec,
2798 struct bfd_link_info *link_info)
2800 Elf_Internal_Shdr *symtab_hdr;
2801 Elf_Internal_Rela *internal_relocs;
2802 Elf_Internal_Rela *irel, *irelend;
2804 struct elf_x86_64_link_hash_table *htab;
2805 bfd_boolean changed_contents;
2806 bfd_boolean changed_relocs;
2807 bfd_signed_vma *local_got_refcounts;
2809 /* Don't even try to convert non-ELF outputs. */
2810 if (!is_elf_hash_table (link_info->hash))
2813 /* Nothing to do if there are no codes, no relocations or no output. */
2814 if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
2815 || sec->reloc_count == 0
2816 || bfd_is_abs_section (sec->output_section))
2819 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2821 /* Load the relocations for this section. */
2822 internal_relocs = (_bfd_elf_link_read_relocs
2823 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
2824 link_info->keep_memory));
2825 if (internal_relocs == NULL)
2828 htab = elf_x86_64_hash_table (link_info);
2829 changed_contents = FALSE;
2830 changed_relocs = FALSE;
2831 local_got_refcounts = elf_local_got_refcounts (abfd);
2833 /* Get the section contents. */
2834 if (elf_section_data (sec)->this_hdr.contents != NULL)
2835 contents = elf_section_data (sec)->this_hdr.contents;
2838 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
2842 irelend = internal_relocs + sec->reloc_count;
2843 for (irel = internal_relocs; irel < irelend; irel++)
2845 unsigned int r_type = ELF32_R_TYPE (irel->r_info);
2846 unsigned int r_symndx = htab->r_sym (irel->r_info);
2848 struct elf_link_hash_entry *h;
2850 if (r_type != R_X86_64_GOTPCREL)
2853 /* Get the symbol referred to by the reloc. */
2854 if (r_symndx < symtab_hdr->sh_info)
2856 Elf_Internal_Sym *isym;
2858 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2861 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. */
2862 if (ELF_ST_TYPE (isym->st_info) != STT_GNU_IFUNC
2863 && bfd_get_8 (input_bfd,
2864 contents + irel->r_offset - 2) == 0x8b)
2866 bfd_put_8 (output_bfd, 0x8d,
2867 contents + irel->r_offset - 2);
2868 irel->r_info = htab->r_info (r_symndx, R_X86_64_PC32);
2869 if (local_got_refcounts != NULL
2870 && local_got_refcounts[r_symndx] > 0)
2871 local_got_refcounts[r_symndx] -= 1;
2872 changed_contents = TRUE;
2873 changed_relocs = TRUE;
2878 indx = r_symndx - symtab_hdr->sh_info;
2879 h = elf_sym_hashes (abfd)[indx];
2880 BFD_ASSERT (h != NULL);
2882 while (h->root.type == bfd_link_hash_indirect
2883 || h->root.type == bfd_link_hash_warning)
2884 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2886 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. We also
2887 avoid optimizing _DYNAMIC since ld.so may use its link-time
2890 && h->type != STT_GNU_IFUNC
2891 && h != htab->elf.hdynamic
2892 && SYMBOL_REFERENCES_LOCAL (link_info, h)
2893 && bfd_get_8 (input_bfd,
2894 contents + irel->r_offset - 2) == 0x8b)
2896 bfd_put_8 (output_bfd, 0x8d,
2897 contents + irel->r_offset - 2);
2898 irel->r_info = htab->r_info (r_symndx, R_X86_64_PC32);
2899 if (h->got.refcount > 0)
2900 h->got.refcount -= 1;
2901 changed_contents = TRUE;
2902 changed_relocs = TRUE;
2906 if (contents != NULL
2907 && elf_section_data (sec)->this_hdr.contents != contents)
2909 if (!changed_contents && !link_info->keep_memory)
2913 /* Cache the section contents for elf_link_input_bfd. */
2914 elf_section_data (sec)->this_hdr.contents = contents;
2918 if (elf_section_data (sec)->relocs != internal_relocs)
2920 if (!changed_relocs)
2921 free (internal_relocs);
2923 elf_section_data (sec)->relocs = internal_relocs;
2929 if (contents != NULL
2930 && elf_section_data (sec)->this_hdr.contents != contents)
2932 if (internal_relocs != NULL
2933 && elf_section_data (sec)->relocs != internal_relocs)
2934 free (internal_relocs);
2938 /* Set the sizes of the dynamic sections. */
2941 elf_x86_64_size_dynamic_sections (bfd *output_bfd,
2942 struct bfd_link_info *info)
2944 struct elf_x86_64_link_hash_table *htab;
2949 const struct elf_backend_data *bed;
2951 htab = elf_x86_64_hash_table (info);
2954 bed = get_elf_backend_data (output_bfd);
2956 dynobj = htab->elf.dynobj;
2960 if (htab->elf.dynamic_sections_created)
2962 /* Set the contents of the .interp section to the interpreter. */
2963 if (info->executable)
2965 s = bfd_get_linker_section (dynobj, ".interp");
2968 s->size = htab->dynamic_interpreter_size;
2969 s->contents = (unsigned char *) htab->dynamic_interpreter;
2973 /* Set up .got offsets for local syms, and space for local dynamic
2975 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2977 bfd_signed_vma *local_got;
2978 bfd_signed_vma *end_local_got;
2979 char *local_tls_type;
2980 bfd_vma *local_tlsdesc_gotent;
2981 bfd_size_type locsymcount;
2982 Elf_Internal_Shdr *symtab_hdr;
2985 if (! is_x86_64_elf (ibfd))
2988 for (s = ibfd->sections; s != NULL; s = s->next)
2990 struct elf_dyn_relocs *p;
2992 if (!elf_x86_64_convert_mov_to_lea (ibfd, s, info))
2995 for (p = (struct elf_dyn_relocs *)
2996 (elf_section_data (s)->local_dynrel);
3000 if (!bfd_is_abs_section (p->sec)
3001 && bfd_is_abs_section (p->sec->output_section))
3003 /* Input section has been discarded, either because
3004 it is a copy of a linkonce section or due to
3005 linker script /DISCARD/, so we'll be discarding
3008 else if (p->count != 0)
3010 srel = elf_section_data (p->sec)->sreloc;
3011 srel->size += p->count * bed->s->sizeof_rela;
3012 if ((p->sec->output_section->flags & SEC_READONLY) != 0
3013 && (info->flags & DF_TEXTREL) == 0)
3015 info->flags |= DF_TEXTREL;
3016 if (info->warn_shared_textrel && info->shared)
3017 info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
3018 p->sec->owner, p->sec);
3024 local_got = elf_local_got_refcounts (ibfd);
3028 symtab_hdr = &elf_symtab_hdr (ibfd);
3029 locsymcount = symtab_hdr->sh_info;
3030 end_local_got = local_got + locsymcount;
3031 local_tls_type = elf_x86_64_local_got_tls_type (ibfd);
3032 local_tlsdesc_gotent = elf_x86_64_local_tlsdesc_gotent (ibfd);
3034 srel = htab->elf.srelgot;
3035 for (; local_got < end_local_got;
3036 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
3038 *local_tlsdesc_gotent = (bfd_vma) -1;
3041 if (GOT_TLS_GDESC_P (*local_tls_type))
3043 *local_tlsdesc_gotent = htab->elf.sgotplt->size
3044 - elf_x86_64_compute_jump_table_size (htab);
3045 htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
3046 *local_got = (bfd_vma) -2;
3048 if (! GOT_TLS_GDESC_P (*local_tls_type)
3049 || GOT_TLS_GD_P (*local_tls_type))
3051 *local_got = s->size;
3052 s->size += GOT_ENTRY_SIZE;
3053 if (GOT_TLS_GD_P (*local_tls_type))
3054 s->size += GOT_ENTRY_SIZE;
3057 || GOT_TLS_GD_ANY_P (*local_tls_type)
3058 || *local_tls_type == GOT_TLS_IE)
3060 if (GOT_TLS_GDESC_P (*local_tls_type))
3062 htab->elf.srelplt->size
3063 += bed->s->sizeof_rela;
3064 htab->tlsdesc_plt = (bfd_vma) -1;
3066 if (! GOT_TLS_GDESC_P (*local_tls_type)
3067 || GOT_TLS_GD_P (*local_tls_type))
3068 srel->size += bed->s->sizeof_rela;
3072 *local_got = (bfd_vma) -1;
3076 if (htab->tls_ld_got.refcount > 0)
3078 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3080 htab->tls_ld_got.offset = htab->elf.sgot->size;
3081 htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
3082 htab->elf.srelgot->size += bed->s->sizeof_rela;
3085 htab->tls_ld_got.offset = -1;
3087 /* Allocate global sym .plt and .got entries, and space for global
3088 sym dynamic relocs. */
3089 elf_link_hash_traverse (&htab->elf, elf_x86_64_allocate_dynrelocs,
3092 /* Allocate .plt and .got entries, and space for local symbols. */
3093 htab_traverse (htab->loc_hash_table,
3094 elf_x86_64_allocate_local_dynrelocs,
3097 /* For every jump slot reserved in the sgotplt, reloc_count is
3098 incremented. However, when we reserve space for TLS descriptors,
3099 it's not incremented, so in order to compute the space reserved
3100 for them, it suffices to multiply the reloc count by the jump
3103 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3104 so that R_X86_64_IRELATIVE entries come last. */
3105 if (htab->elf.srelplt)
3107 htab->sgotplt_jump_table_size
3108 = elf_x86_64_compute_jump_table_size (htab);
3109 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
3111 else if (htab->elf.irelplt)
3112 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
3114 if (htab->tlsdesc_plt)
3116 /* If we're not using lazy TLS relocations, don't generate the
3117 PLT and GOT entries they require. */
3118 if ((info->flags & DF_BIND_NOW))
3119 htab->tlsdesc_plt = 0;
3122 htab->tlsdesc_got = htab->elf.sgot->size;
3123 htab->elf.sgot->size += GOT_ENTRY_SIZE;
3124 /* Reserve room for the initial entry.
3125 FIXME: we could probably do away with it in this case. */
3126 if (htab->elf.splt->size == 0)
3127 htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd);
3128 htab->tlsdesc_plt = htab->elf.splt->size;
3129 htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd);
3133 if (htab->elf.sgotplt)
3135 /* Don't allocate .got.plt section if there are no GOT nor PLT
3136 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3137 if ((htab->elf.hgot == NULL
3138 || !htab->elf.hgot->ref_regular_nonweak)
3139 && (htab->elf.sgotplt->size
3140 == get_elf_backend_data (output_bfd)->got_header_size)
3141 && (htab->elf.splt == NULL
3142 || htab->elf.splt->size == 0)
3143 && (htab->elf.sgot == NULL
3144 || htab->elf.sgot->size == 0)
3145 && (htab->elf.iplt == NULL
3146 || htab->elf.iplt->size == 0)
3147 && (htab->elf.igotplt == NULL
3148 || htab->elf.igotplt->size == 0))
3149 htab->elf.sgotplt->size = 0;
3152 if (htab->plt_eh_frame != NULL
3153 && htab->elf.splt != NULL
3154 && htab->elf.splt->size != 0
3155 && !bfd_is_abs_section (htab->elf.splt->output_section)
3156 && _bfd_elf_eh_frame_present (info))
3158 const struct elf_x86_64_backend_data *arch_data
3159 = get_elf_x86_64_arch_data (bed);
3160 htab->plt_eh_frame->size = arch_data->eh_frame_plt_size;
3163 /* We now have determined the sizes of the various dynamic sections.
3164 Allocate memory for them. */
3166 for (s = dynobj->sections; s != NULL; s = s->next)
3168 if ((s->flags & SEC_LINKER_CREATED) == 0)
3171 if (s == htab->elf.splt
3172 || s == htab->elf.sgot
3173 || s == htab->elf.sgotplt
3174 || s == htab->elf.iplt
3175 || s == htab->elf.igotplt
3176 || s == htab->plt_bnd
3177 || s == htab->plt_eh_frame
3178 || s == htab->sdynbss)
3180 /* Strip this section if we don't need it; see the
3183 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
3185 if (s->size != 0 && s != htab->elf.srelplt)
3188 /* We use the reloc_count field as a counter if we need
3189 to copy relocs into the output file. */
3190 if (s != htab->elf.srelplt)
3195 /* It's not one of our sections, so don't allocate space. */
3201 /* If we don't need this section, strip it from the
3202 output file. This is mostly to handle .rela.bss and
3203 .rela.plt. We must create both sections in
3204 create_dynamic_sections, because they must be created
3205 before the linker maps input sections to output
3206 sections. The linker does that before
3207 adjust_dynamic_symbol is called, and it is that
3208 function which decides whether anything needs to go
3209 into these sections. */
3211 s->flags |= SEC_EXCLUDE;
3215 if ((s->flags & SEC_HAS_CONTENTS) == 0)
3218 /* Allocate memory for the section contents. We use bfd_zalloc
3219 here in case unused entries are not reclaimed before the
3220 section's contents are written out. This should not happen,
3221 but this way if it does, we get a R_X86_64_NONE reloc instead
3223 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3224 if (s->contents == NULL)
3228 if (htab->plt_eh_frame != NULL
3229 && htab->plt_eh_frame->contents != NULL)
3231 const struct elf_x86_64_backend_data *arch_data
3232 = get_elf_x86_64_arch_data (bed);
3234 memcpy (htab->plt_eh_frame->contents,
3235 arch_data->eh_frame_plt, htab->plt_eh_frame->size);
3236 bfd_put_32 (dynobj, htab->elf.splt->size,
3237 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
3240 if (htab->elf.dynamic_sections_created)
3242 /* Add some entries to the .dynamic section. We fill in the
3243 values later, in elf_x86_64_finish_dynamic_sections, but we
3244 must add the entries now so that we get the correct size for
3245 the .dynamic section. The DT_DEBUG entry is filled in by the
3246 dynamic linker and used by the debugger. */
3247 #define add_dynamic_entry(TAG, VAL) \
3248 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3250 if (info->executable)
3252 if (!add_dynamic_entry (DT_DEBUG, 0))
3256 if (htab->elf.splt->size != 0)
3258 if (!add_dynamic_entry (DT_PLTGOT, 0)
3259 || !add_dynamic_entry (DT_PLTRELSZ, 0)
3260 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3261 || !add_dynamic_entry (DT_JMPREL, 0))
3264 if (htab->tlsdesc_plt
3265 && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
3266 || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
3272 if (!add_dynamic_entry (DT_RELA, 0)
3273 || !add_dynamic_entry (DT_RELASZ, 0)
3274 || !add_dynamic_entry (DT_RELAENT, bed->s->sizeof_rela))
3277 /* If any dynamic relocs apply to a read-only section,
3278 then we need a DT_TEXTREL entry. */
3279 if ((info->flags & DF_TEXTREL) == 0)
3280 elf_link_hash_traverse (&htab->elf,
3281 elf_x86_64_readonly_dynrelocs,
3284 if ((info->flags & DF_TEXTREL) != 0)
3286 if (!add_dynamic_entry (DT_TEXTREL, 0))
3291 #undef add_dynamic_entry
3297 elf_x86_64_always_size_sections (bfd *output_bfd,
3298 struct bfd_link_info *info)
3300 asection *tls_sec = elf_hash_table (info)->tls_sec;
3304 struct elf_link_hash_entry *tlsbase;
3306 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
3307 "_TLS_MODULE_BASE_",
3308 FALSE, FALSE, FALSE);
3310 if (tlsbase && tlsbase->type == STT_TLS)
3312 struct elf_x86_64_link_hash_table *htab;
3313 struct bfd_link_hash_entry *bh = NULL;
3314 const struct elf_backend_data *bed
3315 = get_elf_backend_data (output_bfd);
3317 htab = elf_x86_64_hash_table (info);
3321 if (!(_bfd_generic_link_add_one_symbol
3322 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
3323 tls_sec, 0, NULL, FALSE,
3324 bed->collect, &bh)))
3327 htab->tls_module_base = bh;
3329 tlsbase = (struct elf_link_hash_entry *)bh;
3330 tlsbase->def_regular = 1;
3331 tlsbase->other = STV_HIDDEN;
3332 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
3339 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3340 executables. Rather than setting it to the beginning of the TLS
3341 section, we have to set it to the end. This function may be called
3342 multiple times, it is idempotent. */
3345 elf_x86_64_set_tls_module_base (struct bfd_link_info *info)
3347 struct elf_x86_64_link_hash_table *htab;
3348 struct bfd_link_hash_entry *base;
3350 if (!info->executable)
3353 htab = elf_x86_64_hash_table (info);
3357 base = htab->tls_module_base;
3361 base->u.def.value = htab->elf.tls_size;
3364 /* Return the base VMA address which should be subtracted from real addresses
3365 when resolving @dtpoff relocation.
3366 This is PT_TLS segment p_vaddr. */
3369 elf_x86_64_dtpoff_base (struct bfd_link_info *info)
3371 /* If tls_sec is NULL, we should have signalled an error already. */
3372 if (elf_hash_table (info)->tls_sec == NULL)
3374 return elf_hash_table (info)->tls_sec->vma;
3377 /* Return the relocation value for @tpoff relocation
3378 if STT_TLS virtual address is ADDRESS. */
3381 elf_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address)
3383 struct elf_link_hash_table *htab = elf_hash_table (info);
3384 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3385 bfd_vma static_tls_size;
3387 /* If tls_segment is NULL, we should have signalled an error already. */
3388 if (htab->tls_sec == NULL)
3391 /* Consider special static TLS alignment requirements. */
3392 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3393 return address - static_tls_size - htab->tls_sec->vma;
3396 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
3400 is_32bit_relative_branch (bfd_byte *contents, bfd_vma offset)
3402 /* Opcode Instruction
3405 0x0f 0x8x conditional jump */
3407 && (contents [offset - 1] == 0xe8
3408 || contents [offset - 1] == 0xe9))
3410 && contents [offset - 2] == 0x0f
3411 && (contents [offset - 1] & 0xf0) == 0x80));
3414 /* Relocate an x86_64 ELF section. */
3417 elf_x86_64_relocate_section (bfd *output_bfd,
3418 struct bfd_link_info *info,
3420 asection *input_section,
3422 Elf_Internal_Rela *relocs,
3423 Elf_Internal_Sym *local_syms,
3424 asection **local_sections)
3426 struct elf_x86_64_link_hash_table *htab;
3427 Elf_Internal_Shdr *symtab_hdr;
3428 struct elf_link_hash_entry **sym_hashes;
3429 bfd_vma *local_got_offsets;
3430 bfd_vma *local_tlsdesc_gotents;
3431 Elf_Internal_Rela *rel;
3432 Elf_Internal_Rela *relend;
3433 const unsigned int plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
3435 BFD_ASSERT (is_x86_64_elf (input_bfd));
3437 htab = elf_x86_64_hash_table (info);
3440 symtab_hdr = &elf_symtab_hdr (input_bfd);
3441 sym_hashes = elf_sym_hashes (input_bfd);
3442 local_got_offsets = elf_local_got_offsets (input_bfd);
3443 local_tlsdesc_gotents = elf_x86_64_local_tlsdesc_gotent (input_bfd);
3445 elf_x86_64_set_tls_module_base (info);
3448 relend = relocs + input_section->reloc_count;
3449 for (; rel < relend; rel++)
3451 unsigned int r_type;
3452 reloc_howto_type *howto;
3453 unsigned long r_symndx;
3454 struct elf_link_hash_entry *h;
3455 struct elf_x86_64_link_hash_entry *eh;
3456 Elf_Internal_Sym *sym;
3458 bfd_vma off, offplt, plt_offset;
3460 bfd_boolean unresolved_reloc;
3461 bfd_reloc_status_type r;
3463 asection *base_got, *resolved_plt;
3466 r_type = ELF32_R_TYPE (rel->r_info);
3467 if (r_type == (int) R_X86_64_GNU_VTINHERIT
3468 || r_type == (int) R_X86_64_GNU_VTENTRY)
3471 if (r_type >= (int) R_X86_64_standard)
3473 (*_bfd_error_handler)
3474 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3475 input_bfd, input_section, r_type);
3476 bfd_set_error (bfd_error_bad_value);
3480 if (r_type != (int) R_X86_64_32
3481 || ABI_64_P (output_bfd))
3482 howto = x86_64_elf_howto_table + r_type;
3484 howto = (x86_64_elf_howto_table
3485 + ARRAY_SIZE (x86_64_elf_howto_table) - 1);
3486 r_symndx = htab->r_sym (rel->r_info);
3490 unresolved_reloc = FALSE;
3491 if (r_symndx < symtab_hdr->sh_info)
3493 sym = local_syms + r_symndx;
3494 sec = local_sections[r_symndx];
3496 relocation = _bfd_elf_rela_local_sym (output_bfd, sym,
3498 st_size = sym->st_size;
3500 /* Relocate against local STT_GNU_IFUNC symbol. */
3501 if (!info->relocatable
3502 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3504 h = elf_x86_64_get_local_sym_hash (htab, input_bfd,
3509 /* Set STT_GNU_IFUNC symbol value. */
3510 h->root.u.def.value = sym->st_value;
3511 h->root.u.def.section = sec;
3516 bfd_boolean warned ATTRIBUTE_UNUSED;
3517 bfd_boolean ignored ATTRIBUTE_UNUSED;
3519 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3520 r_symndx, symtab_hdr, sym_hashes,
3522 unresolved_reloc, warned, ignored);
3526 if (sec != NULL && discarded_section (sec))
3527 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3528 rel, 1, relend, howto, 0, contents);
3530 if (info->relocatable)
3533 if (rel->r_addend == 0 && !ABI_64_P (output_bfd))
3535 if (r_type == R_X86_64_64)
3537 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
3538 zero-extend it to 64bit if addend is zero. */
3539 r_type = R_X86_64_32;
3540 memset (contents + rel->r_offset + 4, 0, 4);
3542 else if (r_type == R_X86_64_SIZE64)
3544 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
3545 zero-extend it to 64bit if addend is zero. */
3546 r_type = R_X86_64_SIZE32;
3547 memset (contents + rel->r_offset + 4, 0, 4);
3551 eh = (struct elf_x86_64_link_hash_entry *) h;
3553 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3554 it here if it is defined in a non-shared object. */
3556 && h->type == STT_GNU_IFUNC
3562 if ((input_section->flags & SEC_ALLOC) == 0
3563 || h->plt.offset == (bfd_vma) -1)
3566 /* STT_GNU_IFUNC symbol must go through PLT. */
3567 if (htab->elf.splt != NULL)
3569 if (htab->plt_bnd != NULL)
3571 resolved_plt = htab->plt_bnd;
3572 plt_offset = eh->plt_bnd.offset;
3576 resolved_plt = htab->elf.splt;
3577 plt_offset = h->plt.offset;
3582 resolved_plt = htab->elf.iplt;
3583 plt_offset = h->plt.offset;
3586 relocation = (resolved_plt->output_section->vma
3587 + resolved_plt->output_offset + plt_offset);
3592 if (h->root.root.string)
3593 name = h->root.root.string;
3595 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3597 (*_bfd_error_handler)
3598 (_("%B: relocation %s against STT_GNU_IFUNC "
3599 "symbol `%s' isn't handled by %s"), input_bfd,
3600 x86_64_elf_howto_table[r_type].name,
3601 name, __FUNCTION__);
3602 bfd_set_error (bfd_error_bad_value);
3611 if (ABI_64_P (output_bfd))
3615 if (rel->r_addend != 0)
3617 if (h->root.root.string)
3618 name = h->root.root.string;
3620 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
3622 (*_bfd_error_handler)
3623 (_("%B: relocation %s against STT_GNU_IFUNC "
3624 "symbol `%s' has non-zero addend: %d"),
3625 input_bfd, x86_64_elf_howto_table[r_type].name,
3626 name, rel->r_addend);
3627 bfd_set_error (bfd_error_bad_value);
3631 /* Generate dynamic relcoation only when there is a
3632 non-GOT reference in a shared object. */
3633 if (info->shared && h->non_got_ref)
3635 Elf_Internal_Rela outrel;
3638 /* Need a dynamic relocation to get the real function
3640 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
3644 if (outrel.r_offset == (bfd_vma) -1
3645 || outrel.r_offset == (bfd_vma) -2)
3648 outrel.r_offset += (input_section->output_section->vma
3649 + input_section->output_offset);
3651 if (h->dynindx == -1
3653 || info->executable)
3655 /* This symbol is resolved locally. */
3656 outrel.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
3657 outrel.r_addend = (h->root.u.def.value
3658 + h->root.u.def.section->output_section->vma
3659 + h->root.u.def.section->output_offset);
3663 outrel.r_info = htab->r_info (h->dynindx, r_type);
3664 outrel.r_addend = 0;
3667 sreloc = htab->elf.irelifunc;
3668 elf_append_rela (output_bfd, sreloc, &outrel);
3670 /* If this reloc is against an external symbol, we
3671 do not want to fiddle with the addend. Otherwise,
3672 we need to include the symbol value so that it
3673 becomes an addend for the dynamic reloc. For an
3674 internal symbol, we have updated addend. */
3679 case R_X86_64_PC32_BND:
3681 case R_X86_64_PLT32:
3682 case R_X86_64_PLT32_BND:
3685 case R_X86_64_GOTPCREL:
3686 case R_X86_64_GOTPCREL64:
3687 base_got = htab->elf.sgot;
3688 off = h->got.offset;
3690 if (base_got == NULL)
3693 if (off == (bfd_vma) -1)
3695 /* We can't use h->got.offset here to save state, or
3696 even just remember the offset, as finish_dynamic_symbol
3697 would use that as offset into .got. */
3699 if (htab->elf.splt != NULL)
3701 plt_index = h->plt.offset / plt_entry_size - 1;
3702 off = (plt_index + 3) * GOT_ENTRY_SIZE;
3703 base_got = htab->elf.sgotplt;
3707 plt_index = h->plt.offset / plt_entry_size;
3708 off = plt_index * GOT_ENTRY_SIZE;
3709 base_got = htab->elf.igotplt;
3712 if (h->dynindx == -1
3716 /* This references the local defitionion. We must
3717 initialize this entry in the global offset table.
3718 Since the offset must always be a multiple of 8,
3719 we use the least significant bit to record
3720 whether we have initialized it already.
3722 When doing a dynamic link, we create a .rela.got
3723 relocation entry to initialize the value. This
3724 is done in the finish_dynamic_symbol routine. */
3729 bfd_put_64 (output_bfd, relocation,
3730 base_got->contents + off);
3731 /* Note that this is harmless for the GOTPLT64
3732 case, as -1 | 1 still is -1. */
3738 relocation = (base_got->output_section->vma
3739 + base_got->output_offset + off);
3745 /* When generating a shared object, the relocations handled here are
3746 copied into the output file to be resolved at run time. */
3749 case R_X86_64_GOT32:
3750 case R_X86_64_GOT64:
3751 /* Relocation is to the entry for this symbol in the global
3753 case R_X86_64_GOTPCREL:
3754 case R_X86_64_GOTPCREL64:
3755 /* Use global offset table entry as symbol value. */
3756 case R_X86_64_GOTPLT64:
3757 /* This is the same as GOT64 for relocation purposes, but
3758 indicates the existence of a PLT entry. The difficulty is,
3759 that we must calculate the GOT slot offset from the PLT
3760 offset, if this symbol got a PLT entry (it was global).
3761 Additionally if it's computed from the PLT entry, then that
3762 GOT offset is relative to .got.plt, not to .got. */
3763 base_got = htab->elf.sgot;
3765 if (htab->elf.sgot == NULL)
3772 off = h->got.offset;
3774 && h->plt.offset != (bfd_vma)-1
3775 && off == (bfd_vma)-1)
3777 /* We can't use h->got.offset here to save
3778 state, or even just remember the offset, as
3779 finish_dynamic_symbol would use that as offset into
3781 bfd_vma plt_index = h->plt.offset / plt_entry_size - 1;
3782 off = (plt_index + 3) * GOT_ENTRY_SIZE;
3783 base_got = htab->elf.sgotplt;
3786 dyn = htab->elf.dynamic_sections_created;
3788 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3790 && SYMBOL_REFERENCES_LOCAL (info, h))
3791 || (ELF_ST_VISIBILITY (h->other)
3792 && h->root.type == bfd_link_hash_undefweak))
3794 /* This is actually a static link, or it is a -Bsymbolic
3795 link and the symbol is defined locally, or the symbol
3796 was forced to be local because of a version file. We
3797 must initialize this entry in the global offset table.
3798 Since the offset must always be a multiple of 8, we
3799 use the least significant bit to record whether we
3800 have initialized it already.
3802 When doing a dynamic link, we create a .rela.got
3803 relocation entry to initialize the value. This is
3804 done in the finish_dynamic_symbol routine. */
3809 bfd_put_64 (output_bfd, relocation,
3810 base_got->contents + off);
3811 /* Note that this is harmless for the GOTPLT64 case,
3812 as -1 | 1 still is -1. */
3817 unresolved_reloc = FALSE;
3821 if (local_got_offsets == NULL)
3824 off = local_got_offsets[r_symndx];
3826 /* The offset must always be a multiple of 8. We use
3827 the least significant bit to record whether we have
3828 already generated the necessary reloc. */
3833 bfd_put_64 (output_bfd, relocation,
3834 base_got->contents + off);
3839 Elf_Internal_Rela outrel;
3841 /* We need to generate a R_X86_64_RELATIVE reloc
3842 for the dynamic linker. */
3843 s = htab->elf.srelgot;
3847 outrel.r_offset = (base_got->output_section->vma
3848 + base_got->output_offset
3850 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
3851 outrel.r_addend = relocation;
3852 elf_append_rela (output_bfd, s, &outrel);
3855 local_got_offsets[r_symndx] |= 1;
3859 if (off >= (bfd_vma) -2)
3862 relocation = base_got->output_section->vma
3863 + base_got->output_offset + off;
3864 if (r_type != R_X86_64_GOTPCREL && r_type != R_X86_64_GOTPCREL64)
3865 relocation -= htab->elf.sgotplt->output_section->vma
3866 - htab->elf.sgotplt->output_offset;
3870 case R_X86_64_GOTOFF64:
3871 /* Relocation is relative to the start of the global offset
3874 /* Check to make sure it isn't a protected function symbol
3875 for shared library since it may not be local when used
3876 as function address. */
3877 if (!info->executable
3879 && !SYMBOLIC_BIND (info, h)
3881 && h->type == STT_FUNC
3882 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
3884 (*_bfd_error_handler)
3885 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
3886 input_bfd, h->root.root.string);
3887 bfd_set_error (bfd_error_bad_value);
3891 /* Note that sgot is not involved in this
3892 calculation. We always want the start of .got.plt. If we
3893 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3894 permitted by the ABI, we might have to change this
3896 relocation -= htab->elf.sgotplt->output_section->vma
3897 + htab->elf.sgotplt->output_offset;
3900 case R_X86_64_GOTPC32:
3901 case R_X86_64_GOTPC64:
3902 /* Use global offset table as symbol value. */
3903 relocation = htab->elf.sgotplt->output_section->vma
3904 + htab->elf.sgotplt->output_offset;
3905 unresolved_reloc = FALSE;
3908 case R_X86_64_PLTOFF64:
3909 /* Relocation is PLT entry relative to GOT. For local
3910 symbols it's the symbol itself relative to GOT. */
3912 /* See PLT32 handling. */
3913 && h->plt.offset != (bfd_vma) -1
3914 && htab->elf.splt != NULL)
3916 if (htab->plt_bnd != NULL)
3918 resolved_plt = htab->plt_bnd;
3919 plt_offset = eh->plt_bnd.offset;
3923 resolved_plt = htab->elf.splt;
3924 plt_offset = h->plt.offset;
3927 relocation = (resolved_plt->output_section->vma
3928 + resolved_plt->output_offset
3930 unresolved_reloc = FALSE;
3933 relocation -= htab->elf.sgotplt->output_section->vma
3934 + htab->elf.sgotplt->output_offset;
3937 case R_X86_64_PLT32:
3938 case R_X86_64_PLT32_BND:
3939 /* Relocation is to the entry for this symbol in the
3940 procedure linkage table. */
3942 /* Resolve a PLT32 reloc against a local symbol directly,
3943 without using the procedure linkage table. */
3947 if (h->plt.offset == (bfd_vma) -1
3948 || htab->elf.splt == NULL)
3950 /* We didn't make a PLT entry for this symbol. This
3951 happens when statically linking PIC code, or when
3952 using -Bsymbolic. */
3956 if (htab->plt_bnd != NULL)
3958 resolved_plt = htab->plt_bnd;
3959 plt_offset = eh->plt_bnd.offset;
3963 resolved_plt = htab->elf.splt;
3964 plt_offset = h->plt.offset;
3967 relocation = (resolved_plt->output_section->vma
3968 + resolved_plt->output_offset
3970 unresolved_reloc = FALSE;
3973 case R_X86_64_SIZE32:
3974 case R_X86_64_SIZE64:
3975 /* Set to symbol size. */
3976 relocation = st_size;
3982 case R_X86_64_PC32_BND:
3984 && (input_section->flags & SEC_ALLOC) != 0
3985 && (input_section->flags & SEC_READONLY) != 0
3988 bfd_boolean fail = FALSE;
3990 = ((r_type == R_X86_64_PC32
3991 || r_type == R_X86_64_PC32_BND)
3992 && is_32bit_relative_branch (contents, rel->r_offset));
3994 if (SYMBOL_REFERENCES_LOCAL (info, h))
3996 /* Symbol is referenced locally. Make sure it is
3997 defined locally or for a branch. */
3998 fail = !h->def_regular && !branch;
4000 else if (!(info->executable
4001 && (h->needs_copy || eh->needs_copy)))
4003 /* Symbol doesn't need copy reloc and isn't referenced
4004 locally. We only allow branch to symbol with
4005 non-default visibility. */
4007 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT);
4014 const char *pic = "";
4016 switch (ELF_ST_VISIBILITY (h->other))
4019 v = _("hidden symbol");
4022 v = _("internal symbol");
4025 v = _("protected symbol");
4029 pic = _("; recompile with -fPIC");
4034 fmt = _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
4036 fmt = _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
4038 (*_bfd_error_handler) (fmt, input_bfd,
4039 x86_64_elf_howto_table[r_type].name,
4040 v, h->root.root.string, pic);
4041 bfd_set_error (bfd_error_bad_value);
4052 /* FIXME: The ABI says the linker should make sure the value is
4053 the same when it's zeroextended to 64 bit. */
4056 if ((input_section->flags & SEC_ALLOC) == 0)
4059 /* Don't copy a pc-relative relocation into the output file
4060 if the symbol needs copy reloc. */
4062 && !(info->executable
4064 && (h->needs_copy || eh->needs_copy)
4065 && IS_X86_64_PCREL_TYPE (r_type))
4067 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4068 || h->root.type != bfd_link_hash_undefweak)
4069 && ((! IS_X86_64_PCREL_TYPE (r_type)
4070 && r_type != R_X86_64_SIZE32
4071 && r_type != R_X86_64_SIZE64)
4072 || ! SYMBOL_CALLS_LOCAL (info, h)))
4073 || (ELIMINATE_COPY_RELOCS
4080 || h->root.type == bfd_link_hash_undefweak
4081 || h->root.type == bfd_link_hash_undefined)))
4083 Elf_Internal_Rela outrel;
4084 bfd_boolean skip, relocate;
4087 /* When generating a shared object, these relocations
4088 are copied into the output file to be resolved at run
4094 _bfd_elf_section_offset (output_bfd, info, input_section,
4096 if (outrel.r_offset == (bfd_vma) -1)
4098 else if (outrel.r_offset == (bfd_vma) -2)
4099 skip = TRUE, relocate = TRUE;
4101 outrel.r_offset += (input_section->output_section->vma
4102 + input_section->output_offset);
4105 memset (&outrel, 0, sizeof outrel);
4107 /* h->dynindx may be -1 if this symbol was marked to
4111 && (IS_X86_64_PCREL_TYPE (r_type)
4113 || ! SYMBOLIC_BIND (info, h)
4114 || ! h->def_regular))
4116 outrel.r_info = htab->r_info (h->dynindx, r_type);
4117 outrel.r_addend = rel->r_addend;
4121 /* This symbol is local, or marked to become local. */
4122 if (r_type == htab->pointer_r_type)
4125 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
4126 outrel.r_addend = relocation + rel->r_addend;
4128 else if (r_type == R_X86_64_64
4129 && !ABI_64_P (output_bfd))
4132 outrel.r_info = htab->r_info (0,
4133 R_X86_64_RELATIVE64);
4134 outrel.r_addend = relocation + rel->r_addend;
4135 /* Check addend overflow. */
4136 if ((outrel.r_addend & 0x80000000)
4137 != (rel->r_addend & 0x80000000))
4140 int addend = rel->r_addend;
4141 if (h && h->root.root.string)
4142 name = h->root.root.string;
4144 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
4147 (*_bfd_error_handler)
4148 (_("%B: addend -0x%x in relocation %s against "
4149 "symbol `%s' at 0x%lx in section `%A' is "
4151 input_bfd, input_section, addend,
4152 x86_64_elf_howto_table[r_type].name,
4153 name, (unsigned long) rel->r_offset);
4155 (*_bfd_error_handler)
4156 (_("%B: addend 0x%x in relocation %s against "
4157 "symbol `%s' at 0x%lx in section `%A' is "
4159 input_bfd, input_section, addend,
4160 x86_64_elf_howto_table[r_type].name,
4161 name, (unsigned long) rel->r_offset);
4162 bfd_set_error (bfd_error_bad_value);
4170 if (bfd_is_abs_section (sec))
4172 else if (sec == NULL || sec->owner == NULL)
4174 bfd_set_error (bfd_error_bad_value);
4181 /* We are turning this relocation into one
4182 against a section symbol. It would be
4183 proper to subtract the symbol's value,
4184 osec->vma, from the emitted reloc addend,
4185 but ld.so expects buggy relocs. */
4186 osec = sec->output_section;
4187 sindx = elf_section_data (osec)->dynindx;
4190 asection *oi = htab->elf.text_index_section;
4191 sindx = elf_section_data (oi)->dynindx;
4193 BFD_ASSERT (sindx != 0);
4196 outrel.r_info = htab->r_info (sindx, r_type);
4197 outrel.r_addend = relocation + rel->r_addend;
4201 sreloc = elf_section_data (input_section)->sreloc;
4203 if (sreloc == NULL || sreloc->contents == NULL)
4205 r = bfd_reloc_notsupported;
4206 goto check_relocation_error;
4209 elf_append_rela (output_bfd, sreloc, &outrel);
4211 /* If this reloc is against an external symbol, we do
4212 not want to fiddle with the addend. Otherwise, we
4213 need to include the symbol value so that it becomes
4214 an addend for the dynamic reloc. */
4221 case R_X86_64_TLSGD:
4222 case R_X86_64_GOTPC32_TLSDESC:
4223 case R_X86_64_TLSDESC_CALL:
4224 case R_X86_64_GOTTPOFF:
4225 tls_type = GOT_UNKNOWN;
4226 if (h == NULL && local_got_offsets)
4227 tls_type = elf_x86_64_local_got_tls_type (input_bfd) [r_symndx];
4229 tls_type = elf_x86_64_hash_entry (h)->tls_type;
4231 if (! elf_x86_64_tls_transition (info, input_bfd,
4232 input_section, contents,
4233 symtab_hdr, sym_hashes,
4234 &r_type, tls_type, rel,
4235 relend, h, r_symndx))
4238 if (r_type == R_X86_64_TPOFF32)
4240 bfd_vma roff = rel->r_offset;
4242 BFD_ASSERT (! unresolved_reloc);
4244 if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
4246 /* GD->LE transition. For 64bit, change
4247 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4248 .word 0x6666; rex64; call __tls_get_addr
4251 leaq foo@tpoff(%rax), %rax
4253 leaq foo@tlsgd(%rip), %rdi
4254 .word 0x6666; rex64; call __tls_get_addr
4257 leaq foo@tpoff(%rax), %rax
4258 For largepic, change:
4259 leaq foo@tlsgd(%rip), %rdi
4260 movabsq $__tls_get_addr@pltoff, %rax
4265 leaq foo@tpoff(%rax), %rax
4266 nopw 0x0(%rax,%rax,1) */
4268 if (ABI_64_P (output_bfd)
4269 && contents[roff + 5] == (bfd_byte) '\xb8')
4271 memcpy (contents + roff - 3,
4272 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
4273 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4276 else if (ABI_64_P (output_bfd))
4277 memcpy (contents + roff - 4,
4278 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4281 memcpy (contents + roff - 3,
4282 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4284 bfd_put_32 (output_bfd,
4285 elf_x86_64_tpoff (info, relocation),
4286 contents + roff + 8 + largepic);
4287 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4291 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
4293 /* GDesc -> LE transition.
4294 It's originally something like:
4295 leaq x@tlsdesc(%rip), %rax
4298 movl $x@tpoff, %rax. */
4300 unsigned int val, type;
4302 type = bfd_get_8 (input_bfd, contents + roff - 3);
4303 val = bfd_get_8 (input_bfd, contents + roff - 1);
4304 bfd_put_8 (output_bfd, 0x48 | ((type >> 2) & 1),
4305 contents + roff - 3);
4306 bfd_put_8 (output_bfd, 0xc7, contents + roff - 2);
4307 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4308 contents + roff - 1);
4309 bfd_put_32 (output_bfd,
4310 elf_x86_64_tpoff (info, relocation),
4314 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
4316 /* GDesc -> LE transition.
4321 bfd_put_8 (output_bfd, 0x66, contents + roff);
4322 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4325 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTTPOFF)
4327 /* IE->LE transition:
4328 For 64bit, originally it can be one of:
4329 movq foo@gottpoff(%rip), %reg
4330 addq foo@gottpoff(%rip), %reg
4333 leaq foo(%reg), %reg
4335 For 32bit, originally it can be one of:
4336 movq foo@gottpoff(%rip), %reg
4337 addl foo@gottpoff(%rip), %reg
4340 leal foo(%reg), %reg
4343 unsigned int val, type, reg;
4346 val = bfd_get_8 (input_bfd, contents + roff - 3);
4349 type = bfd_get_8 (input_bfd, contents + roff - 2);
4350 reg = bfd_get_8 (input_bfd, contents + roff - 1);
4356 bfd_put_8 (output_bfd, 0x49,
4357 contents + roff - 3);
4358 else if (!ABI_64_P (output_bfd) && val == 0x44)
4359 bfd_put_8 (output_bfd, 0x41,
4360 contents + roff - 3);
4361 bfd_put_8 (output_bfd, 0xc7,
4362 contents + roff - 2);
4363 bfd_put_8 (output_bfd, 0xc0 | reg,
4364 contents + roff - 1);
4368 /* addq/addl -> addq/addl - addressing with %rsp/%r12
4371 bfd_put_8 (output_bfd, 0x49,
4372 contents + roff - 3);
4373 else if (!ABI_64_P (output_bfd) && val == 0x44)
4374 bfd_put_8 (output_bfd, 0x41,
4375 contents + roff - 3);
4376 bfd_put_8 (output_bfd, 0x81,
4377 contents + roff - 2);
4378 bfd_put_8 (output_bfd, 0xc0 | reg,
4379 contents + roff - 1);
4383 /* addq/addl -> leaq/leal */
4385 bfd_put_8 (output_bfd, 0x4d,
4386 contents + roff - 3);
4387 else if (!ABI_64_P (output_bfd) && val == 0x44)
4388 bfd_put_8 (output_bfd, 0x45,
4389 contents + roff - 3);
4390 bfd_put_8 (output_bfd, 0x8d,
4391 contents + roff - 2);
4392 bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
4393 contents + roff - 1);
4395 bfd_put_32 (output_bfd,
4396 elf_x86_64_tpoff (info, relocation),
4404 if (htab->elf.sgot == NULL)
4409 off = h->got.offset;
4410 offplt = elf_x86_64_hash_entry (h)->tlsdesc_got;
4414 if (local_got_offsets == NULL)
4417 off = local_got_offsets[r_symndx];
4418 offplt = local_tlsdesc_gotents[r_symndx];
4425 Elf_Internal_Rela outrel;
4429 if (htab->elf.srelgot == NULL)
4432 indx = h && h->dynindx != -1 ? h->dynindx : 0;
4434 if (GOT_TLS_GDESC_P (tls_type))
4436 outrel.r_info = htab->r_info (indx, R_X86_64_TLSDESC);
4437 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt
4438 + 2 * GOT_ENTRY_SIZE <= htab->elf.sgotplt->size);
4439 outrel.r_offset = (htab->elf.sgotplt->output_section->vma
4440 + htab->elf.sgotplt->output_offset
4442 + htab->sgotplt_jump_table_size);
4443 sreloc = htab->elf.srelplt;
4445 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
4447 outrel.r_addend = 0;
4448 elf_append_rela (output_bfd, sreloc, &outrel);
4451 sreloc = htab->elf.srelgot;
4453 outrel.r_offset = (htab->elf.sgot->output_section->vma
4454 + htab->elf.sgot->output_offset + off);
4456 if (GOT_TLS_GD_P (tls_type))
4457 dr_type = R_X86_64_DTPMOD64;
4458 else if (GOT_TLS_GDESC_P (tls_type))
4461 dr_type = R_X86_64_TPOFF64;
4463 bfd_put_64 (output_bfd, 0, htab->elf.sgot->contents + off);
4464 outrel.r_addend = 0;
4465 if ((dr_type == R_X86_64_TPOFF64
4466 || dr_type == R_X86_64_TLSDESC) && indx == 0)
4467 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
4468 outrel.r_info = htab->r_info (indx, dr_type);
4470 elf_append_rela (output_bfd, sreloc, &outrel);
4472 if (GOT_TLS_GD_P (tls_type))
4476 BFD_ASSERT (! unresolved_reloc);
4477 bfd_put_64 (output_bfd,
4478 relocation - elf_x86_64_dtpoff_base (info),
4479 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4483 bfd_put_64 (output_bfd, 0,
4484 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4485 outrel.r_info = htab->r_info (indx,
4487 outrel.r_offset += GOT_ENTRY_SIZE;
4488 elf_append_rela (output_bfd, sreloc,
4497 local_got_offsets[r_symndx] |= 1;
4500 if (off >= (bfd_vma) -2
4501 && ! GOT_TLS_GDESC_P (tls_type))
4503 if (r_type == ELF32_R_TYPE (rel->r_info))
4505 if (r_type == R_X86_64_GOTPC32_TLSDESC
4506 || r_type == R_X86_64_TLSDESC_CALL)
4507 relocation = htab->elf.sgotplt->output_section->vma
4508 + htab->elf.sgotplt->output_offset
4509 + offplt + htab->sgotplt_jump_table_size;
4511 relocation = htab->elf.sgot->output_section->vma
4512 + htab->elf.sgot->output_offset + off;
4513 unresolved_reloc = FALSE;
4517 bfd_vma roff = rel->r_offset;
4519 if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
4521 /* GD->IE transition. For 64bit, change
4522 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4523 .word 0x6666; rex64; call __tls_get_addr@plt
4526 addq foo@gottpoff(%rip), %rax
4528 leaq foo@tlsgd(%rip), %rdi
4529 .word 0x6666; rex64; call __tls_get_addr@plt
4532 addq foo@gottpoff(%rip), %rax
4533 For largepic, change:
4534 leaq foo@tlsgd(%rip), %rdi
4535 movabsq $__tls_get_addr@pltoff, %rax
4540 addq foo@gottpoff(%rax), %rax
4541 nopw 0x0(%rax,%rax,1) */
4543 if (ABI_64_P (output_bfd)
4544 && contents[roff + 5] == (bfd_byte) '\xb8')
4546 memcpy (contents + roff - 3,
4547 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
4548 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4551 else if (ABI_64_P (output_bfd))
4552 memcpy (contents + roff - 4,
4553 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4556 memcpy (contents + roff - 3,
4557 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4560 relocation = (htab->elf.sgot->output_section->vma
4561 + htab->elf.sgot->output_offset + off
4564 - input_section->output_section->vma
4565 - input_section->output_offset
4567 bfd_put_32 (output_bfd, relocation,
4568 contents + roff + 8 + largepic);
4569 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4573 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
4575 /* GDesc -> IE transition.
4576 It's originally something like:
4577 leaq x@tlsdesc(%rip), %rax
4580 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
4582 /* Now modify the instruction as appropriate. To
4583 turn a leaq into a movq in the form we use it, it
4584 suffices to change the second byte from 0x8d to
4586 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4588 bfd_put_32 (output_bfd,
4589 htab->elf.sgot->output_section->vma
4590 + htab->elf.sgot->output_offset + off
4592 - input_section->output_section->vma
4593 - input_section->output_offset
4598 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
4600 /* GDesc -> IE transition.
4607 bfd_put_8 (output_bfd, 0x66, contents + roff);
4608 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4616 case R_X86_64_TLSLD:
4617 if (! elf_x86_64_tls_transition (info, input_bfd,
4618 input_section, contents,
4619 symtab_hdr, sym_hashes,
4620 &r_type, GOT_UNKNOWN,
4621 rel, relend, h, r_symndx))
4624 if (r_type != R_X86_64_TLSLD)
4626 /* LD->LE transition:
4627 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
4628 For 64bit, we change it into:
4629 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
4630 For 32bit, we change it into:
4631 nopl 0x0(%rax); movl %fs:0, %eax.
4632 For largepic, change:
4633 leaq foo@tlsgd(%rip), %rdi
4634 movabsq $__tls_get_addr@pltoff, %rax
4638 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
4641 BFD_ASSERT (r_type == R_X86_64_TPOFF32);
4642 if (ABI_64_P (output_bfd)
4643 && contents[rel->r_offset + 5] == (bfd_byte) '\xb8')
4644 memcpy (contents + rel->r_offset - 3,
4645 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
4646 "\x64\x48\x8b\x04\x25\0\0\0", 22);
4647 else if (ABI_64_P (output_bfd))
4648 memcpy (contents + rel->r_offset - 3,
4649 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
4651 memcpy (contents + rel->r_offset - 3,
4652 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
4653 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4658 if (htab->elf.sgot == NULL)
4661 off = htab->tls_ld_got.offset;
4666 Elf_Internal_Rela outrel;
4668 if (htab->elf.srelgot == NULL)
4671 outrel.r_offset = (htab->elf.sgot->output_section->vma
4672 + htab->elf.sgot->output_offset + off);
4674 bfd_put_64 (output_bfd, 0,
4675 htab->elf.sgot->contents + off);
4676 bfd_put_64 (output_bfd, 0,
4677 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4678 outrel.r_info = htab->r_info (0, R_X86_64_DTPMOD64);
4679 outrel.r_addend = 0;
4680 elf_append_rela (output_bfd, htab->elf.srelgot,
4682 htab->tls_ld_got.offset |= 1;
4684 relocation = htab->elf.sgot->output_section->vma
4685 + htab->elf.sgot->output_offset + off;
4686 unresolved_reloc = FALSE;
4689 case R_X86_64_DTPOFF32:
4690 if (!info->executable|| (input_section->flags & SEC_CODE) == 0)
4691 relocation -= elf_x86_64_dtpoff_base (info);
4693 relocation = elf_x86_64_tpoff (info, relocation);
4696 case R_X86_64_TPOFF32:
4697 case R_X86_64_TPOFF64:
4698 BFD_ASSERT (info->executable);
4699 relocation = elf_x86_64_tpoff (info, relocation);
4702 case R_X86_64_DTPOFF64:
4703 BFD_ASSERT ((input_section->flags & SEC_CODE) == 0);
4704 relocation -= elf_x86_64_dtpoff_base (info);
4711 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4712 because such sections are not SEC_ALLOC and thus ld.so will
4713 not process them. */
4714 if (unresolved_reloc
4715 && !((input_section->flags & SEC_DEBUGGING) != 0
4717 && _bfd_elf_section_offset (output_bfd, info, input_section,
4718 rel->r_offset) != (bfd_vma) -1)
4720 (*_bfd_error_handler)
4721 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4724 (long) rel->r_offset,
4726 h->root.root.string);
4731 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4732 contents, rel->r_offset,
4733 relocation, rel->r_addend);
4735 check_relocation_error:
4736 if (r != bfd_reloc_ok)
4741 name = h->root.root.string;
4744 name = bfd_elf_string_from_elf_section (input_bfd,
4745 symtab_hdr->sh_link,
4750 name = bfd_section_name (input_bfd, sec);
4753 if (r == bfd_reloc_overflow)
4755 if (! ((*info->callbacks->reloc_overflow)
4756 (info, (h ? &h->root : NULL), name, howto->name,
4757 (bfd_vma) 0, input_bfd, input_section,
4763 (*_bfd_error_handler)
4764 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4765 input_bfd, input_section,
4766 (long) rel->r_offset, name, (int) r);
4775 /* Finish up dynamic symbol handling. We set the contents of various
4776 dynamic sections here. */
4779 elf_x86_64_finish_dynamic_symbol (bfd *output_bfd,
4780 struct bfd_link_info *info,
4781 struct elf_link_hash_entry *h,
4782 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
4784 struct elf_x86_64_link_hash_table *htab;
4785 const struct elf_x86_64_backend_data *abed;
4786 bfd_boolean use_plt_bnd;
4788 htab = elf_x86_64_hash_table (info);
4792 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
4793 section only if there is .plt section. */
4794 use_plt_bnd = htab->elf.splt != NULL && htab->plt_bnd != NULL;
4796 ? &elf_x86_64_bnd_arch_bed
4797 : get_elf_x86_64_backend_data (output_bfd));
4799 if (h->plt.offset != (bfd_vma) -1)
4802 bfd_vma got_offset, plt_offset, plt_plt_offset, plt_got_offset;
4803 bfd_vma plt_plt_insn_end, plt_got_insn_size;
4804 Elf_Internal_Rela rela;
4806 asection *plt, *gotplt, *relplt, *resolved_plt;
4807 const struct elf_backend_data *bed;
4809 /* When building a static executable, use .iplt, .igot.plt and
4810 .rela.iplt sections for STT_GNU_IFUNC symbols. */
4811 if (htab->elf.splt != NULL)
4813 plt = htab->elf.splt;
4814 gotplt = htab->elf.sgotplt;
4815 relplt = htab->elf.srelplt;
4819 plt = htab->elf.iplt;
4820 gotplt = htab->elf.igotplt;
4821 relplt = htab->elf.irelplt;
4824 /* This symbol has an entry in the procedure linkage table. Set
4826 if ((h->dynindx == -1
4827 && !((h->forced_local || info->executable)
4829 && h->type == STT_GNU_IFUNC))
4835 /* Get the index in the procedure linkage table which
4836 corresponds to this symbol. This is the index of this symbol
4837 in all the symbols for which we are making plt entries. The
4838 first entry in the procedure linkage table is reserved.
4840 Get the offset into the .got table of the entry that
4841 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
4842 bytes. The first three are reserved for the dynamic linker.
4844 For static executables, we don't reserve anything. */
4846 if (plt == htab->elf.splt)
4848 got_offset = h->plt.offset / abed->plt_entry_size - 1;
4849 got_offset = (got_offset + 3) * GOT_ENTRY_SIZE;
4853 got_offset = h->plt.offset / abed->plt_entry_size;
4854 got_offset = got_offset * GOT_ENTRY_SIZE;
4857 plt_plt_insn_end = abed->plt_plt_insn_end;
4858 plt_plt_offset = abed->plt_plt_offset;
4859 plt_got_insn_size = abed->plt_got_insn_size;
4860 plt_got_offset = abed->plt_got_offset;
4863 /* Use the second PLT with BND relocations. */
4864 const bfd_byte *plt_entry, *plt2_entry;
4865 struct elf_x86_64_link_hash_entry *eh
4866 = (struct elf_x86_64_link_hash_entry *) h;
4868 if (eh->has_bnd_reloc)
4870 plt_entry = elf_x86_64_bnd_plt_entry;
4871 plt2_entry = elf_x86_64_bnd_plt2_entry;
4875 plt_entry = elf_x86_64_legacy_plt_entry;
4876 plt2_entry = elf_x86_64_legacy_plt2_entry;
4878 /* Subtract 1 since there is no BND prefix. */
4879 plt_plt_insn_end -= 1;
4880 plt_plt_offset -= 1;
4881 plt_got_insn_size -= 1;
4882 plt_got_offset -= 1;
4885 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry)
4886 == sizeof (elf_x86_64_legacy_plt_entry));
4888 /* Fill in the entry in the procedure linkage table. */
4889 memcpy (plt->contents + h->plt.offset,
4890 plt_entry, sizeof (elf_x86_64_legacy_plt_entry));
4891 /* Fill in the entry in the second PLT. */
4892 memcpy (htab->plt_bnd->contents + eh->plt_bnd.offset,
4893 plt2_entry, sizeof (elf_x86_64_legacy_plt2_entry));
4895 resolved_plt = htab->plt_bnd;
4896 plt_offset = eh->plt_bnd.offset;
4900 /* Fill in the entry in the procedure linkage table. */
4901 memcpy (plt->contents + h->plt.offset, abed->plt_entry,
4902 abed->plt_entry_size);
4905 plt_offset = h->plt.offset;
4908 /* Insert the relocation positions of the plt section. */
4910 /* Put offset the PC-relative instruction referring to the GOT entry,
4911 subtracting the size of that instruction. */
4912 bfd_put_32 (output_bfd,
4913 (gotplt->output_section->vma
4914 + gotplt->output_offset
4916 - resolved_plt->output_section->vma
4917 - resolved_plt->output_offset
4919 - plt_got_insn_size),
4920 resolved_plt->contents + plt_offset + plt_got_offset);
4922 /* Fill in the entry in the global offset table, initially this
4923 points to the second part of the PLT entry. */
4924 bfd_put_64 (output_bfd, (plt->output_section->vma
4925 + plt->output_offset
4926 + h->plt.offset + abed->plt_lazy_offset),
4927 gotplt->contents + got_offset);
4929 /* Fill in the entry in the .rela.plt section. */
4930 rela.r_offset = (gotplt->output_section->vma
4931 + gotplt->output_offset
4933 if (h->dynindx == -1
4934 || ((info->executable
4935 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4937 && h->type == STT_GNU_IFUNC))
4939 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4940 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
4941 rela.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
4942 rela.r_addend = (h->root.u.def.value
4943 + h->root.u.def.section->output_section->vma
4944 + h->root.u.def.section->output_offset);
4945 /* R_X86_64_IRELATIVE comes last. */
4946 plt_index = htab->next_irelative_index--;
4950 rela.r_info = htab->r_info (h->dynindx, R_X86_64_JUMP_SLOT);
4952 plt_index = htab->next_jump_slot_index++;
4955 /* Don't fill PLT entry for static executables. */
4956 if (plt == htab->elf.splt)
4958 /* Put relocation index. */
4959 bfd_put_32 (output_bfd, plt_index,
4960 plt->contents + h->plt.offset + abed->plt_reloc_offset);
4961 /* Put offset for jmp .PLT0. */
4962 bfd_put_32 (output_bfd, - (h->plt.offset + plt_plt_insn_end),
4963 plt->contents + h->plt.offset + plt_plt_offset);
4966 bed = get_elf_backend_data (output_bfd);
4967 loc = relplt->contents + plt_index * bed->s->sizeof_rela;
4968 bed->s->swap_reloca_out (output_bfd, &rela, loc);
4970 if (!h->def_regular)
4972 /* Mark the symbol as undefined, rather than as defined in
4973 the .plt section. Leave the value if there were any
4974 relocations where pointer equality matters (this is a clue
4975 for the dynamic linker, to make function pointer
4976 comparisons work between an application and shared
4977 library), otherwise set it to zero. If a function is only
4978 called from a binary, there is no need to slow down
4979 shared libraries because of that. */
4980 sym->st_shndx = SHN_UNDEF;
4981 if (!h->pointer_equality_needed)
4986 if (h->got.offset != (bfd_vma) -1
4987 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h)->tls_type)
4988 && elf_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE)
4990 Elf_Internal_Rela rela;
4992 /* This symbol has an entry in the global offset table. Set it
4994 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
4997 rela.r_offset = (htab->elf.sgot->output_section->vma
4998 + htab->elf.sgot->output_offset
4999 + (h->got.offset &~ (bfd_vma) 1));
5001 /* If this is a static link, or it is a -Bsymbolic link and the
5002 symbol is defined locally or was forced to be local because
5003 of a version file, we just want to emit a RELATIVE reloc.
5004 The entry in the global offset table will already have been
5005 initialized in the relocate_section function. */
5007 && h->type == STT_GNU_IFUNC)
5011 /* Generate R_X86_64_GLOB_DAT. */
5018 if (!h->pointer_equality_needed)
5021 /* For non-shared object, we can't use .got.plt, which
5022 contains the real function addres if we need pointer
5023 equality. We load the GOT entry with the PLT entry. */
5024 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
5025 bfd_put_64 (output_bfd, (plt->output_section->vma
5026 + plt->output_offset
5028 htab->elf.sgot->contents + h->got.offset);
5032 else if (info->shared
5033 && SYMBOL_REFERENCES_LOCAL (info, h))
5035 if (!h->def_regular)
5037 BFD_ASSERT((h->got.offset & 1) != 0);
5038 rela.r_info = htab->r_info (0, R_X86_64_RELATIVE);
5039 rela.r_addend = (h->root.u.def.value
5040 + h->root.u.def.section->output_section->vma
5041 + h->root.u.def.section->output_offset);
5045 BFD_ASSERT((h->got.offset & 1) == 0);
5047 bfd_put_64 (output_bfd, (bfd_vma) 0,
5048 htab->elf.sgot->contents + h->got.offset);
5049 rela.r_info = htab->r_info (h->dynindx, R_X86_64_GLOB_DAT);
5053 elf_append_rela (output_bfd, htab->elf.srelgot, &rela);
5058 Elf_Internal_Rela rela;
5060 /* This symbol needs a copy reloc. Set it up. */
5062 if (h->dynindx == -1
5063 || (h->root.type != bfd_link_hash_defined
5064 && h->root.type != bfd_link_hash_defweak)
5065 || htab->srelbss == NULL)
5068 rela.r_offset = (h->root.u.def.value
5069 + h->root.u.def.section->output_section->vma
5070 + h->root.u.def.section->output_offset);
5071 rela.r_info = htab->r_info (h->dynindx, R_X86_64_COPY);
5073 elf_append_rela (output_bfd, htab->srelbss, &rela);
5079 /* Finish up local dynamic symbol handling. We set the contents of
5080 various dynamic sections here. */
5083 elf_x86_64_finish_local_dynamic_symbol (void **slot, void *inf)
5085 struct elf_link_hash_entry *h
5086 = (struct elf_link_hash_entry *) *slot;
5087 struct bfd_link_info *info
5088 = (struct bfd_link_info *) inf;
5090 return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
5094 /* Used to decide how to sort relocs in an optimal manner for the
5095 dynamic linker, before writing them out. */
5097 static enum elf_reloc_type_class
5098 elf_x86_64_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
5099 const asection *rel_sec ATTRIBUTE_UNUSED,
5100 const Elf_Internal_Rela *rela)
5102 switch ((int) ELF32_R_TYPE (rela->r_info))
5104 case R_X86_64_RELATIVE:
5105 case R_X86_64_RELATIVE64:
5106 return reloc_class_relative;
5107 case R_X86_64_JUMP_SLOT:
5108 return reloc_class_plt;
5110 return reloc_class_copy;
5112 return reloc_class_normal;
5116 /* Finish up the dynamic sections. */
5119 elf_x86_64_finish_dynamic_sections (bfd *output_bfd,
5120 struct bfd_link_info *info)
5122 struct elf_x86_64_link_hash_table *htab;
5125 const struct elf_x86_64_backend_data *abed;
5127 htab = elf_x86_64_hash_table (info);
5131 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5132 section only if there is .plt section. */
5133 abed = (htab->elf.splt != NULL && htab->plt_bnd != NULL
5134 ? &elf_x86_64_bnd_arch_bed
5135 : get_elf_x86_64_backend_data (output_bfd));
5137 dynobj = htab->elf.dynobj;
5138 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
5140 if (htab->elf.dynamic_sections_created)
5142 bfd_byte *dyncon, *dynconend;
5143 const struct elf_backend_data *bed;
5144 bfd_size_type sizeof_dyn;
5146 if (sdyn == NULL || htab->elf.sgot == NULL)
5149 bed = get_elf_backend_data (dynobj);
5150 sizeof_dyn = bed->s->sizeof_dyn;
5151 dyncon = sdyn->contents;
5152 dynconend = sdyn->contents + sdyn->size;
5153 for (; dyncon < dynconend; dyncon += sizeof_dyn)
5155 Elf_Internal_Dyn dyn;
5158 (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
5166 s = htab->elf.sgotplt;
5167 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5171 dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
5175 s = htab->elf.srelplt->output_section;
5176 dyn.d_un.d_val = s->size;
5180 /* The procedure linkage table relocs (DT_JMPREL) should
5181 not be included in the overall relocs (DT_RELA).
5182 Therefore, we override the DT_RELASZ entry here to
5183 make it not include the JMPREL relocs. Since the
5184 linker script arranges for .rela.plt to follow all
5185 other relocation sections, we don't have to worry
5186 about changing the DT_RELA entry. */
5187 if (htab->elf.srelplt != NULL)
5189 s = htab->elf.srelplt->output_section;
5190 dyn.d_un.d_val -= s->size;
5194 case DT_TLSDESC_PLT:
5196 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
5197 + htab->tlsdesc_plt;
5200 case DT_TLSDESC_GOT:
5202 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
5203 + htab->tlsdesc_got;
5207 (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
5210 /* Fill in the special first entry in the procedure linkage table. */
5211 if (htab->elf.splt && htab->elf.splt->size > 0)
5213 /* Fill in the first entry in the procedure linkage table. */
5214 memcpy (htab->elf.splt->contents,
5215 abed->plt0_entry, abed->plt_entry_size);
5216 /* Add offset for pushq GOT+8(%rip), since the instruction
5217 uses 6 bytes subtract this value. */
5218 bfd_put_32 (output_bfd,
5219 (htab->elf.sgotplt->output_section->vma
5220 + htab->elf.sgotplt->output_offset
5222 - htab->elf.splt->output_section->vma
5223 - htab->elf.splt->output_offset
5225 htab->elf.splt->contents + abed->plt0_got1_offset);
5226 /* Add offset for the PC-relative instruction accessing GOT+16,
5227 subtracting the offset to the end of that instruction. */
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
5234 - abed->plt0_got2_insn_end),
5235 htab->elf.splt->contents + abed->plt0_got2_offset);
5237 elf_section_data (htab->elf.splt->output_section)
5238 ->this_hdr.sh_entsize = abed->plt_entry_size;
5240 if (htab->tlsdesc_plt)
5242 bfd_put_64 (output_bfd, (bfd_vma) 0,
5243 htab->elf.sgot->contents + htab->tlsdesc_got);
5245 memcpy (htab->elf.splt->contents + htab->tlsdesc_plt,
5246 abed->plt0_entry, abed->plt_entry_size);
5248 /* Add offset for pushq GOT+8(%rip), since the
5249 instruction uses 6 bytes subtract this value. */
5250 bfd_put_32 (output_bfd,
5251 (htab->elf.sgotplt->output_section->vma
5252 + htab->elf.sgotplt->output_offset
5254 - htab->elf.splt->output_section->vma
5255 - htab->elf.splt->output_offset
5258 htab->elf.splt->contents
5259 + htab->tlsdesc_plt + abed->plt0_got1_offset);
5260 /* Add offset for the PC-relative instruction accessing GOT+TDG,
5261 where TGD stands for htab->tlsdesc_got, subtracting the offset
5262 to the end of that instruction. */
5263 bfd_put_32 (output_bfd,
5264 (htab->elf.sgot->output_section->vma
5265 + htab->elf.sgot->output_offset
5267 - htab->elf.splt->output_section->vma
5268 - htab->elf.splt->output_offset
5270 - abed->plt0_got2_insn_end),
5271 htab->elf.splt->contents
5272 + htab->tlsdesc_plt + abed->plt0_got2_offset);
5277 if (htab->plt_bnd != NULL)
5278 elf_section_data (htab->plt_bnd->output_section)
5279 ->this_hdr.sh_entsize = sizeof (elf_x86_64_bnd_plt2_entry);
5281 if (htab->elf.sgotplt)
5283 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
5285 (*_bfd_error_handler)
5286 (_("discarded output section: `%A'"), htab->elf.sgotplt);
5290 /* Fill in the first three entries in the global offset table. */
5291 if (htab->elf.sgotplt->size > 0)
5293 /* Set the first entry in the global offset table to the address of
5294 the dynamic section. */
5296 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents);
5298 bfd_put_64 (output_bfd,
5299 sdyn->output_section->vma + sdyn->output_offset,
5300 htab->elf.sgotplt->contents);
5301 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
5302 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
5303 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE*2);
5306 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize =
5310 /* Adjust .eh_frame for .plt section. */
5311 if (htab->plt_eh_frame != NULL
5312 && htab->plt_eh_frame->contents != NULL)
5314 if (htab->elf.splt != NULL
5315 && htab->elf.splt->size != 0
5316 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
5317 && htab->elf.splt->output_section != NULL
5318 && htab->plt_eh_frame->output_section != NULL)
5320 bfd_vma plt_start = htab->elf.splt->output_section->vma;
5321 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
5322 + htab->plt_eh_frame->output_offset
5323 + PLT_FDE_START_OFFSET;
5324 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
5325 htab->plt_eh_frame->contents
5326 + PLT_FDE_START_OFFSET);
5328 if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
5330 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
5332 htab->plt_eh_frame->contents))
5337 if (htab->elf.sgot && htab->elf.sgot->size > 0)
5338 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
5341 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5342 htab_traverse (htab->loc_hash_table,
5343 elf_x86_64_finish_local_dynamic_symbol,
5349 /* Return an array of PLT entry symbol values. */
5352 elf_x86_64_get_plt_sym_val (bfd *abfd, asymbol **dynsyms, asection *plt,
5355 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
5358 bfd_vma *plt_sym_val;
5360 bfd_byte *plt_contents;
5361 const struct elf_x86_64_backend_data *bed;
5362 Elf_Internal_Shdr *hdr;
5365 /* Get the .plt section contents. PLT passed down may point to the
5366 .plt.bnd section. Make sure that PLT always points to the .plt
5368 plt_bnd = bfd_get_section_by_name (abfd, ".plt.bnd");
5373 plt = bfd_get_section_by_name (abfd, ".plt");
5376 bed = &elf_x86_64_bnd_arch_bed;
5379 bed = get_elf_x86_64_backend_data (abfd);
5381 plt_contents = (bfd_byte *) bfd_malloc (plt->size);
5382 if (plt_contents == NULL)
5384 if (!bfd_get_section_contents (abfd, (asection *) plt,
5385 plt_contents, 0, plt->size))
5388 free (plt_contents);
5392 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
5393 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
5396 hdr = &elf_section_data (relplt)->this_hdr;
5397 count = relplt->size / hdr->sh_entsize;
5399 plt_sym_val = (bfd_vma *) bfd_malloc (sizeof (bfd_vma) * count);
5400 if (plt_sym_val == NULL)
5403 for (i = 0; i < count; i++, p++)
5404 plt_sym_val[i] = -1;
5406 plt_offset = bed->plt_entry_size;
5407 p = relplt->relocation;
5408 for (i = 0; i < count; i++, p++)
5412 if (p->howto->type != R_X86_64_JUMP_SLOT
5413 && p->howto->type != R_X86_64_IRELATIVE)
5416 reloc_index = H_GET_32 (abfd, (plt_contents + plt_offset
5417 + bed->plt_reloc_offset));
5418 if (reloc_index >= count)
5422 /* This is the index in .plt section. */
5423 long plt_index = plt_offset / bed->plt_entry_size;
5424 /* Store VMA + the offset in .plt.bnd section. */
5425 plt_sym_val[reloc_index] =
5427 + (plt_index - 1) * sizeof (elf_x86_64_legacy_plt2_entry));
5430 plt_sym_val[reloc_index] = plt->vma + plt_offset;
5431 plt_offset += bed->plt_entry_size;
5434 free (plt_contents);
5439 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
5443 elf_x86_64_get_synthetic_symtab (bfd *abfd,
5450 /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
5451 as PLT if it exists. */
5452 asection *plt = bfd_get_section_by_name (abfd, ".plt.bnd");
5454 plt = bfd_get_section_by_name (abfd, ".plt");
5455 return _bfd_elf_ifunc_get_synthetic_symtab (abfd, symcount, syms,
5456 dynsymcount, dynsyms, ret,
5458 elf_x86_64_get_plt_sym_val);
5461 /* Handle an x86-64 specific section when reading an object file. This
5462 is called when elfcode.h finds a section with an unknown type. */
5465 elf_x86_64_section_from_shdr (bfd *abfd, Elf_Internal_Shdr *hdr,
5466 const char *name, int shindex)
5468 if (hdr->sh_type != SHT_X86_64_UNWIND)
5471 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
5477 /* Hook called by the linker routine which adds symbols from an object
5478 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
5482 elf_x86_64_add_symbol_hook (bfd *abfd,
5483 struct bfd_link_info *info,
5484 Elf_Internal_Sym *sym,
5485 const char **namep ATTRIBUTE_UNUSED,
5486 flagword *flagsp ATTRIBUTE_UNUSED,
5492 switch (sym->st_shndx)
5494 case SHN_X86_64_LCOMMON:
5495 lcomm = bfd_get_section_by_name (abfd, "LARGE_COMMON");
5498 lcomm = bfd_make_section_with_flags (abfd,
5502 | SEC_LINKER_CREATED));
5505 elf_section_flags (lcomm) |= SHF_X86_64_LARGE;
5508 *valp = sym->st_size;
5512 if ((ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
5513 || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE)
5514 && (abfd->flags & DYNAMIC) == 0
5515 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
5516 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
5522 /* Given a BFD section, try to locate the corresponding ELF section
5526 elf_x86_64_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
5527 asection *sec, int *index_return)
5529 if (sec == &_bfd_elf_large_com_section)
5531 *index_return = SHN_X86_64_LCOMMON;
5537 /* Process a symbol. */
5540 elf_x86_64_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
5543 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
5545 switch (elfsym->internal_elf_sym.st_shndx)
5547 case SHN_X86_64_LCOMMON:
5548 asym->section = &_bfd_elf_large_com_section;
5549 asym->value = elfsym->internal_elf_sym.st_size;
5550 /* Common symbol doesn't set BSF_GLOBAL. */
5551 asym->flags &= ~BSF_GLOBAL;
5557 elf_x86_64_common_definition (Elf_Internal_Sym *sym)
5559 return (sym->st_shndx == SHN_COMMON
5560 || sym->st_shndx == SHN_X86_64_LCOMMON);
5564 elf_x86_64_common_section_index (asection *sec)
5566 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
5569 return SHN_X86_64_LCOMMON;
5573 elf_x86_64_common_section (asection *sec)
5575 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
5576 return bfd_com_section_ptr;
5578 return &_bfd_elf_large_com_section;
5582 elf_x86_64_merge_symbol (struct elf_link_hash_entry *h,
5583 const Elf_Internal_Sym *sym,
5588 const asection *oldsec)
5590 /* A normal common symbol and a large common symbol result in a
5591 normal common symbol. We turn the large common symbol into a
5594 && h->root.type == bfd_link_hash_common
5596 && bfd_is_com_section (*psec)
5599 if (sym->st_shndx == SHN_COMMON
5600 && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) != 0)
5602 h->root.u.c.p->section
5603 = bfd_make_section_old_way (oldbfd, "COMMON");
5604 h->root.u.c.p->section->flags = SEC_ALLOC;
5606 else if (sym->st_shndx == SHN_X86_64_LCOMMON
5607 && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) == 0)
5608 *psec = bfd_com_section_ptr;
5615 elf_x86_64_additional_program_headers (bfd *abfd,
5616 struct bfd_link_info *info ATTRIBUTE_UNUSED)
5621 /* Check to see if we need a large readonly segment. */
5622 s = bfd_get_section_by_name (abfd, ".lrodata");
5623 if (s && (s->flags & SEC_LOAD))
5626 /* Check to see if we need a large data segment. Since .lbss sections
5627 is placed right after the .bss section, there should be no need for
5628 a large data segment just because of .lbss. */
5629 s = bfd_get_section_by_name (abfd, ".ldata");
5630 if (s && (s->flags & SEC_LOAD))
5636 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5639 elf_x86_64_hash_symbol (struct elf_link_hash_entry *h)
5641 if (h->plt.offset != (bfd_vma) -1
5643 && !h->pointer_equality_needed)
5646 return _bfd_elf_hash_symbol (h);
5649 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
5652 elf_x86_64_relocs_compatible (const bfd_target *input,
5653 const bfd_target *output)
5655 return ((xvec_get_elf_backend_data (input)->s->elfclass
5656 == xvec_get_elf_backend_data (output)->s->elfclass)
5657 && _bfd_elf_relocs_compatible (input, output));
5660 static const struct bfd_elf_special_section
5661 elf_x86_64_special_sections[]=
5663 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5664 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
5665 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR + SHF_X86_64_LARGE},
5666 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5667 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5668 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
5669 { NULL, 0, 0, 0, 0 }
5672 #define TARGET_LITTLE_SYM x86_64_elf64_vec
5673 #define TARGET_LITTLE_NAME "elf64-x86-64"
5674 #define ELF_ARCH bfd_arch_i386
5675 #define ELF_TARGET_ID X86_64_ELF_DATA
5676 #define ELF_MACHINE_CODE EM_X86_64
5677 #define ELF_MAXPAGESIZE 0x200000
5678 #define ELF_MINPAGESIZE 0x1000
5679 #define ELF_COMMONPAGESIZE 0x1000
5681 #define elf_backend_can_gc_sections 1
5682 #define elf_backend_can_refcount 1
5683 #define elf_backend_want_got_plt 1
5684 #define elf_backend_plt_readonly 1
5685 #define elf_backend_want_plt_sym 0
5686 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
5687 #define elf_backend_rela_normal 1
5688 #define elf_backend_plt_alignment 4
5690 #define elf_info_to_howto elf_x86_64_info_to_howto
5692 #define bfd_elf64_bfd_link_hash_table_create \
5693 elf_x86_64_link_hash_table_create
5694 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
5695 #define bfd_elf64_bfd_reloc_name_lookup \
5696 elf_x86_64_reloc_name_lookup
5698 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
5699 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
5700 #define elf_backend_check_relocs elf_x86_64_check_relocs
5701 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
5702 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
5703 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
5704 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
5705 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
5706 #define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
5707 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
5708 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
5710 #define elf_backend_write_core_note elf_x86_64_write_core_note
5712 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
5713 #define elf_backend_relocate_section elf_x86_64_relocate_section
5714 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
5715 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
5716 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
5717 #define elf_backend_object_p elf64_x86_64_elf_object_p
5718 #define bfd_elf64_mkobject elf_x86_64_mkobject
5719 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
5721 #define elf_backend_section_from_shdr \
5722 elf_x86_64_section_from_shdr
5724 #define elf_backend_section_from_bfd_section \
5725 elf_x86_64_elf_section_from_bfd_section
5726 #define elf_backend_add_symbol_hook \
5727 elf_x86_64_add_symbol_hook
5728 #define elf_backend_symbol_processing \
5729 elf_x86_64_symbol_processing
5730 #define elf_backend_common_section_index \
5731 elf_x86_64_common_section_index
5732 #define elf_backend_common_section \
5733 elf_x86_64_common_section
5734 #define elf_backend_common_definition \
5735 elf_x86_64_common_definition
5736 #define elf_backend_merge_symbol \
5737 elf_x86_64_merge_symbol
5738 #define elf_backend_special_sections \
5739 elf_x86_64_special_sections
5740 #define elf_backend_additional_program_headers \
5741 elf_x86_64_additional_program_headers
5742 #define elf_backend_hash_symbol \
5743 elf_x86_64_hash_symbol
5745 #include "elf64-target.h"
5747 /* FreeBSD support. */
5749 #undef TARGET_LITTLE_SYM
5750 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
5751 #undef TARGET_LITTLE_NAME
5752 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
5755 #define ELF_OSABI ELFOSABI_FREEBSD
5758 #define elf64_bed elf64_x86_64_fbsd_bed
5760 #include "elf64-target.h"
5762 /* Solaris 2 support. */
5764 #undef TARGET_LITTLE_SYM
5765 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
5766 #undef TARGET_LITTLE_NAME
5767 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
5769 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5770 objects won't be recognized. */
5774 #define elf64_bed elf64_x86_64_sol2_bed
5776 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
5778 #undef elf_backend_static_tls_alignment
5779 #define elf_backend_static_tls_alignment 16
5781 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5783 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5785 #undef elf_backend_want_plt_sym
5786 #define elf_backend_want_plt_sym 1
5788 #include "elf64-target.h"
5790 /* Native Client support. */
5793 elf64_x86_64_nacl_elf_object_p (bfd *abfd)
5795 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
5796 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64_nacl);
5800 #undef TARGET_LITTLE_SYM
5801 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
5802 #undef TARGET_LITTLE_NAME
5803 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
5805 #define elf64_bed elf64_x86_64_nacl_bed
5807 #undef ELF_MAXPAGESIZE
5808 #undef ELF_MINPAGESIZE
5809 #undef ELF_COMMONPAGESIZE
5810 #define ELF_MAXPAGESIZE 0x10000
5811 #define ELF_MINPAGESIZE 0x10000
5812 #define ELF_COMMONPAGESIZE 0x10000
5814 /* Restore defaults. */
5816 #undef elf_backend_static_tls_alignment
5817 #undef elf_backend_want_plt_sym
5818 #define elf_backend_want_plt_sym 0
5820 /* NaCl uses substantially different PLT entries for the same effects. */
5822 #undef elf_backend_plt_alignment
5823 #define elf_backend_plt_alignment 5
5824 #define NACL_PLT_ENTRY_SIZE 64
5825 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
5827 static const bfd_byte elf_x86_64_nacl_plt0_entry[NACL_PLT_ENTRY_SIZE] =
5829 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
5830 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
5831 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */
5832 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5833 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5835 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
5836 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
5838 /* 32 bytes of nop to pad out to the standard size. */
5839 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5840 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5841 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5842 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5843 0x66, /* excess data32 prefix */
5847 static const bfd_byte elf_x86_64_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
5849 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
5850 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */
5851 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5852 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5854 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
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) */
5858 /* Lazy GOT entries point here (32-byte aligned). */
5859 0x68, /* pushq immediate */
5860 0, 0, 0, 0, /* replaced with index into relocation table. */
5861 0xe9, /* jmp relative */
5862 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
5864 /* 22 bytes of nop to pad out to the standard size. */
5865 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5866 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5867 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
5870 /* .eh_frame covering the .plt section. */
5872 static const bfd_byte elf_x86_64_nacl_eh_frame_plt[] =
5874 #if (PLT_CIE_LENGTH != 20 \
5875 || PLT_FDE_LENGTH != 36 \
5876 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
5877 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
5878 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
5880 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
5881 0, 0, 0, 0, /* CIE ID */
5882 1, /* CIE version */
5883 'z', 'R', 0, /* Augmentation string */
5884 1, /* Code alignment factor */
5885 0x78, /* Data alignment factor */
5886 16, /* Return address column */
5887 1, /* Augmentation size */
5888 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
5889 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
5890 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
5891 DW_CFA_nop, DW_CFA_nop,
5893 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
5894 PLT_CIE_LENGTH + 8, 0, 0, 0,/* CIE pointer */
5895 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
5896 0, 0, 0, 0, /* .plt size goes here */
5897 0, /* Augmentation size */
5898 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
5899 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
5900 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
5901 DW_CFA_advance_loc + 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
5902 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
5903 13, /* Block length */
5904 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
5905 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
5906 DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
5907 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
5908 DW_CFA_nop, DW_CFA_nop
5911 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed =
5913 elf_x86_64_nacl_plt0_entry, /* plt0_entry */
5914 elf_x86_64_nacl_plt_entry, /* plt_entry */
5915 NACL_PLT_ENTRY_SIZE, /* plt_entry_size */
5916 2, /* plt0_got1_offset */
5917 9, /* plt0_got2_offset */
5918 13, /* plt0_got2_insn_end */
5919 3, /* plt_got_offset */
5920 33, /* plt_reloc_offset */
5921 38, /* plt_plt_offset */
5922 7, /* plt_got_insn_size */
5923 42, /* plt_plt_insn_end */
5924 32, /* plt_lazy_offset */
5925 elf_x86_64_nacl_eh_frame_plt, /* eh_frame_plt */
5926 sizeof (elf_x86_64_nacl_eh_frame_plt), /* eh_frame_plt_size */
5929 #undef elf_backend_arch_data
5930 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
5932 #undef elf_backend_object_p
5933 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
5934 #undef elf_backend_modify_segment_map
5935 #define elf_backend_modify_segment_map nacl_modify_segment_map
5936 #undef elf_backend_modify_program_headers
5937 #define elf_backend_modify_program_headers nacl_modify_program_headers
5938 #undef elf_backend_final_write_processing
5939 #define elf_backend_final_write_processing nacl_final_write_processing
5941 #include "elf64-target.h"
5943 /* Native Client x32 support. */
5946 elf32_x86_64_nacl_elf_object_p (bfd *abfd)
5948 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
5949 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32_nacl);
5953 #undef TARGET_LITTLE_SYM
5954 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
5955 #undef TARGET_LITTLE_NAME
5956 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
5958 #define elf32_bed elf32_x86_64_nacl_bed
5960 #define bfd_elf32_bfd_link_hash_table_create \
5961 elf_x86_64_link_hash_table_create
5962 #define bfd_elf32_bfd_reloc_type_lookup \
5963 elf_x86_64_reloc_type_lookup
5964 #define bfd_elf32_bfd_reloc_name_lookup \
5965 elf_x86_64_reloc_name_lookup
5966 #define bfd_elf32_mkobject \
5968 #define bfd_elf32_get_synthetic_symtab \
5969 elf_x86_64_get_synthetic_symtab
5971 #undef elf_backend_object_p
5972 #define elf_backend_object_p \
5973 elf32_x86_64_nacl_elf_object_p
5975 #undef elf_backend_bfd_from_remote_memory
5976 #define elf_backend_bfd_from_remote_memory \
5977 _bfd_elf32_bfd_from_remote_memory
5979 #undef elf_backend_size_info
5980 #define elf_backend_size_info \
5981 _bfd_elf32_size_info
5983 #include "elf32-target.h"
5985 /* Restore defaults. */
5986 #undef elf_backend_object_p
5987 #define elf_backend_object_p elf64_x86_64_elf_object_p
5988 #undef elf_backend_bfd_from_remote_memory
5989 #undef elf_backend_size_info
5990 #undef elf_backend_modify_segment_map
5991 #undef elf_backend_modify_program_headers
5992 #undef elf_backend_final_write_processing
5994 /* Intel L1OM support. */
5997 elf64_l1om_elf_object_p (bfd *abfd)
5999 /* Set the right machine number for an L1OM elf64 file. */
6000 bfd_default_set_arch_mach (abfd, bfd_arch_l1om, bfd_mach_l1om);
6004 #undef TARGET_LITTLE_SYM
6005 #define TARGET_LITTLE_SYM l1om_elf64_vec
6006 #undef TARGET_LITTLE_NAME
6007 #define TARGET_LITTLE_NAME "elf64-l1om"
6009 #define ELF_ARCH bfd_arch_l1om
6011 #undef ELF_MACHINE_CODE
6012 #define ELF_MACHINE_CODE EM_L1OM
6017 #define elf64_bed elf64_l1om_bed
6019 #undef elf_backend_object_p
6020 #define elf_backend_object_p elf64_l1om_elf_object_p
6022 /* Restore defaults. */
6023 #undef ELF_MAXPAGESIZE
6024 #undef ELF_MINPAGESIZE
6025 #undef ELF_COMMONPAGESIZE
6026 #define ELF_MAXPAGESIZE 0x200000
6027 #define ELF_MINPAGESIZE 0x1000
6028 #define ELF_COMMONPAGESIZE 0x1000
6029 #undef elf_backend_plt_alignment
6030 #define elf_backend_plt_alignment 4
6031 #undef elf_backend_arch_data
6032 #define elf_backend_arch_data &elf_x86_64_arch_bed
6034 #include "elf64-target.h"
6036 /* FreeBSD L1OM support. */
6038 #undef TARGET_LITTLE_SYM
6039 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
6040 #undef TARGET_LITTLE_NAME
6041 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
6044 #define ELF_OSABI ELFOSABI_FREEBSD
6047 #define elf64_bed elf64_l1om_fbsd_bed
6049 #include "elf64-target.h"
6051 /* Intel K1OM support. */
6054 elf64_k1om_elf_object_p (bfd *abfd)
6056 /* Set the right machine number for an K1OM elf64 file. */
6057 bfd_default_set_arch_mach (abfd, bfd_arch_k1om, bfd_mach_k1om);
6061 #undef TARGET_LITTLE_SYM
6062 #define TARGET_LITTLE_SYM k1om_elf64_vec
6063 #undef TARGET_LITTLE_NAME
6064 #define TARGET_LITTLE_NAME "elf64-k1om"
6066 #define ELF_ARCH bfd_arch_k1om
6068 #undef ELF_MACHINE_CODE
6069 #define ELF_MACHINE_CODE EM_K1OM
6074 #define elf64_bed elf64_k1om_bed
6076 #undef elf_backend_object_p
6077 #define elf_backend_object_p elf64_k1om_elf_object_p
6079 #undef elf_backend_static_tls_alignment
6081 #undef elf_backend_want_plt_sym
6082 #define elf_backend_want_plt_sym 0
6084 #include "elf64-target.h"
6086 /* FreeBSD K1OM support. */
6088 #undef TARGET_LITTLE_SYM
6089 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
6090 #undef TARGET_LITTLE_NAME
6091 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
6094 #define ELF_OSABI ELFOSABI_FREEBSD
6097 #define elf64_bed elf64_k1om_fbsd_bed
6099 #include "elf64-target.h"
6101 /* 32bit x86-64 support. */
6103 #undef TARGET_LITTLE_SYM
6104 #define TARGET_LITTLE_SYM x86_64_elf32_vec
6105 #undef TARGET_LITTLE_NAME
6106 #define TARGET_LITTLE_NAME "elf32-x86-64"
6110 #define ELF_ARCH bfd_arch_i386
6112 #undef ELF_MACHINE_CODE
6113 #define ELF_MACHINE_CODE EM_X86_64
6117 #undef elf_backend_object_p
6118 #define elf_backend_object_p \
6119 elf32_x86_64_elf_object_p
6121 #undef elf_backend_bfd_from_remote_memory
6122 #define elf_backend_bfd_from_remote_memory \
6123 _bfd_elf32_bfd_from_remote_memory
6125 #undef elf_backend_size_info
6126 #define elf_backend_size_info \
6127 _bfd_elf32_size_info
6129 #include "elf32-target.h"