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 symbol has at least one BND relocation. */
761 bfd_boolean has_bnd_reloc;
763 /* Information about the second PLT entry. Filled when has_bnd_reloc is
765 union gotplt_union plt_bnd;
767 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
768 starting at the end of the jump table. */
772 #define elf_x86_64_hash_entry(ent) \
773 ((struct elf_x86_64_link_hash_entry *)(ent))
775 struct elf_x86_64_obj_tdata
777 struct elf_obj_tdata root;
779 /* tls_type for each local got entry. */
780 char *local_got_tls_type;
782 /* GOTPLT entries for TLS descriptors. */
783 bfd_vma *local_tlsdesc_gotent;
786 #define elf_x86_64_tdata(abfd) \
787 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
789 #define elf_x86_64_local_got_tls_type(abfd) \
790 (elf_x86_64_tdata (abfd)->local_got_tls_type)
792 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
793 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
795 #define is_x86_64_elf(bfd) \
796 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
797 && elf_tdata (bfd) != NULL \
798 && elf_object_id (bfd) == X86_64_ELF_DATA)
801 elf_x86_64_mkobject (bfd *abfd)
803 return bfd_elf_allocate_object (abfd, sizeof (struct elf_x86_64_obj_tdata),
807 /* x86-64 ELF linker hash table. */
809 struct elf_x86_64_link_hash_table
811 struct elf_link_hash_table elf;
813 /* Short-cuts to get to dynamic linker sections. */
816 asection *plt_eh_frame;
821 bfd_signed_vma refcount;
825 /* The amount of space used by the jump slots in the GOT. */
826 bfd_vma sgotplt_jump_table_size;
828 /* Small local sym cache. */
829 struct sym_cache sym_cache;
831 bfd_vma (*r_info) (bfd_vma, bfd_vma);
832 bfd_vma (*r_sym) (bfd_vma);
833 unsigned int pointer_r_type;
834 const char *dynamic_interpreter;
835 int dynamic_interpreter_size;
837 /* _TLS_MODULE_BASE_ symbol. */
838 struct bfd_link_hash_entry *tls_module_base;
840 /* Used by local STT_GNU_IFUNC symbols. */
841 htab_t loc_hash_table;
842 void * loc_hash_memory;
844 /* The offset into splt of the PLT entry for the TLS descriptor
845 resolver. Special values are 0, if not necessary (or not found
846 to be necessary yet), and -1 if needed but not determined
849 /* The offset into sgot of the GOT entry used by the PLT entry
853 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
854 bfd_vma next_jump_slot_index;
855 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
856 bfd_vma next_irelative_index;
859 /* Get the x86-64 ELF linker hash table from a link_info structure. */
861 #define elf_x86_64_hash_table(p) \
862 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
863 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
865 #define elf_x86_64_compute_jump_table_size(htab) \
866 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
868 /* Create an entry in an x86-64 ELF linker hash table. */
870 static struct bfd_hash_entry *
871 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry *entry,
872 struct bfd_hash_table *table,
875 /* Allocate the structure if it has not already been allocated by a
879 entry = (struct bfd_hash_entry *)
880 bfd_hash_allocate (table,
881 sizeof (struct elf_x86_64_link_hash_entry));
886 /* Call the allocation method of the superclass. */
887 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
890 struct elf_x86_64_link_hash_entry *eh;
892 eh = (struct elf_x86_64_link_hash_entry *) entry;
893 eh->dyn_relocs = NULL;
894 eh->tls_type = GOT_UNKNOWN;
895 eh->has_bnd_reloc = FALSE;
896 eh->plt_bnd.offset = (bfd_vma) -1;
897 eh->tlsdesc_got = (bfd_vma) -1;
903 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
904 for local symbol so that we can handle local STT_GNU_IFUNC symbols
905 as global symbol. We reuse indx and dynstr_index for local symbol
906 hash since they aren't used by global symbols in this backend. */
909 elf_x86_64_local_htab_hash (const void *ptr)
911 struct elf_link_hash_entry *h
912 = (struct elf_link_hash_entry *) ptr;
913 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
916 /* Compare local hash entries. */
919 elf_x86_64_local_htab_eq (const void *ptr1, const void *ptr2)
921 struct elf_link_hash_entry *h1
922 = (struct elf_link_hash_entry *) ptr1;
923 struct elf_link_hash_entry *h2
924 = (struct elf_link_hash_entry *) ptr2;
926 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
929 /* Find and/or create a hash entry for local symbol. */
931 static struct elf_link_hash_entry *
932 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table *htab,
933 bfd *abfd, const Elf_Internal_Rela *rel,
936 struct elf_x86_64_link_hash_entry e, *ret;
937 asection *sec = abfd->sections;
938 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
939 htab->r_sym (rel->r_info));
942 e.elf.indx = sec->id;
943 e.elf.dynstr_index = htab->r_sym (rel->r_info);
944 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
945 create ? INSERT : NO_INSERT);
952 ret = (struct elf_x86_64_link_hash_entry *) *slot;
956 ret = (struct elf_x86_64_link_hash_entry *)
957 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
958 sizeof (struct elf_x86_64_link_hash_entry));
961 memset (ret, 0, sizeof (*ret));
962 ret->elf.indx = sec->id;
963 ret->elf.dynstr_index = htab->r_sym (rel->r_info);
964 ret->elf.dynindx = -1;
970 /* Destroy an X86-64 ELF linker hash table. */
973 elf_x86_64_link_hash_table_free (bfd *obfd)
975 struct elf_x86_64_link_hash_table *htab
976 = (struct elf_x86_64_link_hash_table *) obfd->link.hash;
978 if (htab->loc_hash_table)
979 htab_delete (htab->loc_hash_table);
980 if (htab->loc_hash_memory)
981 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
982 _bfd_elf_link_hash_table_free (obfd);
985 /* Create an X86-64 ELF linker hash table. */
987 static struct bfd_link_hash_table *
988 elf_x86_64_link_hash_table_create (bfd *abfd)
990 struct elf_x86_64_link_hash_table *ret;
991 bfd_size_type amt = sizeof (struct elf_x86_64_link_hash_table);
993 ret = (struct elf_x86_64_link_hash_table *) bfd_zmalloc (amt);
997 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
998 elf_x86_64_link_hash_newfunc,
999 sizeof (struct elf_x86_64_link_hash_entry),
1006 if (ABI_64_P (abfd))
1008 ret->r_info = elf64_r_info;
1009 ret->r_sym = elf64_r_sym;
1010 ret->pointer_r_type = R_X86_64_64;
1011 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
1012 ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
1016 ret->r_info = elf32_r_info;
1017 ret->r_sym = elf32_r_sym;
1018 ret->pointer_r_type = R_X86_64_32;
1019 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
1020 ret->dynamic_interpreter_size = sizeof ELF32_DYNAMIC_INTERPRETER;
1023 ret->loc_hash_table = htab_try_create (1024,
1024 elf_x86_64_local_htab_hash,
1025 elf_x86_64_local_htab_eq,
1027 ret->loc_hash_memory = objalloc_create ();
1028 if (!ret->loc_hash_table || !ret->loc_hash_memory)
1030 elf_x86_64_link_hash_table_free (abfd);
1033 ret->elf.root.hash_table_free = elf_x86_64_link_hash_table_free;
1035 return &ret->elf.root;
1038 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1039 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1043 elf_x86_64_create_dynamic_sections (bfd *dynobj,
1044 struct bfd_link_info *info)
1046 struct elf_x86_64_link_hash_table *htab;
1048 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1051 htab = elf_x86_64_hash_table (info);
1055 htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
1059 if (info->executable)
1061 /* Always allow copy relocs for building executables. */
1062 asection *s = bfd_get_linker_section (dynobj, ".rela.bss");
1065 const struct elf_backend_data *bed = get_elf_backend_data (dynobj);
1066 s = bfd_make_section_anyway_with_flags (dynobj,
1068 (bed->dynamic_sec_flags
1071 || ! bfd_set_section_alignment (dynobj, s,
1072 bed->s->log_file_align))
1078 if (!info->no_ld_generated_unwind_info
1079 && htab->plt_eh_frame == NULL
1080 && htab->elf.splt != NULL)
1082 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
1083 | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1084 | SEC_LINKER_CREATED);
1086 = bfd_make_section_anyway_with_flags (dynobj, ".eh_frame", flags);
1087 if (htab->plt_eh_frame == NULL
1088 || !bfd_set_section_alignment (dynobj, htab->plt_eh_frame, 3))
1094 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1097 elf_x86_64_copy_indirect_symbol (struct bfd_link_info *info,
1098 struct elf_link_hash_entry *dir,
1099 struct elf_link_hash_entry *ind)
1101 struct elf_x86_64_link_hash_entry *edir, *eind;
1103 edir = (struct elf_x86_64_link_hash_entry *) dir;
1104 eind = (struct elf_x86_64_link_hash_entry *) ind;
1106 if (!edir->has_bnd_reloc)
1107 edir->has_bnd_reloc = eind->has_bnd_reloc;
1109 if (eind->dyn_relocs != NULL)
1111 if (edir->dyn_relocs != NULL)
1113 struct elf_dyn_relocs **pp;
1114 struct elf_dyn_relocs *p;
1116 /* Add reloc counts against the indirect sym to the direct sym
1117 list. Merge any entries against the same section. */
1118 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1120 struct elf_dyn_relocs *q;
1122 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1123 if (q->sec == p->sec)
1125 q->pc_count += p->pc_count;
1126 q->count += p->count;
1133 *pp = edir->dyn_relocs;
1136 edir->dyn_relocs = eind->dyn_relocs;
1137 eind->dyn_relocs = NULL;
1140 if (ind->root.type == bfd_link_hash_indirect
1141 && dir->got.refcount <= 0)
1143 edir->tls_type = eind->tls_type;
1144 eind->tls_type = GOT_UNKNOWN;
1147 if (ELIMINATE_COPY_RELOCS
1148 && ind->root.type != bfd_link_hash_indirect
1149 && dir->dynamic_adjusted)
1151 /* If called to transfer flags for a weakdef during processing
1152 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1153 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1154 dir->ref_dynamic |= ind->ref_dynamic;
1155 dir->ref_regular |= ind->ref_regular;
1156 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1157 dir->needs_plt |= ind->needs_plt;
1158 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1161 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1165 elf64_x86_64_elf_object_p (bfd *abfd)
1167 /* Set the right machine number for an x86-64 elf64 file. */
1168 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64);
1173 elf32_x86_64_elf_object_p (bfd *abfd)
1175 /* Set the right machine number for an x86-64 elf32 file. */
1176 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32);
1180 /* Return TRUE if the TLS access code sequence support transition
1184 elf_x86_64_check_tls_transition (bfd *abfd,
1185 struct bfd_link_info *info,
1188 Elf_Internal_Shdr *symtab_hdr,
1189 struct elf_link_hash_entry **sym_hashes,
1190 unsigned int r_type,
1191 const Elf_Internal_Rela *rel,
1192 const Elf_Internal_Rela *relend)
1195 unsigned long r_symndx;
1196 bfd_boolean largepic = FALSE;
1197 struct elf_link_hash_entry *h;
1199 struct elf_x86_64_link_hash_table *htab;
1201 /* Get the section contents. */
1202 if (contents == NULL)
1204 if (elf_section_data (sec)->this_hdr.contents != NULL)
1205 contents = elf_section_data (sec)->this_hdr.contents;
1208 /* FIXME: How to better handle error condition? */
1209 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1212 /* Cache the section contents for elf_link_input_bfd. */
1213 elf_section_data (sec)->this_hdr.contents = contents;
1217 htab = elf_x86_64_hash_table (info);
1218 offset = rel->r_offset;
1221 case R_X86_64_TLSGD:
1222 case R_X86_64_TLSLD:
1223 if ((rel + 1) >= relend)
1226 if (r_type == R_X86_64_TLSGD)
1228 /* Check transition from GD access model. For 64bit, only
1229 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1230 .word 0x6666; rex64; call __tls_get_addr
1231 can transit to different access model. For 32bit, only
1232 leaq foo@tlsgd(%rip), %rdi
1233 .word 0x6666; rex64; call __tls_get_addr
1234 can transit to different access model. For largepic
1236 leaq foo@tlsgd(%rip), %rdi
1237 movabsq $__tls_get_addr@pltoff, %rax
1241 static const unsigned char call[] = { 0x66, 0x66, 0x48, 0xe8 };
1242 static const unsigned char leaq[] = { 0x66, 0x48, 0x8d, 0x3d };
1244 if ((offset + 12) > sec->size)
1247 if (memcmp (contents + offset + 4, call, 4) != 0)
1249 if (!ABI_64_P (abfd)
1250 || (offset + 19) > sec->size
1252 || memcmp (contents + offset - 3, leaq + 1, 3) != 0
1253 || memcmp (contents + offset + 4, "\x48\xb8", 2) != 0
1254 || memcmp (contents + offset + 14, "\x48\x01\xd8\xff\xd0", 5)
1259 else if (ABI_64_P (abfd))
1262 || memcmp (contents + offset - 4, leaq, 4) != 0)
1268 || memcmp (contents + offset - 3, leaq + 1, 3) != 0)
1274 /* Check transition from LD access model. Only
1275 leaq foo@tlsld(%rip), %rdi;
1277 can transit to different access model. For largepic
1279 leaq foo@tlsld(%rip), %rdi
1280 movabsq $__tls_get_addr@pltoff, %rax
1284 static const unsigned char lea[] = { 0x48, 0x8d, 0x3d };
1286 if (offset < 3 || (offset + 9) > sec->size)
1289 if (memcmp (contents + offset - 3, lea, 3) != 0)
1292 if (0xe8 != *(contents + offset + 4))
1294 if (!ABI_64_P (abfd)
1295 || (offset + 19) > sec->size
1296 || memcmp (contents + offset + 4, "\x48\xb8", 2) != 0
1297 || memcmp (contents + offset + 14, "\x48\x01\xd8\xff\xd0", 5)
1304 r_symndx = htab->r_sym (rel[1].r_info);
1305 if (r_symndx < symtab_hdr->sh_info)
1308 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1309 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1310 may be versioned. */
1312 && h->root.root.string != NULL
1314 ? ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PLTOFF64
1315 : (ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PC32
1316 || ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PLT32))
1317 && (strncmp (h->root.root.string,
1318 "__tls_get_addr", 14) == 0));
1320 case R_X86_64_GOTTPOFF:
1321 /* Check transition from IE access model:
1322 mov foo@gottpoff(%rip), %reg
1323 add foo@gottpoff(%rip), %reg
1326 /* Check REX prefix first. */
1327 if (offset >= 3 && (offset + 4) <= sec->size)
1329 val = bfd_get_8 (abfd, contents + offset - 3);
1330 if (val != 0x48 && val != 0x4c)
1332 /* X32 may have 0x44 REX prefix or no REX prefix. */
1333 if (ABI_64_P (abfd))
1339 /* X32 may not have any REX prefix. */
1340 if (ABI_64_P (abfd))
1342 if (offset < 2 || (offset + 3) > sec->size)
1346 val = bfd_get_8 (abfd, contents + offset - 2);
1347 if (val != 0x8b && val != 0x03)
1350 val = bfd_get_8 (abfd, contents + offset - 1);
1351 return (val & 0xc7) == 5;
1353 case R_X86_64_GOTPC32_TLSDESC:
1354 /* Check transition from GDesc access model:
1355 leaq x@tlsdesc(%rip), %rax
1357 Make sure it's a leaq adding rip to a 32-bit offset
1358 into any register, although it's probably almost always
1361 if (offset < 3 || (offset + 4) > sec->size)
1364 val = bfd_get_8 (abfd, contents + offset - 3);
1365 if ((val & 0xfb) != 0x48)
1368 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1371 val = bfd_get_8 (abfd, contents + offset - 1);
1372 return (val & 0xc7) == 0x05;
1374 case R_X86_64_TLSDESC_CALL:
1375 /* Check transition from GDesc access model:
1376 call *x@tlsdesc(%rax)
1378 if (offset + 2 <= sec->size)
1380 /* Make sure that it's a call *x@tlsdesc(%rax). */
1381 static const unsigned char call[] = { 0xff, 0x10 };
1382 return memcmp (contents + offset, call, 2) == 0;
1392 /* Return TRUE if the TLS access transition is OK or no transition
1393 will be performed. Update R_TYPE if there is a transition. */
1396 elf_x86_64_tls_transition (struct bfd_link_info *info, bfd *abfd,
1397 asection *sec, bfd_byte *contents,
1398 Elf_Internal_Shdr *symtab_hdr,
1399 struct elf_link_hash_entry **sym_hashes,
1400 unsigned int *r_type, int tls_type,
1401 const Elf_Internal_Rela *rel,
1402 const Elf_Internal_Rela *relend,
1403 struct elf_link_hash_entry *h,
1404 unsigned long r_symndx)
1406 unsigned int from_type = *r_type;
1407 unsigned int to_type = from_type;
1408 bfd_boolean check = TRUE;
1410 /* Skip TLS transition for functions. */
1412 && (h->type == STT_FUNC
1413 || h->type == STT_GNU_IFUNC))
1418 case R_X86_64_TLSGD:
1419 case R_X86_64_GOTPC32_TLSDESC:
1420 case R_X86_64_TLSDESC_CALL:
1421 case R_X86_64_GOTTPOFF:
1422 if (info->executable)
1425 to_type = R_X86_64_TPOFF32;
1427 to_type = R_X86_64_GOTTPOFF;
1430 /* When we are called from elf_x86_64_relocate_section,
1431 CONTENTS isn't NULL and there may be additional transitions
1432 based on TLS_TYPE. */
1433 if (contents != NULL)
1435 unsigned int new_to_type = to_type;
1437 if (info->executable
1440 && tls_type == GOT_TLS_IE)
1441 new_to_type = R_X86_64_TPOFF32;
1443 if (to_type == R_X86_64_TLSGD
1444 || to_type == R_X86_64_GOTPC32_TLSDESC
1445 || to_type == R_X86_64_TLSDESC_CALL)
1447 if (tls_type == GOT_TLS_IE)
1448 new_to_type = R_X86_64_GOTTPOFF;
1451 /* We checked the transition before when we were called from
1452 elf_x86_64_check_relocs. We only want to check the new
1453 transition which hasn't been checked before. */
1454 check = new_to_type != to_type && from_type == to_type;
1455 to_type = new_to_type;
1460 case R_X86_64_TLSLD:
1461 if (info->executable)
1462 to_type = R_X86_64_TPOFF32;
1469 /* Return TRUE if there is no transition. */
1470 if (from_type == to_type)
1473 /* Check if the transition can be performed. */
1475 && ! elf_x86_64_check_tls_transition (abfd, info, sec, contents,
1476 symtab_hdr, sym_hashes,
1477 from_type, rel, relend))
1479 reloc_howto_type *from, *to;
1482 from = elf_x86_64_rtype_to_howto (abfd, from_type);
1483 to = elf_x86_64_rtype_to_howto (abfd, to_type);
1486 name = h->root.root.string;
1489 struct elf_x86_64_link_hash_table *htab;
1491 htab = elf_x86_64_hash_table (info);
1496 Elf_Internal_Sym *isym;
1498 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1500 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1504 (*_bfd_error_handler)
1505 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1506 "in section `%A' failed"),
1507 abfd, sec, from->name, to->name, name,
1508 (unsigned long) rel->r_offset);
1509 bfd_set_error (bfd_error_bad_value);
1517 /* Look through the relocs for a section during the first phase, and
1518 calculate needed space in the global offset table, procedure
1519 linkage table, and dynamic reloc sections. */
1522 elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info,
1524 const Elf_Internal_Rela *relocs)
1526 struct elf_x86_64_link_hash_table *htab;
1527 Elf_Internal_Shdr *symtab_hdr;
1528 struct elf_link_hash_entry **sym_hashes;
1529 const Elf_Internal_Rela *rel;
1530 const Elf_Internal_Rela *rel_end;
1533 if (info->relocatable)
1536 BFD_ASSERT (is_x86_64_elf (abfd));
1538 htab = elf_x86_64_hash_table (info);
1542 symtab_hdr = &elf_symtab_hdr (abfd);
1543 sym_hashes = elf_sym_hashes (abfd);
1547 rel_end = relocs + sec->reloc_count;
1548 for (rel = relocs; rel < rel_end; rel++)
1550 unsigned int r_type;
1551 unsigned long r_symndx;
1552 struct elf_link_hash_entry *h;
1553 Elf_Internal_Sym *isym;
1555 bfd_boolean size_reloc;
1557 r_symndx = htab->r_sym (rel->r_info);
1558 r_type = ELF32_R_TYPE (rel->r_info);
1560 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1562 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1567 if (r_symndx < symtab_hdr->sh_info)
1569 /* A local symbol. */
1570 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1575 /* Check relocation against local STT_GNU_IFUNC symbol. */
1576 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1578 h = elf_x86_64_get_local_sym_hash (htab, abfd, rel,
1583 /* Fake a STT_GNU_IFUNC symbol. */
1584 h->type = STT_GNU_IFUNC;
1587 h->forced_local = 1;
1588 h->root.type = bfd_link_hash_defined;
1596 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1597 while (h->root.type == bfd_link_hash_indirect
1598 || h->root.type == bfd_link_hash_warning)
1599 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1602 /* Check invalid x32 relocations. */
1603 if (!ABI_64_P (abfd))
1609 case R_X86_64_DTPOFF64:
1610 case R_X86_64_TPOFF64:
1612 case R_X86_64_GOTOFF64:
1613 case R_X86_64_GOT64:
1614 case R_X86_64_GOTPCREL64:
1615 case R_X86_64_GOTPC64:
1616 case R_X86_64_GOTPLT64:
1617 case R_X86_64_PLTOFF64:
1620 name = h->root.root.string;
1622 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1624 (*_bfd_error_handler)
1625 (_("%B: relocation %s against symbol `%s' isn't "
1626 "supported in x32 mode"), abfd,
1627 x86_64_elf_howto_table[r_type].name, name);
1628 bfd_set_error (bfd_error_bad_value);
1636 /* Create the ifunc sections for static executables. If we
1637 never see an indirect function symbol nor we are building
1638 a static executable, those sections will be empty and
1639 won't appear in output. */
1645 case R_X86_64_PC32_BND:
1646 case R_X86_64_PLT32_BND:
1648 case R_X86_64_PLT32:
1651 /* MPX PLT is supported only if elf_x86_64_arch_bed
1652 is used in 64-bit mode. */
1655 && (get_elf_x86_64_backend_data (abfd)
1656 == &elf_x86_64_arch_bed))
1658 elf_x86_64_hash_entry (h)->has_bnd_reloc = TRUE;
1660 /* Create the second PLT for Intel MPX support. */
1661 if (htab->plt_bnd == NULL)
1663 unsigned int plt_bnd_align;
1664 const struct elf_backend_data *bed;
1666 bed = get_elf_backend_data (info->output_bfd);
1667 switch (sizeof (elf_x86_64_bnd_plt2_entry))
1679 if (htab->elf.dynobj == NULL)
1680 htab->elf.dynobj = abfd;
1682 = bfd_make_section_anyway_with_flags (htab->elf.dynobj,
1684 (bed->dynamic_sec_flags
1689 if (htab->plt_bnd == NULL
1690 || !bfd_set_section_alignment (htab->elf.dynobj,
1699 case R_X86_64_GOTPCREL:
1700 case R_X86_64_GOTPCREL64:
1701 if (htab->elf.dynobj == NULL)
1702 htab->elf.dynobj = abfd;
1703 if (!_bfd_elf_create_ifunc_sections (htab->elf.dynobj, info))
1708 /* It is referenced by a non-shared object. */
1710 h->root.non_ir_ref = 1;
1713 if (! elf_x86_64_tls_transition (info, abfd, sec, NULL,
1714 symtab_hdr, sym_hashes,
1715 &r_type, GOT_UNKNOWN,
1716 rel, rel_end, h, r_symndx))
1721 case R_X86_64_TLSLD:
1722 htab->tls_ld_got.refcount += 1;
1725 case R_X86_64_TPOFF32:
1726 if (!info->executable && ABI_64_P (abfd))
1729 name = h->root.root.string;
1731 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1733 (*_bfd_error_handler)
1734 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1736 x86_64_elf_howto_table[r_type].name, name);
1737 bfd_set_error (bfd_error_bad_value);
1742 case R_X86_64_GOTTPOFF:
1743 if (!info->executable)
1744 info->flags |= DF_STATIC_TLS;
1747 case R_X86_64_GOT32:
1748 case R_X86_64_GOTPCREL:
1749 case R_X86_64_TLSGD:
1750 case R_X86_64_GOT64:
1751 case R_X86_64_GOTPCREL64:
1752 case R_X86_64_GOTPLT64:
1753 case R_X86_64_GOTPC32_TLSDESC:
1754 case R_X86_64_TLSDESC_CALL:
1755 /* This symbol requires a global offset table entry. */
1757 int tls_type, old_tls_type;
1761 default: tls_type = GOT_NORMAL; break;
1762 case R_X86_64_TLSGD: tls_type = GOT_TLS_GD; break;
1763 case R_X86_64_GOTTPOFF: tls_type = GOT_TLS_IE; break;
1764 case R_X86_64_GOTPC32_TLSDESC:
1765 case R_X86_64_TLSDESC_CALL:
1766 tls_type = GOT_TLS_GDESC; break;
1771 if (r_type == R_X86_64_GOTPLT64)
1773 /* This relocation indicates that we also need
1774 a PLT entry, as this is a function. We don't need
1775 a PLT entry for local symbols. */
1777 h->plt.refcount += 1;
1779 h->got.refcount += 1;
1780 old_tls_type = elf_x86_64_hash_entry (h)->tls_type;
1784 bfd_signed_vma *local_got_refcounts;
1786 /* This is a global offset table entry for a local symbol. */
1787 local_got_refcounts = elf_local_got_refcounts (abfd);
1788 if (local_got_refcounts == NULL)
1792 size = symtab_hdr->sh_info;
1793 size *= sizeof (bfd_signed_vma)
1794 + sizeof (bfd_vma) + sizeof (char);
1795 local_got_refcounts = ((bfd_signed_vma *)
1796 bfd_zalloc (abfd, size));
1797 if (local_got_refcounts == NULL)
1799 elf_local_got_refcounts (abfd) = local_got_refcounts;
1800 elf_x86_64_local_tlsdesc_gotent (abfd)
1801 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
1802 elf_x86_64_local_got_tls_type (abfd)
1803 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
1805 local_got_refcounts[r_symndx] += 1;
1807 = elf_x86_64_local_got_tls_type (abfd) [r_symndx];
1810 /* If a TLS symbol is accessed using IE at least once,
1811 there is no point to use dynamic model for it. */
1812 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1813 && (! GOT_TLS_GD_ANY_P (old_tls_type)
1814 || tls_type != GOT_TLS_IE))
1816 if (old_tls_type == GOT_TLS_IE && GOT_TLS_GD_ANY_P (tls_type))
1817 tls_type = old_tls_type;
1818 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1819 && GOT_TLS_GD_ANY_P (tls_type))
1820 tls_type |= old_tls_type;
1824 name = h->root.root.string;
1826 name = bfd_elf_sym_name (abfd, symtab_hdr,
1828 (*_bfd_error_handler)
1829 (_("%B: '%s' accessed both as normal and thread local symbol"),
1831 bfd_set_error (bfd_error_bad_value);
1836 if (old_tls_type != tls_type)
1839 elf_x86_64_hash_entry (h)->tls_type = tls_type;
1841 elf_x86_64_local_got_tls_type (abfd) [r_symndx] = tls_type;
1846 case R_X86_64_GOTOFF64:
1847 case R_X86_64_GOTPC32:
1848 case R_X86_64_GOTPC64:
1850 if (htab->elf.sgot == NULL)
1852 if (htab->elf.dynobj == NULL)
1853 htab->elf.dynobj = abfd;
1854 if (!_bfd_elf_create_got_section (htab->elf.dynobj,
1860 case R_X86_64_PLT32:
1861 case R_X86_64_PLT32_BND:
1862 /* This symbol requires a procedure linkage table entry. We
1863 actually build the entry in adjust_dynamic_symbol,
1864 because this might be a case of linking PIC code which is
1865 never referenced by a dynamic object, in which case we
1866 don't need to generate a procedure linkage table entry
1869 /* If this is a local symbol, we resolve it directly without
1870 creating a procedure linkage table entry. */
1875 h->plt.refcount += 1;
1878 case R_X86_64_PLTOFF64:
1879 /* This tries to form the 'address' of a function relative
1880 to GOT. For global symbols we need a PLT entry. */
1884 h->plt.refcount += 1;
1888 case R_X86_64_SIZE32:
1889 case R_X86_64_SIZE64:
1894 if (!ABI_64_P (abfd))
1899 /* Let's help debug shared library creation. These relocs
1900 cannot be used in shared libs. Don't error out for
1901 sections we don't care about, such as debug sections or
1902 non-constant sections. */
1904 && (sec->flags & SEC_ALLOC) != 0
1905 && (sec->flags & SEC_READONLY) != 0)
1908 name = h->root.root.string;
1910 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1911 (*_bfd_error_handler)
1912 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1913 abfd, x86_64_elf_howto_table[r_type].name, name);
1914 bfd_set_error (bfd_error_bad_value);
1922 case R_X86_64_PC32_BND:
1926 if (h != NULL && info->executable)
1928 /* If this reloc is in a read-only section, we might
1929 need a copy reloc. We can't check reliably at this
1930 stage whether the section is read-only, as input
1931 sections have not yet been mapped to output sections.
1932 Tentatively set the flag for now, and correct in
1933 adjust_dynamic_symbol. */
1936 /* We may need a .plt entry if the function this reloc
1937 refers to is in a shared lib. */
1938 h->plt.refcount += 1;
1939 if (r_type != R_X86_64_PC32
1940 && r_type != R_X86_64_PC32_BND
1941 && r_type != R_X86_64_PC64)
1942 h->pointer_equality_needed = 1;
1947 /* If we are creating a shared library, and this is a reloc
1948 against a global symbol, or a non PC relative reloc
1949 against a local symbol, then we need to copy the reloc
1950 into the shared library. However, if we are linking with
1951 -Bsymbolic, we do not need to copy a reloc against a
1952 global symbol which is defined in an object we are
1953 including in the link (i.e., DEF_REGULAR is set). At
1954 this point we have not seen all the input files, so it is
1955 possible that DEF_REGULAR is not set now but will be set
1956 later (it is never cleared). In case of a weak definition,
1957 DEF_REGULAR may be cleared later by a strong definition in
1958 a shared library. We account for that possibility below by
1959 storing information in the relocs_copied field of the hash
1960 table entry. A similar situation occurs when creating
1961 shared libraries and symbol visibility changes render the
1964 If on the other hand, we are creating an executable, we
1965 may need to keep relocations for symbols satisfied by a
1966 dynamic library if we manage to avoid copy relocs for the
1969 && (sec->flags & SEC_ALLOC) != 0
1970 && (! IS_X86_64_PCREL_TYPE (r_type)
1972 && (! SYMBOLIC_BIND (info, h)
1973 || h->root.type == bfd_link_hash_defweak
1974 || !h->def_regular))))
1975 || (ELIMINATE_COPY_RELOCS
1977 && (sec->flags & SEC_ALLOC) != 0
1979 && (h->root.type == bfd_link_hash_defweak
1980 || !h->def_regular)))
1982 struct elf_dyn_relocs *p;
1983 struct elf_dyn_relocs **head;
1985 /* We must copy these reloc types into the output file.
1986 Create a reloc section in dynobj and make room for
1990 if (htab->elf.dynobj == NULL)
1991 htab->elf.dynobj = abfd;
1993 sreloc = _bfd_elf_make_dynamic_reloc_section
1994 (sec, htab->elf.dynobj, ABI_64_P (abfd) ? 3 : 2,
1995 abfd, /*rela?*/ TRUE);
2001 /* If this is a global symbol, we count the number of
2002 relocations we need for this symbol. */
2005 head = &((struct elf_x86_64_link_hash_entry *) h)->dyn_relocs;
2009 /* Track dynamic relocs needed for local syms too.
2010 We really need local syms available to do this
2015 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2020 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
2024 /* Beware of type punned pointers vs strict aliasing
2026 vpp = &(elf_section_data (s)->local_dynrel);
2027 head = (struct elf_dyn_relocs **)vpp;
2031 if (p == NULL || p->sec != sec)
2033 bfd_size_type amt = sizeof *p;
2035 p = ((struct elf_dyn_relocs *)
2036 bfd_alloc (htab->elf.dynobj, amt));
2047 /* Count size relocation as PC-relative relocation. */
2048 if (IS_X86_64_PCREL_TYPE (r_type) || size_reloc)
2053 /* This relocation describes the C++ object vtable hierarchy.
2054 Reconstruct it for later use during GC. */
2055 case R_X86_64_GNU_VTINHERIT:
2056 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2060 /* This relocation describes which C++ vtable entries are actually
2061 used. Record for later use during GC. */
2062 case R_X86_64_GNU_VTENTRY:
2063 BFD_ASSERT (h != NULL);
2065 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2077 /* Return the section that should be marked against GC for a given
2081 elf_x86_64_gc_mark_hook (asection *sec,
2082 struct bfd_link_info *info,
2083 Elf_Internal_Rela *rel,
2084 struct elf_link_hash_entry *h,
2085 Elf_Internal_Sym *sym)
2088 switch (ELF32_R_TYPE (rel->r_info))
2090 case R_X86_64_GNU_VTINHERIT:
2091 case R_X86_64_GNU_VTENTRY:
2095 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2098 /* Update the got entry reference counts for the section being removed. */
2101 elf_x86_64_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
2103 const Elf_Internal_Rela *relocs)
2105 struct elf_x86_64_link_hash_table *htab;
2106 Elf_Internal_Shdr *symtab_hdr;
2107 struct elf_link_hash_entry **sym_hashes;
2108 bfd_signed_vma *local_got_refcounts;
2109 const Elf_Internal_Rela *rel, *relend;
2111 if (info->relocatable)
2114 htab = elf_x86_64_hash_table (info);
2118 elf_section_data (sec)->local_dynrel = NULL;
2120 symtab_hdr = &elf_symtab_hdr (abfd);
2121 sym_hashes = elf_sym_hashes (abfd);
2122 local_got_refcounts = elf_local_got_refcounts (abfd);
2124 htab = elf_x86_64_hash_table (info);
2125 relend = relocs + sec->reloc_count;
2126 for (rel = relocs; rel < relend; rel++)
2128 unsigned long r_symndx;
2129 unsigned int r_type;
2130 struct elf_link_hash_entry *h = NULL;
2132 r_symndx = htab->r_sym (rel->r_info);
2133 if (r_symndx >= symtab_hdr->sh_info)
2135 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2136 while (h->root.type == bfd_link_hash_indirect
2137 || h->root.type == bfd_link_hash_warning)
2138 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2142 /* A local symbol. */
2143 Elf_Internal_Sym *isym;
2145 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2148 /* Check relocation against local STT_GNU_IFUNC symbol. */
2150 && ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
2152 h = elf_x86_64_get_local_sym_hash (htab, abfd, rel, FALSE);
2160 struct elf_x86_64_link_hash_entry *eh;
2161 struct elf_dyn_relocs **pp;
2162 struct elf_dyn_relocs *p;
2164 eh = (struct elf_x86_64_link_hash_entry *) h;
2166 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
2169 /* Everything must go for SEC. */
2175 r_type = ELF32_R_TYPE (rel->r_info);
2176 if (! elf_x86_64_tls_transition (info, abfd, sec, NULL,
2177 symtab_hdr, sym_hashes,
2178 &r_type, GOT_UNKNOWN,
2179 rel, relend, h, r_symndx))
2184 case R_X86_64_TLSLD:
2185 if (htab->tls_ld_got.refcount > 0)
2186 htab->tls_ld_got.refcount -= 1;
2189 case R_X86_64_TLSGD:
2190 case R_X86_64_GOTPC32_TLSDESC:
2191 case R_X86_64_TLSDESC_CALL:
2192 case R_X86_64_GOTTPOFF:
2193 case R_X86_64_GOT32:
2194 case R_X86_64_GOTPCREL:
2195 case R_X86_64_GOT64:
2196 case R_X86_64_GOTPCREL64:
2197 case R_X86_64_GOTPLT64:
2200 if (r_type == R_X86_64_GOTPLT64 && h->plt.refcount > 0)
2201 h->plt.refcount -= 1;
2202 if (h->got.refcount > 0)
2203 h->got.refcount -= 1;
2204 if (h->type == STT_GNU_IFUNC)
2206 if (h->plt.refcount > 0)
2207 h->plt.refcount -= 1;
2210 else if (local_got_refcounts != NULL)
2212 if (local_got_refcounts[r_symndx] > 0)
2213 local_got_refcounts[r_symndx] -= 1;
2225 case R_X86_64_PC32_BND:
2227 case R_X86_64_SIZE32:
2228 case R_X86_64_SIZE64:
2230 && (h == NULL || h->type != STT_GNU_IFUNC))
2234 case R_X86_64_PLT32:
2235 case R_X86_64_PLT32_BND:
2236 case R_X86_64_PLTOFF64:
2239 if (h->plt.refcount > 0)
2240 h->plt.refcount -= 1;
2252 /* Adjust a symbol defined by a dynamic object and referenced by a
2253 regular object. The current definition is in some section of the
2254 dynamic object, but we're not including those sections. We have to
2255 change the definition to something the rest of the link can
2259 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info *info,
2260 struct elf_link_hash_entry *h)
2262 struct elf_x86_64_link_hash_table *htab;
2264 struct elf_x86_64_link_hash_entry *eh;
2265 struct elf_dyn_relocs *p;
2267 /* STT_GNU_IFUNC symbol must go through PLT. */
2268 if (h->type == STT_GNU_IFUNC)
2270 /* All local STT_GNU_IFUNC references must be treate as local
2271 calls via local PLT. */
2273 && SYMBOL_CALLS_LOCAL (info, h))
2275 bfd_size_type pc_count = 0, count = 0;
2276 struct elf_dyn_relocs **pp;
2278 eh = (struct elf_x86_64_link_hash_entry *) h;
2279 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2281 pc_count += p->pc_count;
2282 p->count -= p->pc_count;
2291 if (pc_count || count)
2295 if (h->plt.refcount <= 0)
2296 h->plt.refcount = 1;
2298 h->plt.refcount += 1;
2302 if (h->plt.refcount <= 0)
2304 h->plt.offset = (bfd_vma) -1;
2310 /* If this is a function, put it in the procedure linkage table. We
2311 will fill in the contents of the procedure linkage table later,
2312 when we know the address of the .got section. */
2313 if (h->type == STT_FUNC
2316 if (h->plt.refcount <= 0
2317 || SYMBOL_CALLS_LOCAL (info, h)
2318 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2319 && h->root.type == bfd_link_hash_undefweak))
2321 /* This case can occur if we saw a PLT32 reloc in an input
2322 file, but the symbol was never referred to by a dynamic
2323 object, or if all references were garbage collected. In
2324 such a case, we don't actually need to build a procedure
2325 linkage table, and we can just do a PC32 reloc instead. */
2326 h->plt.offset = (bfd_vma) -1;
2333 /* It's possible that we incorrectly decided a .plt reloc was
2334 needed for an R_X86_64_PC32 reloc to a non-function sym in
2335 check_relocs. We can't decide accurately between function and
2336 non-function syms in check-relocs; Objects loaded later in
2337 the link may change h->type. So fix it now. */
2338 h->plt.offset = (bfd_vma) -1;
2340 /* If this is a weak symbol, and there is a real definition, the
2341 processor independent code will have arranged for us to see the
2342 real definition first, and we can just use the same value. */
2343 if (h->u.weakdef != NULL)
2345 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2346 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2347 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2348 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2349 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
2350 h->non_got_ref = h->u.weakdef->non_got_ref;
2354 /* This is a reference to a symbol defined by a dynamic object which
2355 is not a function. */
2357 /* If we are creating a shared library, we must presume that the
2358 only references to the symbol are via the global offset table.
2359 For such cases we need not do anything here; the relocations will
2360 be handled correctly by relocate_section. */
2361 if (!info->executable)
2364 /* If there are no references to this symbol that do not use the
2365 GOT, we don't need to generate a copy reloc. */
2366 if (!h->non_got_ref)
2369 /* If -z nocopyreloc was given, we won't generate them either. */
2370 if (info->nocopyreloc)
2376 if (ELIMINATE_COPY_RELOCS)
2378 eh = (struct elf_x86_64_link_hash_entry *) h;
2379 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2381 s = p->sec->output_section;
2382 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2386 /* If we didn't find any dynamic relocs in read-only sections, then
2387 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2395 /* We must allocate the symbol in our .dynbss section, which will
2396 become part of the .bss section of the executable. There will be
2397 an entry for this symbol in the .dynsym section. The dynamic
2398 object will contain position independent code, so all references
2399 from the dynamic object to this symbol will go through the global
2400 offset table. The dynamic linker will use the .dynsym entry to
2401 determine the address it must put in the global offset table, so
2402 both the dynamic object and the regular object will refer to the
2403 same memory location for the variable. */
2405 htab = elf_x86_64_hash_table (info);
2409 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2410 to copy the initial value out of the dynamic object and into the
2411 runtime process image. */
2412 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2414 const struct elf_backend_data *bed;
2415 bed = get_elf_backend_data (info->output_bfd);
2416 htab->srelbss->size += bed->s->sizeof_rela;
2422 return _bfd_elf_adjust_dynamic_copy (h, s);
2425 /* Allocate space in .plt, .got and associated reloc sections for
2429 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2431 struct bfd_link_info *info;
2432 struct elf_x86_64_link_hash_table *htab;
2433 struct elf_x86_64_link_hash_entry *eh;
2434 struct elf_dyn_relocs *p;
2435 const struct elf_backend_data *bed;
2436 unsigned int plt_entry_size;
2438 if (h->root.type == bfd_link_hash_indirect)
2441 eh = (struct elf_x86_64_link_hash_entry *) h;
2443 info = (struct bfd_link_info *) inf;
2444 htab = elf_x86_64_hash_table (info);
2447 bed = get_elf_backend_data (info->output_bfd);
2448 plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
2450 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2451 here if it is defined and referenced in a non-shared object. */
2452 if (h->type == STT_GNU_IFUNC
2455 if (_bfd_elf_allocate_ifunc_dyn_relocs (info, h,
2461 asection *s = htab->plt_bnd;
2462 if (h->plt.offset != (bfd_vma) -1 && s != NULL)
2464 /* Use the .plt.bnd section if it is created. */
2465 eh->plt_bnd.offset = s->size;
2467 /* Make room for this entry in the .plt.bnd section. */
2468 s->size += sizeof (elf_x86_64_legacy_plt2_entry);
2476 else if (htab->elf.dynamic_sections_created
2477 && h->plt.refcount > 0)
2479 /* Make sure this symbol is output as a dynamic symbol.
2480 Undefined weak syms won't yet be marked as dynamic. */
2481 if (h->dynindx == -1
2482 && !h->forced_local)
2484 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2489 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2491 asection *s = htab->elf.splt;
2492 asection *bnd_s = htab->plt_bnd;
2494 /* If this is the first .plt entry, make room for the special
2497 s->size = plt_entry_size;
2499 h->plt.offset = s->size;
2501 eh->plt_bnd.offset = bnd_s->size;
2503 /* If this symbol is not defined in a regular file, and we are
2504 not generating a shared library, then set the symbol to this
2505 location in the .plt. This is required to make function
2506 pointers compare as equal between the normal executable and
2507 the shared library. */
2513 /* We need to make a call to the entry of the second
2514 PLT instead of regular PLT entry. */
2515 h->root.u.def.section = bnd_s;
2516 h->root.u.def.value = eh->plt_bnd.offset;
2520 h->root.u.def.section = s;
2521 h->root.u.def.value = h->plt.offset;
2525 /* Make room for this entry. */
2526 s->size += plt_entry_size;
2529 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry)
2530 == sizeof (elf_x86_64_legacy_plt2_entry));
2531 bnd_s->size += sizeof (elf_x86_64_legacy_plt2_entry);
2534 /* We also need to make an entry in the .got.plt section, which
2535 will be placed in the .got section by the linker script. */
2536 htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
2538 /* We also need to make an entry in the .rela.plt section. */
2539 htab->elf.srelplt->size += bed->s->sizeof_rela;
2540 htab->elf.srelplt->reloc_count++;
2544 h->plt.offset = (bfd_vma) -1;
2550 h->plt.offset = (bfd_vma) -1;
2554 eh->tlsdesc_got = (bfd_vma) -1;
2556 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2557 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2558 if (h->got.refcount > 0
2561 && elf_x86_64_hash_entry (h)->tls_type == GOT_TLS_IE)
2563 h->got.offset = (bfd_vma) -1;
2565 else if (h->got.refcount > 0)
2569 int tls_type = elf_x86_64_hash_entry (h)->tls_type;
2571 /* Make sure this symbol is output as a dynamic symbol.
2572 Undefined weak syms won't yet be marked as dynamic. */
2573 if (h->dynindx == -1
2574 && !h->forced_local)
2576 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2580 if (GOT_TLS_GDESC_P (tls_type))
2582 eh->tlsdesc_got = htab->elf.sgotplt->size
2583 - elf_x86_64_compute_jump_table_size (htab);
2584 htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
2585 h->got.offset = (bfd_vma) -2;
2587 if (! GOT_TLS_GDESC_P (tls_type)
2588 || GOT_TLS_GD_P (tls_type))
2591 h->got.offset = s->size;
2592 s->size += GOT_ENTRY_SIZE;
2593 if (GOT_TLS_GD_P (tls_type))
2594 s->size += GOT_ENTRY_SIZE;
2596 dyn = htab->elf.dynamic_sections_created;
2597 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2599 R_X86_64_GOTTPOFF needs one dynamic relocation. */
2600 if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
2601 || tls_type == GOT_TLS_IE)
2602 htab->elf.srelgot->size += bed->s->sizeof_rela;
2603 else if (GOT_TLS_GD_P (tls_type))
2604 htab->elf.srelgot->size += 2 * bed->s->sizeof_rela;
2605 else if (! GOT_TLS_GDESC_P (tls_type)
2606 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2607 || h->root.type != bfd_link_hash_undefweak)
2609 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
2610 htab->elf.srelgot->size += bed->s->sizeof_rela;
2611 if (GOT_TLS_GDESC_P (tls_type))
2613 htab->elf.srelplt->size += bed->s->sizeof_rela;
2614 htab->tlsdesc_plt = (bfd_vma) -1;
2618 h->got.offset = (bfd_vma) -1;
2620 if (eh->dyn_relocs == NULL)
2623 /* In the shared -Bsymbolic case, discard space allocated for
2624 dynamic pc-relative relocs against symbols which turn out to be
2625 defined in regular objects. For the normal shared case, discard
2626 space for pc-relative relocs that have become local due to symbol
2627 visibility changes. */
2631 /* Relocs that use pc_count are those that appear on a call
2632 insn, or certain REL relocs that can generated via assembly.
2633 We want calls to protected symbols to resolve directly to the
2634 function rather than going via the plt. If people want
2635 function pointer comparisons to work as expected then they
2636 should avoid writing weird assembly. */
2637 if (SYMBOL_CALLS_LOCAL (info, h))
2639 struct elf_dyn_relocs **pp;
2641 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2643 p->count -= p->pc_count;
2652 /* Also discard relocs on undefined weak syms with non-default
2654 if (eh->dyn_relocs != NULL)
2656 if (h->root.type == bfd_link_hash_undefweak)
2658 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2659 eh->dyn_relocs = NULL;
2661 /* Make sure undefined weak symbols are output as a dynamic
2663 else if (h->dynindx == -1
2664 && ! h->forced_local
2665 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2668 /* For PIE, discard space for relocs against symbols which
2669 turn out to need copy relocs. */
2670 else if (info->executable
2674 eh->dyn_relocs = NULL;
2677 else if (ELIMINATE_COPY_RELOCS)
2679 /* For the non-shared case, discard space for relocs against
2680 symbols which turn out to need copy relocs or are not
2686 || (htab->elf.dynamic_sections_created
2687 && (h->root.type == bfd_link_hash_undefweak
2688 || h->root.type == bfd_link_hash_undefined))))
2690 /* Make sure this symbol is output as a dynamic symbol.
2691 Undefined weak syms won't yet be marked as dynamic. */
2692 if (h->dynindx == -1
2693 && ! h->forced_local
2694 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2697 /* If that succeeded, we know we'll be keeping all the
2699 if (h->dynindx != -1)
2703 eh->dyn_relocs = NULL;
2708 /* Finally, allocate space. */
2709 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2713 sreloc = elf_section_data (p->sec)->sreloc;
2715 BFD_ASSERT (sreloc != NULL);
2717 sreloc->size += p->count * bed->s->sizeof_rela;
2723 /* Allocate space in .plt, .got and associated reloc sections for
2724 local dynamic relocs. */
2727 elf_x86_64_allocate_local_dynrelocs (void **slot, void *inf)
2729 struct elf_link_hash_entry *h
2730 = (struct elf_link_hash_entry *) *slot;
2732 if (h->type != STT_GNU_IFUNC
2736 || h->root.type != bfd_link_hash_defined)
2739 return elf_x86_64_allocate_dynrelocs (h, inf);
2742 /* Find any dynamic relocs that apply to read-only sections. */
2745 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry *h,
2748 struct elf_x86_64_link_hash_entry *eh;
2749 struct elf_dyn_relocs *p;
2751 /* Skip local IFUNC symbols. */
2752 if (h->forced_local && h->type == STT_GNU_IFUNC)
2755 eh = (struct elf_x86_64_link_hash_entry *) h;
2756 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2758 asection *s = p->sec->output_section;
2760 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2762 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2764 info->flags |= DF_TEXTREL;
2766 if (info->warn_shared_textrel && info->shared)
2767 info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2768 p->sec->owner, h->root.root.string,
2771 /* Not an error, just cut short the traversal. */
2779 mov foo@GOTPCREL(%rip), %reg
2782 with the local symbol, foo. */
2785 elf_x86_64_convert_mov_to_lea (bfd *abfd, asection *sec,
2786 struct bfd_link_info *link_info)
2788 Elf_Internal_Shdr *symtab_hdr;
2789 Elf_Internal_Rela *internal_relocs;
2790 Elf_Internal_Rela *irel, *irelend;
2792 struct elf_x86_64_link_hash_table *htab;
2793 bfd_boolean changed_contents;
2794 bfd_boolean changed_relocs;
2795 bfd_signed_vma *local_got_refcounts;
2797 /* Don't even try to convert non-ELF outputs. */
2798 if (!is_elf_hash_table (link_info->hash))
2801 /* Nothing to do if there are no codes, no relocations or no output. */
2802 if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
2803 || sec->reloc_count == 0
2804 || bfd_is_abs_section (sec->output_section))
2807 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2809 /* Load the relocations for this section. */
2810 internal_relocs = (_bfd_elf_link_read_relocs
2811 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
2812 link_info->keep_memory));
2813 if (internal_relocs == NULL)
2816 htab = elf_x86_64_hash_table (link_info);
2817 changed_contents = FALSE;
2818 changed_relocs = FALSE;
2819 local_got_refcounts = elf_local_got_refcounts (abfd);
2821 /* Get the section contents. */
2822 if (elf_section_data (sec)->this_hdr.contents != NULL)
2823 contents = elf_section_data (sec)->this_hdr.contents;
2826 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
2830 irelend = internal_relocs + sec->reloc_count;
2831 for (irel = internal_relocs; irel < irelend; irel++)
2833 unsigned int r_type = ELF32_R_TYPE (irel->r_info);
2834 unsigned int r_symndx = htab->r_sym (irel->r_info);
2836 struct elf_link_hash_entry *h;
2838 if (r_type != R_X86_64_GOTPCREL)
2841 /* Get the symbol referred to by the reloc. */
2842 if (r_symndx < symtab_hdr->sh_info)
2844 Elf_Internal_Sym *isym;
2846 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2849 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. */
2850 if (ELF_ST_TYPE (isym->st_info) != STT_GNU_IFUNC
2851 && bfd_get_8 (input_bfd,
2852 contents + irel->r_offset - 2) == 0x8b)
2854 bfd_put_8 (output_bfd, 0x8d,
2855 contents + irel->r_offset - 2);
2856 irel->r_info = htab->r_info (r_symndx, R_X86_64_PC32);
2857 if (local_got_refcounts != NULL
2858 && local_got_refcounts[r_symndx] > 0)
2859 local_got_refcounts[r_symndx] -= 1;
2860 changed_contents = TRUE;
2861 changed_relocs = TRUE;
2866 indx = r_symndx - symtab_hdr->sh_info;
2867 h = elf_sym_hashes (abfd)[indx];
2868 BFD_ASSERT (h != NULL);
2870 while (h->root.type == bfd_link_hash_indirect
2871 || h->root.type == bfd_link_hash_warning)
2872 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2874 /* STT_GNU_IFUNC must keep R_X86_64_GOTPCREL relocation. We also
2875 avoid optimizing _DYNAMIC since ld.so may use its link-time
2878 && h->type != STT_GNU_IFUNC
2879 && h != htab->elf.hdynamic
2880 && SYMBOL_REFERENCES_LOCAL (link_info, h)
2881 && bfd_get_8 (input_bfd,
2882 contents + irel->r_offset - 2) == 0x8b)
2884 bfd_put_8 (output_bfd, 0x8d,
2885 contents + irel->r_offset - 2);
2886 irel->r_info = htab->r_info (r_symndx, R_X86_64_PC32);
2887 if (h->got.refcount > 0)
2888 h->got.refcount -= 1;
2889 changed_contents = TRUE;
2890 changed_relocs = TRUE;
2894 if (contents != NULL
2895 && elf_section_data (sec)->this_hdr.contents != contents)
2897 if (!changed_contents && !link_info->keep_memory)
2901 /* Cache the section contents for elf_link_input_bfd. */
2902 elf_section_data (sec)->this_hdr.contents = contents;
2906 if (elf_section_data (sec)->relocs != internal_relocs)
2908 if (!changed_relocs)
2909 free (internal_relocs);
2911 elf_section_data (sec)->relocs = internal_relocs;
2917 if (contents != NULL
2918 && elf_section_data (sec)->this_hdr.contents != contents)
2920 if (internal_relocs != NULL
2921 && elf_section_data (sec)->relocs != internal_relocs)
2922 free (internal_relocs);
2926 /* Set the sizes of the dynamic sections. */
2929 elf_x86_64_size_dynamic_sections (bfd *output_bfd,
2930 struct bfd_link_info *info)
2932 struct elf_x86_64_link_hash_table *htab;
2937 const struct elf_backend_data *bed;
2939 htab = elf_x86_64_hash_table (info);
2942 bed = get_elf_backend_data (output_bfd);
2944 dynobj = htab->elf.dynobj;
2948 if (htab->elf.dynamic_sections_created)
2950 /* Set the contents of the .interp section to the interpreter. */
2951 if (info->executable)
2953 s = bfd_get_linker_section (dynobj, ".interp");
2956 s->size = htab->dynamic_interpreter_size;
2957 s->contents = (unsigned char *) htab->dynamic_interpreter;
2961 /* Set up .got offsets for local syms, and space for local dynamic
2963 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2965 bfd_signed_vma *local_got;
2966 bfd_signed_vma *end_local_got;
2967 char *local_tls_type;
2968 bfd_vma *local_tlsdesc_gotent;
2969 bfd_size_type locsymcount;
2970 Elf_Internal_Shdr *symtab_hdr;
2973 if (! is_x86_64_elf (ibfd))
2976 for (s = ibfd->sections; s != NULL; s = s->next)
2978 struct elf_dyn_relocs *p;
2980 if (!elf_x86_64_convert_mov_to_lea (ibfd, s, info))
2983 for (p = (struct elf_dyn_relocs *)
2984 (elf_section_data (s)->local_dynrel);
2988 if (!bfd_is_abs_section (p->sec)
2989 && bfd_is_abs_section (p->sec->output_section))
2991 /* Input section has been discarded, either because
2992 it is a copy of a linkonce section or due to
2993 linker script /DISCARD/, so we'll be discarding
2996 else if (p->count != 0)
2998 srel = elf_section_data (p->sec)->sreloc;
2999 srel->size += p->count * bed->s->sizeof_rela;
3000 if ((p->sec->output_section->flags & SEC_READONLY) != 0
3001 && (info->flags & DF_TEXTREL) == 0)
3003 info->flags |= DF_TEXTREL;
3004 if (info->warn_shared_textrel && info->shared)
3005 info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
3006 p->sec->owner, p->sec);
3012 local_got = elf_local_got_refcounts (ibfd);
3016 symtab_hdr = &elf_symtab_hdr (ibfd);
3017 locsymcount = symtab_hdr->sh_info;
3018 end_local_got = local_got + locsymcount;
3019 local_tls_type = elf_x86_64_local_got_tls_type (ibfd);
3020 local_tlsdesc_gotent = elf_x86_64_local_tlsdesc_gotent (ibfd);
3022 srel = htab->elf.srelgot;
3023 for (; local_got < end_local_got;
3024 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
3026 *local_tlsdesc_gotent = (bfd_vma) -1;
3029 if (GOT_TLS_GDESC_P (*local_tls_type))
3031 *local_tlsdesc_gotent = htab->elf.sgotplt->size
3032 - elf_x86_64_compute_jump_table_size (htab);
3033 htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
3034 *local_got = (bfd_vma) -2;
3036 if (! GOT_TLS_GDESC_P (*local_tls_type)
3037 || GOT_TLS_GD_P (*local_tls_type))
3039 *local_got = s->size;
3040 s->size += GOT_ENTRY_SIZE;
3041 if (GOT_TLS_GD_P (*local_tls_type))
3042 s->size += GOT_ENTRY_SIZE;
3045 || GOT_TLS_GD_ANY_P (*local_tls_type)
3046 || *local_tls_type == GOT_TLS_IE)
3048 if (GOT_TLS_GDESC_P (*local_tls_type))
3050 htab->elf.srelplt->size
3051 += bed->s->sizeof_rela;
3052 htab->tlsdesc_plt = (bfd_vma) -1;
3054 if (! GOT_TLS_GDESC_P (*local_tls_type)
3055 || GOT_TLS_GD_P (*local_tls_type))
3056 srel->size += bed->s->sizeof_rela;
3060 *local_got = (bfd_vma) -1;
3064 if (htab->tls_ld_got.refcount > 0)
3066 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3068 htab->tls_ld_got.offset = htab->elf.sgot->size;
3069 htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
3070 htab->elf.srelgot->size += bed->s->sizeof_rela;
3073 htab->tls_ld_got.offset = -1;
3075 /* Allocate global sym .plt and .got entries, and space for global
3076 sym dynamic relocs. */
3077 elf_link_hash_traverse (&htab->elf, elf_x86_64_allocate_dynrelocs,
3080 /* Allocate .plt and .got entries, and space for local symbols. */
3081 htab_traverse (htab->loc_hash_table,
3082 elf_x86_64_allocate_local_dynrelocs,
3085 /* For every jump slot reserved in the sgotplt, reloc_count is
3086 incremented. However, when we reserve space for TLS descriptors,
3087 it's not incremented, so in order to compute the space reserved
3088 for them, it suffices to multiply the reloc count by the jump
3091 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3092 so that R_X86_64_IRELATIVE entries come last. */
3093 if (htab->elf.srelplt)
3095 htab->sgotplt_jump_table_size
3096 = elf_x86_64_compute_jump_table_size (htab);
3097 htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
3099 else if (htab->elf.irelplt)
3100 htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
3102 if (htab->tlsdesc_plt)
3104 /* If we're not using lazy TLS relocations, don't generate the
3105 PLT and GOT entries they require. */
3106 if ((info->flags & DF_BIND_NOW))
3107 htab->tlsdesc_plt = 0;
3110 htab->tlsdesc_got = htab->elf.sgot->size;
3111 htab->elf.sgot->size += GOT_ENTRY_SIZE;
3112 /* Reserve room for the initial entry.
3113 FIXME: we could probably do away with it in this case. */
3114 if (htab->elf.splt->size == 0)
3115 htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd);
3116 htab->tlsdesc_plt = htab->elf.splt->size;
3117 htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd);
3121 if (htab->elf.sgotplt)
3123 /* Don't allocate .got.plt section if there are no GOT nor PLT
3124 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3125 if ((htab->elf.hgot == NULL
3126 || !htab->elf.hgot->ref_regular_nonweak)
3127 && (htab->elf.sgotplt->size
3128 == get_elf_backend_data (output_bfd)->got_header_size)
3129 && (htab->elf.splt == NULL
3130 || htab->elf.splt->size == 0)
3131 && (htab->elf.sgot == NULL
3132 || htab->elf.sgot->size == 0)
3133 && (htab->elf.iplt == NULL
3134 || htab->elf.iplt->size == 0)
3135 && (htab->elf.igotplt == NULL
3136 || htab->elf.igotplt->size == 0))
3137 htab->elf.sgotplt->size = 0;
3140 if (htab->plt_eh_frame != NULL
3141 && htab->elf.splt != NULL
3142 && htab->elf.splt->size != 0
3143 && !bfd_is_abs_section (htab->elf.splt->output_section)
3144 && _bfd_elf_eh_frame_present (info))
3146 const struct elf_x86_64_backend_data *arch_data
3147 = get_elf_x86_64_arch_data (bed);
3148 htab->plt_eh_frame->size = arch_data->eh_frame_plt_size;
3151 /* We now have determined the sizes of the various dynamic sections.
3152 Allocate memory for them. */
3154 for (s = dynobj->sections; s != NULL; s = s->next)
3156 if ((s->flags & SEC_LINKER_CREATED) == 0)
3159 if (s == htab->elf.splt
3160 || s == htab->elf.sgot
3161 || s == htab->elf.sgotplt
3162 || s == htab->elf.iplt
3163 || s == htab->elf.igotplt
3164 || s == htab->plt_bnd
3165 || s == htab->plt_eh_frame
3166 || s == htab->sdynbss)
3168 /* Strip this section if we don't need it; see the
3171 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
3173 if (s->size != 0 && s != htab->elf.srelplt)
3176 /* We use the reloc_count field as a counter if we need
3177 to copy relocs into the output file. */
3178 if (s != htab->elf.srelplt)
3183 /* It's not one of our sections, so don't allocate space. */
3189 /* If we don't need this section, strip it from the
3190 output file. This is mostly to handle .rela.bss and
3191 .rela.plt. We must create both sections in
3192 create_dynamic_sections, because they must be created
3193 before the linker maps input sections to output
3194 sections. The linker does that before
3195 adjust_dynamic_symbol is called, and it is that
3196 function which decides whether anything needs to go
3197 into these sections. */
3199 s->flags |= SEC_EXCLUDE;
3203 if ((s->flags & SEC_HAS_CONTENTS) == 0)
3206 /* Allocate memory for the section contents. We use bfd_zalloc
3207 here in case unused entries are not reclaimed before the
3208 section's contents are written out. This should not happen,
3209 but this way if it does, we get a R_X86_64_NONE reloc instead
3211 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3212 if (s->contents == NULL)
3216 if (htab->plt_eh_frame != NULL
3217 && htab->plt_eh_frame->contents != NULL)
3219 const struct elf_x86_64_backend_data *arch_data
3220 = get_elf_x86_64_arch_data (bed);
3222 memcpy (htab->plt_eh_frame->contents,
3223 arch_data->eh_frame_plt, htab->plt_eh_frame->size);
3224 bfd_put_32 (dynobj, htab->elf.splt->size,
3225 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
3228 if (htab->elf.dynamic_sections_created)
3230 /* Add some entries to the .dynamic section. We fill in the
3231 values later, in elf_x86_64_finish_dynamic_sections, but we
3232 must add the entries now so that we get the correct size for
3233 the .dynamic section. The DT_DEBUG entry is filled in by the
3234 dynamic linker and used by the debugger. */
3235 #define add_dynamic_entry(TAG, VAL) \
3236 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3238 if (info->executable)
3240 if (!add_dynamic_entry (DT_DEBUG, 0))
3244 if (htab->elf.splt->size != 0)
3246 if (!add_dynamic_entry (DT_PLTGOT, 0)
3247 || !add_dynamic_entry (DT_PLTRELSZ, 0)
3248 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3249 || !add_dynamic_entry (DT_JMPREL, 0))
3252 if (htab->tlsdesc_plt
3253 && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
3254 || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
3260 if (!add_dynamic_entry (DT_RELA, 0)
3261 || !add_dynamic_entry (DT_RELASZ, 0)
3262 || !add_dynamic_entry (DT_RELAENT, bed->s->sizeof_rela))
3265 /* If any dynamic relocs apply to a read-only section,
3266 then we need a DT_TEXTREL entry. */
3267 if ((info->flags & DF_TEXTREL) == 0)
3268 elf_link_hash_traverse (&htab->elf,
3269 elf_x86_64_readonly_dynrelocs,
3272 if ((info->flags & DF_TEXTREL) != 0)
3274 if (!add_dynamic_entry (DT_TEXTREL, 0))
3279 #undef add_dynamic_entry
3285 elf_x86_64_always_size_sections (bfd *output_bfd,
3286 struct bfd_link_info *info)
3288 asection *tls_sec = elf_hash_table (info)->tls_sec;
3292 struct elf_link_hash_entry *tlsbase;
3294 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
3295 "_TLS_MODULE_BASE_",
3296 FALSE, FALSE, FALSE);
3298 if (tlsbase && tlsbase->type == STT_TLS)
3300 struct elf_x86_64_link_hash_table *htab;
3301 struct bfd_link_hash_entry *bh = NULL;
3302 const struct elf_backend_data *bed
3303 = get_elf_backend_data (output_bfd);
3305 htab = elf_x86_64_hash_table (info);
3309 if (!(_bfd_generic_link_add_one_symbol
3310 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
3311 tls_sec, 0, NULL, FALSE,
3312 bed->collect, &bh)))
3315 htab->tls_module_base = bh;
3317 tlsbase = (struct elf_link_hash_entry *)bh;
3318 tlsbase->def_regular = 1;
3319 tlsbase->other = STV_HIDDEN;
3320 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
3327 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3328 executables. Rather than setting it to the beginning of the TLS
3329 section, we have to set it to the end. This function may be called
3330 multiple times, it is idempotent. */
3333 elf_x86_64_set_tls_module_base (struct bfd_link_info *info)
3335 struct elf_x86_64_link_hash_table *htab;
3336 struct bfd_link_hash_entry *base;
3338 if (!info->executable)
3341 htab = elf_x86_64_hash_table (info);
3345 base = htab->tls_module_base;
3349 base->u.def.value = htab->elf.tls_size;
3352 /* Return the base VMA address which should be subtracted from real addresses
3353 when resolving @dtpoff relocation.
3354 This is PT_TLS segment p_vaddr. */
3357 elf_x86_64_dtpoff_base (struct bfd_link_info *info)
3359 /* If tls_sec is NULL, we should have signalled an error already. */
3360 if (elf_hash_table (info)->tls_sec == NULL)
3362 return elf_hash_table (info)->tls_sec->vma;
3365 /* Return the relocation value for @tpoff relocation
3366 if STT_TLS virtual address is ADDRESS. */
3369 elf_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address)
3371 struct elf_link_hash_table *htab = elf_hash_table (info);
3372 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3373 bfd_vma static_tls_size;
3375 /* If tls_segment is NULL, we should have signalled an error already. */
3376 if (htab->tls_sec == NULL)
3379 /* Consider special static TLS alignment requirements. */
3380 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3381 return address - static_tls_size - htab->tls_sec->vma;
3384 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
3388 is_32bit_relative_branch (bfd_byte *contents, bfd_vma offset)
3390 /* Opcode Instruction
3393 0x0f 0x8x conditional jump */
3395 && (contents [offset - 1] == 0xe8
3396 || contents [offset - 1] == 0xe9))
3398 && contents [offset - 2] == 0x0f
3399 && (contents [offset - 1] & 0xf0) == 0x80));
3402 /* Relocate an x86_64 ELF section. */
3405 elf_x86_64_relocate_section (bfd *output_bfd,
3406 struct bfd_link_info *info,
3408 asection *input_section,
3410 Elf_Internal_Rela *relocs,
3411 Elf_Internal_Sym *local_syms,
3412 asection **local_sections)
3414 struct elf_x86_64_link_hash_table *htab;
3415 Elf_Internal_Shdr *symtab_hdr;
3416 struct elf_link_hash_entry **sym_hashes;
3417 bfd_vma *local_got_offsets;
3418 bfd_vma *local_tlsdesc_gotents;
3419 Elf_Internal_Rela *rel;
3420 Elf_Internal_Rela *relend;
3421 const unsigned int plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
3423 BFD_ASSERT (is_x86_64_elf (input_bfd));
3425 htab = elf_x86_64_hash_table (info);
3428 symtab_hdr = &elf_symtab_hdr (input_bfd);
3429 sym_hashes = elf_sym_hashes (input_bfd);
3430 local_got_offsets = elf_local_got_offsets (input_bfd);
3431 local_tlsdesc_gotents = elf_x86_64_local_tlsdesc_gotent (input_bfd);
3433 elf_x86_64_set_tls_module_base (info);
3436 relend = relocs + input_section->reloc_count;
3437 for (; rel < relend; rel++)
3439 unsigned int r_type;
3440 reloc_howto_type *howto;
3441 unsigned long r_symndx;
3442 struct elf_link_hash_entry *h;
3443 struct elf_x86_64_link_hash_entry *eh;
3444 Elf_Internal_Sym *sym;
3446 bfd_vma off, offplt, plt_offset;
3448 bfd_boolean unresolved_reloc;
3449 bfd_reloc_status_type r;
3451 asection *base_got, *resolved_plt;
3454 r_type = ELF32_R_TYPE (rel->r_info);
3455 if (r_type == (int) R_X86_64_GNU_VTINHERIT
3456 || r_type == (int) R_X86_64_GNU_VTENTRY)
3459 if (r_type >= (int) R_X86_64_standard)
3461 (*_bfd_error_handler)
3462 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3463 input_bfd, input_section, r_type);
3464 bfd_set_error (bfd_error_bad_value);
3468 if (r_type != (int) R_X86_64_32
3469 || ABI_64_P (output_bfd))
3470 howto = x86_64_elf_howto_table + r_type;
3472 howto = (x86_64_elf_howto_table
3473 + ARRAY_SIZE (x86_64_elf_howto_table) - 1);
3474 r_symndx = htab->r_sym (rel->r_info);
3478 unresolved_reloc = FALSE;
3479 if (r_symndx < symtab_hdr->sh_info)
3481 sym = local_syms + r_symndx;
3482 sec = local_sections[r_symndx];
3484 relocation = _bfd_elf_rela_local_sym (output_bfd, sym,
3486 st_size = sym->st_size;
3488 /* Relocate against local STT_GNU_IFUNC symbol. */
3489 if (!info->relocatable
3490 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3492 h = elf_x86_64_get_local_sym_hash (htab, input_bfd,
3497 /* Set STT_GNU_IFUNC symbol value. */
3498 h->root.u.def.value = sym->st_value;
3499 h->root.u.def.section = sec;
3504 bfd_boolean warned ATTRIBUTE_UNUSED;
3505 bfd_boolean ignored ATTRIBUTE_UNUSED;
3507 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3508 r_symndx, symtab_hdr, sym_hashes,
3510 unresolved_reloc, warned, ignored);
3514 if (sec != NULL && discarded_section (sec))
3515 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3516 rel, 1, relend, howto, 0, contents);
3518 if (info->relocatable)
3521 if (rel->r_addend == 0 && !ABI_64_P (output_bfd))
3523 if (r_type == R_X86_64_64)
3525 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
3526 zero-extend it to 64bit if addend is zero. */
3527 r_type = R_X86_64_32;
3528 memset (contents + rel->r_offset + 4, 0, 4);
3530 else if (r_type == R_X86_64_SIZE64)
3532 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
3533 zero-extend it to 64bit if addend is zero. */
3534 r_type = R_X86_64_SIZE32;
3535 memset (contents + rel->r_offset + 4, 0, 4);
3539 eh = (struct elf_x86_64_link_hash_entry *) h;
3541 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3542 it here if it is defined in a non-shared object. */
3544 && h->type == STT_GNU_IFUNC
3550 if ((input_section->flags & SEC_ALLOC) == 0
3551 || h->plt.offset == (bfd_vma) -1)
3554 /* STT_GNU_IFUNC symbol must go through PLT. */
3555 if (htab->elf.splt != NULL)
3557 if (htab->plt_bnd != NULL)
3559 resolved_plt = htab->plt_bnd;
3560 plt_offset = eh->plt_bnd.offset;
3564 resolved_plt = htab->elf.splt;
3565 plt_offset = h->plt.offset;
3570 resolved_plt = htab->elf.iplt;
3571 plt_offset = h->plt.offset;
3574 relocation = (resolved_plt->output_section->vma
3575 + resolved_plt->output_offset + plt_offset);
3580 if (h->root.root.string)
3581 name = h->root.root.string;
3583 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3585 (*_bfd_error_handler)
3586 (_("%B: relocation %s against STT_GNU_IFUNC "
3587 "symbol `%s' isn't handled by %s"), input_bfd,
3588 x86_64_elf_howto_table[r_type].name,
3589 name, __FUNCTION__);
3590 bfd_set_error (bfd_error_bad_value);
3599 if (ABI_64_P (output_bfd))
3603 if (rel->r_addend != 0)
3605 if (h->root.root.string)
3606 name = h->root.root.string;
3608 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
3610 (*_bfd_error_handler)
3611 (_("%B: relocation %s against STT_GNU_IFUNC "
3612 "symbol `%s' has non-zero addend: %d"),
3613 input_bfd, x86_64_elf_howto_table[r_type].name,
3614 name, rel->r_addend);
3615 bfd_set_error (bfd_error_bad_value);
3619 /* Generate dynamic relcoation only when there is a
3620 non-GOT reference in a shared object. */
3621 if (info->shared && h->non_got_ref)
3623 Elf_Internal_Rela outrel;
3626 /* Need a dynamic relocation to get the real function
3628 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
3632 if (outrel.r_offset == (bfd_vma) -1
3633 || outrel.r_offset == (bfd_vma) -2)
3636 outrel.r_offset += (input_section->output_section->vma
3637 + input_section->output_offset);
3639 if (h->dynindx == -1
3641 || info->executable)
3643 /* This symbol is resolved locally. */
3644 outrel.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
3645 outrel.r_addend = (h->root.u.def.value
3646 + h->root.u.def.section->output_section->vma
3647 + h->root.u.def.section->output_offset);
3651 outrel.r_info = htab->r_info (h->dynindx, r_type);
3652 outrel.r_addend = 0;
3655 sreloc = htab->elf.irelifunc;
3656 elf_append_rela (output_bfd, sreloc, &outrel);
3658 /* If this reloc is against an external symbol, we
3659 do not want to fiddle with the addend. Otherwise,
3660 we need to include the symbol value so that it
3661 becomes an addend for the dynamic reloc. For an
3662 internal symbol, we have updated addend. */
3667 case R_X86_64_PC32_BND:
3669 case R_X86_64_PLT32:
3670 case R_X86_64_PLT32_BND:
3673 case R_X86_64_GOTPCREL:
3674 case R_X86_64_GOTPCREL64:
3675 base_got = htab->elf.sgot;
3676 off = h->got.offset;
3678 if (base_got == NULL)
3681 if (off == (bfd_vma) -1)
3683 /* We can't use h->got.offset here to save state, or
3684 even just remember the offset, as finish_dynamic_symbol
3685 would use that as offset into .got. */
3687 if (htab->elf.splt != NULL)
3689 plt_index = h->plt.offset / plt_entry_size - 1;
3690 off = (plt_index + 3) * GOT_ENTRY_SIZE;
3691 base_got = htab->elf.sgotplt;
3695 plt_index = h->plt.offset / plt_entry_size;
3696 off = plt_index * GOT_ENTRY_SIZE;
3697 base_got = htab->elf.igotplt;
3700 if (h->dynindx == -1
3704 /* This references the local defitionion. We must
3705 initialize this entry in the global offset table.
3706 Since the offset must always be a multiple of 8,
3707 we use the least significant bit to record
3708 whether we have initialized it already.
3710 When doing a dynamic link, we create a .rela.got
3711 relocation entry to initialize the value. This
3712 is done in the finish_dynamic_symbol routine. */
3717 bfd_put_64 (output_bfd, relocation,
3718 base_got->contents + off);
3719 /* Note that this is harmless for the GOTPLT64
3720 case, as -1 | 1 still is -1. */
3726 relocation = (base_got->output_section->vma
3727 + base_got->output_offset + off);
3733 /* When generating a shared object, the relocations handled here are
3734 copied into the output file to be resolved at run time. */
3737 case R_X86_64_GOT32:
3738 case R_X86_64_GOT64:
3739 /* Relocation is to the entry for this symbol in the global
3741 case R_X86_64_GOTPCREL:
3742 case R_X86_64_GOTPCREL64:
3743 /* Use global offset table entry as symbol value. */
3744 case R_X86_64_GOTPLT64:
3745 /* This is the same as GOT64 for relocation purposes, but
3746 indicates the existence of a PLT entry. The difficulty is,
3747 that we must calculate the GOT slot offset from the PLT
3748 offset, if this symbol got a PLT entry (it was global).
3749 Additionally if it's computed from the PLT entry, then that
3750 GOT offset is relative to .got.plt, not to .got. */
3751 base_got = htab->elf.sgot;
3753 if (htab->elf.sgot == NULL)
3760 off = h->got.offset;
3762 && h->plt.offset != (bfd_vma)-1
3763 && off == (bfd_vma)-1)
3765 /* We can't use h->got.offset here to save
3766 state, or even just remember the offset, as
3767 finish_dynamic_symbol would use that as offset into
3769 bfd_vma plt_index = h->plt.offset / plt_entry_size - 1;
3770 off = (plt_index + 3) * GOT_ENTRY_SIZE;
3771 base_got = htab->elf.sgotplt;
3774 dyn = htab->elf.dynamic_sections_created;
3776 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3778 && SYMBOL_REFERENCES_LOCAL (info, h))
3779 || (ELF_ST_VISIBILITY (h->other)
3780 && h->root.type == bfd_link_hash_undefweak))
3782 /* This is actually a static link, or it is a -Bsymbolic
3783 link and the symbol is defined locally, or the symbol
3784 was forced to be local because of a version file. We
3785 must initialize this entry in the global offset table.
3786 Since the offset must always be a multiple of 8, we
3787 use the least significant bit to record whether we
3788 have initialized it already.
3790 When doing a dynamic link, we create a .rela.got
3791 relocation entry to initialize the value. This is
3792 done in the finish_dynamic_symbol routine. */
3797 bfd_put_64 (output_bfd, relocation,
3798 base_got->contents + off);
3799 /* Note that this is harmless for the GOTPLT64 case,
3800 as -1 | 1 still is -1. */
3805 unresolved_reloc = FALSE;
3809 if (local_got_offsets == NULL)
3812 off = local_got_offsets[r_symndx];
3814 /* The offset must always be a multiple of 8. We use
3815 the least significant bit to record whether we have
3816 already generated the necessary reloc. */
3821 bfd_put_64 (output_bfd, relocation,
3822 base_got->contents + off);
3827 Elf_Internal_Rela outrel;
3829 /* We need to generate a R_X86_64_RELATIVE reloc
3830 for the dynamic linker. */
3831 s = htab->elf.srelgot;
3835 outrel.r_offset = (base_got->output_section->vma
3836 + base_got->output_offset
3838 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
3839 outrel.r_addend = relocation;
3840 elf_append_rela (output_bfd, s, &outrel);
3843 local_got_offsets[r_symndx] |= 1;
3847 if (off >= (bfd_vma) -2)
3850 relocation = base_got->output_section->vma
3851 + base_got->output_offset + off;
3852 if (r_type != R_X86_64_GOTPCREL && r_type != R_X86_64_GOTPCREL64)
3853 relocation -= htab->elf.sgotplt->output_section->vma
3854 - htab->elf.sgotplt->output_offset;
3858 case R_X86_64_GOTOFF64:
3859 /* Relocation is relative to the start of the global offset
3862 /* Check to make sure it isn't a protected function symbol
3863 for shared library since it may not be local when used
3864 as function address. */
3865 if (!info->executable
3867 && !SYMBOLIC_BIND (info, h)
3869 && h->type == STT_FUNC
3870 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
3872 (*_bfd_error_handler)
3873 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
3874 input_bfd, h->root.root.string);
3875 bfd_set_error (bfd_error_bad_value);
3879 /* Note that sgot is not involved in this
3880 calculation. We always want the start of .got.plt. If we
3881 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3882 permitted by the ABI, we might have to change this
3884 relocation -= htab->elf.sgotplt->output_section->vma
3885 + htab->elf.sgotplt->output_offset;
3888 case R_X86_64_GOTPC32:
3889 case R_X86_64_GOTPC64:
3890 /* Use global offset table as symbol value. */
3891 relocation = htab->elf.sgotplt->output_section->vma
3892 + htab->elf.sgotplt->output_offset;
3893 unresolved_reloc = FALSE;
3896 case R_X86_64_PLTOFF64:
3897 /* Relocation is PLT entry relative to GOT. For local
3898 symbols it's the symbol itself relative to GOT. */
3900 /* See PLT32 handling. */
3901 && h->plt.offset != (bfd_vma) -1
3902 && htab->elf.splt != NULL)
3904 if (htab->plt_bnd != NULL)
3906 resolved_plt = htab->plt_bnd;
3907 plt_offset = eh->plt_bnd.offset;
3911 resolved_plt = htab->elf.splt;
3912 plt_offset = h->plt.offset;
3915 relocation = (resolved_plt->output_section->vma
3916 + resolved_plt->output_offset
3918 unresolved_reloc = FALSE;
3921 relocation -= htab->elf.sgotplt->output_section->vma
3922 + htab->elf.sgotplt->output_offset;
3925 case R_X86_64_PLT32:
3926 case R_X86_64_PLT32_BND:
3927 /* Relocation is to the entry for this symbol in the
3928 procedure linkage table. */
3930 /* Resolve a PLT32 reloc against a local symbol directly,
3931 without using the procedure linkage table. */
3935 if (h->plt.offset == (bfd_vma) -1
3936 || htab->elf.splt == NULL)
3938 /* We didn't make a PLT entry for this symbol. This
3939 happens when statically linking PIC code, or when
3940 using -Bsymbolic. */
3944 if (htab->plt_bnd != NULL)
3946 resolved_plt = htab->plt_bnd;
3947 plt_offset = eh->plt_bnd.offset;
3951 resolved_plt = htab->elf.splt;
3952 plt_offset = h->plt.offset;
3955 relocation = (resolved_plt->output_section->vma
3956 + resolved_plt->output_offset
3958 unresolved_reloc = FALSE;
3961 case R_X86_64_SIZE32:
3962 case R_X86_64_SIZE64:
3963 /* Set to symbol size. */
3964 relocation = st_size;
3970 case R_X86_64_PC32_BND:
3972 && (input_section->flags & SEC_ALLOC) != 0
3973 && (input_section->flags & SEC_READONLY) != 0
3976 bfd_boolean fail = FALSE;
3978 = ((r_type == R_X86_64_PC32
3979 || r_type == R_X86_64_PC32_BND)
3980 && is_32bit_relative_branch (contents, rel->r_offset));
3982 if (SYMBOL_REFERENCES_LOCAL (info, h))
3984 /* Symbol is referenced locally. Make sure it is
3985 defined locally or for a branch. */
3986 fail = !h->def_regular && !branch;
3988 else if (!(info->executable && h->needs_copy))
3990 /* Symbol doesn't need copy reloc and isn't referenced
3991 locally. We only allow branch to symbol with
3992 non-default visibility. */
3994 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT);
4001 const char *pic = "";
4003 switch (ELF_ST_VISIBILITY (h->other))
4006 v = _("hidden symbol");
4009 v = _("internal symbol");
4012 v = _("protected symbol");
4016 pic = _("; recompile with -fPIC");
4021 fmt = _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
4023 fmt = _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
4025 (*_bfd_error_handler) (fmt, input_bfd,
4026 x86_64_elf_howto_table[r_type].name,
4027 v, h->root.root.string, pic);
4028 bfd_set_error (bfd_error_bad_value);
4039 /* FIXME: The ABI says the linker should make sure the value is
4040 the same when it's zeroextended to 64 bit. */
4043 if ((input_section->flags & SEC_ALLOC) == 0)
4046 /* Don't copy a pc-relative relocation into the output file
4047 if the symbol needs copy reloc. */
4049 && !(info->executable
4052 && IS_X86_64_PCREL_TYPE (r_type))
4054 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4055 || h->root.type != bfd_link_hash_undefweak)
4056 && ((! IS_X86_64_PCREL_TYPE (r_type)
4057 && r_type != R_X86_64_SIZE32
4058 && r_type != R_X86_64_SIZE64)
4059 || ! SYMBOL_CALLS_LOCAL (info, h)))
4060 || (ELIMINATE_COPY_RELOCS
4067 || h->root.type == bfd_link_hash_undefweak
4068 || h->root.type == bfd_link_hash_undefined)))
4070 Elf_Internal_Rela outrel;
4071 bfd_boolean skip, relocate;
4074 /* When generating a shared object, these relocations
4075 are copied into the output file to be resolved at run
4081 _bfd_elf_section_offset (output_bfd, info, input_section,
4083 if (outrel.r_offset == (bfd_vma) -1)
4085 else if (outrel.r_offset == (bfd_vma) -2)
4086 skip = TRUE, relocate = TRUE;
4088 outrel.r_offset += (input_section->output_section->vma
4089 + input_section->output_offset);
4092 memset (&outrel, 0, sizeof outrel);
4094 /* h->dynindx may be -1 if this symbol was marked to
4098 && (IS_X86_64_PCREL_TYPE (r_type)
4100 || ! SYMBOLIC_BIND (info, h)
4101 || ! h->def_regular))
4103 outrel.r_info = htab->r_info (h->dynindx, r_type);
4104 outrel.r_addend = rel->r_addend;
4108 /* This symbol is local, or marked to become local. */
4109 if (r_type == htab->pointer_r_type)
4112 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
4113 outrel.r_addend = relocation + rel->r_addend;
4115 else if (r_type == R_X86_64_64
4116 && !ABI_64_P (output_bfd))
4119 outrel.r_info = htab->r_info (0,
4120 R_X86_64_RELATIVE64);
4121 outrel.r_addend = relocation + rel->r_addend;
4122 /* Check addend overflow. */
4123 if ((outrel.r_addend & 0x80000000)
4124 != (rel->r_addend & 0x80000000))
4127 int addend = rel->r_addend;
4128 if (h && h->root.root.string)
4129 name = h->root.root.string;
4131 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
4134 (*_bfd_error_handler)
4135 (_("%B: addend -0x%x in relocation %s against "
4136 "symbol `%s' at 0x%lx in section `%A' is "
4138 input_bfd, input_section, addend,
4139 x86_64_elf_howto_table[r_type].name,
4140 name, (unsigned long) rel->r_offset);
4142 (*_bfd_error_handler)
4143 (_("%B: addend 0x%x in relocation %s against "
4144 "symbol `%s' at 0x%lx in section `%A' is "
4146 input_bfd, input_section, addend,
4147 x86_64_elf_howto_table[r_type].name,
4148 name, (unsigned long) rel->r_offset);
4149 bfd_set_error (bfd_error_bad_value);
4157 if (bfd_is_abs_section (sec))
4159 else if (sec == NULL || sec->owner == NULL)
4161 bfd_set_error (bfd_error_bad_value);
4168 /* We are turning this relocation into one
4169 against a section symbol. It would be
4170 proper to subtract the symbol's value,
4171 osec->vma, from the emitted reloc addend,
4172 but ld.so expects buggy relocs. */
4173 osec = sec->output_section;
4174 sindx = elf_section_data (osec)->dynindx;
4177 asection *oi = htab->elf.text_index_section;
4178 sindx = elf_section_data (oi)->dynindx;
4180 BFD_ASSERT (sindx != 0);
4183 outrel.r_info = htab->r_info (sindx, r_type);
4184 outrel.r_addend = relocation + rel->r_addend;
4188 sreloc = elf_section_data (input_section)->sreloc;
4190 if (sreloc == NULL || sreloc->contents == NULL)
4192 r = bfd_reloc_notsupported;
4193 goto check_relocation_error;
4196 elf_append_rela (output_bfd, sreloc, &outrel);
4198 /* If this reloc is against an external symbol, we do
4199 not want to fiddle with the addend. Otherwise, we
4200 need to include the symbol value so that it becomes
4201 an addend for the dynamic reloc. */
4208 case R_X86_64_TLSGD:
4209 case R_X86_64_GOTPC32_TLSDESC:
4210 case R_X86_64_TLSDESC_CALL:
4211 case R_X86_64_GOTTPOFF:
4212 tls_type = GOT_UNKNOWN;
4213 if (h == NULL && local_got_offsets)
4214 tls_type = elf_x86_64_local_got_tls_type (input_bfd) [r_symndx];
4216 tls_type = elf_x86_64_hash_entry (h)->tls_type;
4218 if (! elf_x86_64_tls_transition (info, input_bfd,
4219 input_section, contents,
4220 symtab_hdr, sym_hashes,
4221 &r_type, tls_type, rel,
4222 relend, h, r_symndx))
4225 if (r_type == R_X86_64_TPOFF32)
4227 bfd_vma roff = rel->r_offset;
4229 BFD_ASSERT (! unresolved_reloc);
4231 if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
4233 /* GD->LE transition. For 64bit, change
4234 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4235 .word 0x6666; rex64; call __tls_get_addr
4238 leaq foo@tpoff(%rax), %rax
4240 leaq foo@tlsgd(%rip), %rdi
4241 .word 0x6666; rex64; call __tls_get_addr
4244 leaq foo@tpoff(%rax), %rax
4245 For largepic, change:
4246 leaq foo@tlsgd(%rip), %rdi
4247 movabsq $__tls_get_addr@pltoff, %rax
4252 leaq foo@tpoff(%rax), %rax
4253 nopw 0x0(%rax,%rax,1) */
4255 if (ABI_64_P (output_bfd)
4256 && contents[roff + 5] == (bfd_byte) '\xb8')
4258 memcpy (contents + roff - 3,
4259 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
4260 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4263 else if (ABI_64_P (output_bfd))
4264 memcpy (contents + roff - 4,
4265 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4268 memcpy (contents + roff - 3,
4269 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4271 bfd_put_32 (output_bfd,
4272 elf_x86_64_tpoff (info, relocation),
4273 contents + roff + 8 + largepic);
4274 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4278 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
4280 /* GDesc -> LE transition.
4281 It's originally something like:
4282 leaq x@tlsdesc(%rip), %rax
4285 movl $x@tpoff, %rax. */
4287 unsigned int val, type;
4289 type = bfd_get_8 (input_bfd, contents + roff - 3);
4290 val = bfd_get_8 (input_bfd, contents + roff - 1);
4291 bfd_put_8 (output_bfd, 0x48 | ((type >> 2) & 1),
4292 contents + roff - 3);
4293 bfd_put_8 (output_bfd, 0xc7, contents + roff - 2);
4294 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
4295 contents + roff - 1);
4296 bfd_put_32 (output_bfd,
4297 elf_x86_64_tpoff (info, relocation),
4301 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
4303 /* GDesc -> LE transition.
4308 bfd_put_8 (output_bfd, 0x66, contents + roff);
4309 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4312 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTTPOFF)
4314 /* IE->LE transition:
4315 For 64bit, originally it can be one of:
4316 movq foo@gottpoff(%rip), %reg
4317 addq foo@gottpoff(%rip), %reg
4320 leaq foo(%reg), %reg
4322 For 32bit, originally it can be one of:
4323 movq foo@gottpoff(%rip), %reg
4324 addl foo@gottpoff(%rip), %reg
4327 leal foo(%reg), %reg
4330 unsigned int val, type, reg;
4333 val = bfd_get_8 (input_bfd, contents + roff - 3);
4336 type = bfd_get_8 (input_bfd, contents + roff - 2);
4337 reg = bfd_get_8 (input_bfd, contents + roff - 1);
4343 bfd_put_8 (output_bfd, 0x49,
4344 contents + roff - 3);
4345 else if (!ABI_64_P (output_bfd) && val == 0x44)
4346 bfd_put_8 (output_bfd, 0x41,
4347 contents + roff - 3);
4348 bfd_put_8 (output_bfd, 0xc7,
4349 contents + roff - 2);
4350 bfd_put_8 (output_bfd, 0xc0 | reg,
4351 contents + roff - 1);
4355 /* addq/addl -> addq/addl - addressing with %rsp/%r12
4358 bfd_put_8 (output_bfd, 0x49,
4359 contents + roff - 3);
4360 else if (!ABI_64_P (output_bfd) && val == 0x44)
4361 bfd_put_8 (output_bfd, 0x41,
4362 contents + roff - 3);
4363 bfd_put_8 (output_bfd, 0x81,
4364 contents + roff - 2);
4365 bfd_put_8 (output_bfd, 0xc0 | reg,
4366 contents + roff - 1);
4370 /* addq/addl -> leaq/leal */
4372 bfd_put_8 (output_bfd, 0x4d,
4373 contents + roff - 3);
4374 else if (!ABI_64_P (output_bfd) && val == 0x44)
4375 bfd_put_8 (output_bfd, 0x45,
4376 contents + roff - 3);
4377 bfd_put_8 (output_bfd, 0x8d,
4378 contents + roff - 2);
4379 bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
4380 contents + roff - 1);
4382 bfd_put_32 (output_bfd,
4383 elf_x86_64_tpoff (info, relocation),
4391 if (htab->elf.sgot == NULL)
4396 off = h->got.offset;
4397 offplt = elf_x86_64_hash_entry (h)->tlsdesc_got;
4401 if (local_got_offsets == NULL)
4404 off = local_got_offsets[r_symndx];
4405 offplt = local_tlsdesc_gotents[r_symndx];
4412 Elf_Internal_Rela outrel;
4416 if (htab->elf.srelgot == NULL)
4419 indx = h && h->dynindx != -1 ? h->dynindx : 0;
4421 if (GOT_TLS_GDESC_P (tls_type))
4423 outrel.r_info = htab->r_info (indx, R_X86_64_TLSDESC);
4424 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt
4425 + 2 * GOT_ENTRY_SIZE <= htab->elf.sgotplt->size);
4426 outrel.r_offset = (htab->elf.sgotplt->output_section->vma
4427 + htab->elf.sgotplt->output_offset
4429 + htab->sgotplt_jump_table_size);
4430 sreloc = htab->elf.srelplt;
4432 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
4434 outrel.r_addend = 0;
4435 elf_append_rela (output_bfd, sreloc, &outrel);
4438 sreloc = htab->elf.srelgot;
4440 outrel.r_offset = (htab->elf.sgot->output_section->vma
4441 + htab->elf.sgot->output_offset + off);
4443 if (GOT_TLS_GD_P (tls_type))
4444 dr_type = R_X86_64_DTPMOD64;
4445 else if (GOT_TLS_GDESC_P (tls_type))
4448 dr_type = R_X86_64_TPOFF64;
4450 bfd_put_64 (output_bfd, 0, htab->elf.sgot->contents + off);
4451 outrel.r_addend = 0;
4452 if ((dr_type == R_X86_64_TPOFF64
4453 || dr_type == R_X86_64_TLSDESC) && indx == 0)
4454 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
4455 outrel.r_info = htab->r_info (indx, dr_type);
4457 elf_append_rela (output_bfd, sreloc, &outrel);
4459 if (GOT_TLS_GD_P (tls_type))
4463 BFD_ASSERT (! unresolved_reloc);
4464 bfd_put_64 (output_bfd,
4465 relocation - elf_x86_64_dtpoff_base (info),
4466 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4470 bfd_put_64 (output_bfd, 0,
4471 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4472 outrel.r_info = htab->r_info (indx,
4474 outrel.r_offset += GOT_ENTRY_SIZE;
4475 elf_append_rela (output_bfd, sreloc,
4484 local_got_offsets[r_symndx] |= 1;
4487 if (off >= (bfd_vma) -2
4488 && ! GOT_TLS_GDESC_P (tls_type))
4490 if (r_type == ELF32_R_TYPE (rel->r_info))
4492 if (r_type == R_X86_64_GOTPC32_TLSDESC
4493 || r_type == R_X86_64_TLSDESC_CALL)
4494 relocation = htab->elf.sgotplt->output_section->vma
4495 + htab->elf.sgotplt->output_offset
4496 + offplt + htab->sgotplt_jump_table_size;
4498 relocation = htab->elf.sgot->output_section->vma
4499 + htab->elf.sgot->output_offset + off;
4500 unresolved_reloc = FALSE;
4504 bfd_vma roff = rel->r_offset;
4506 if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
4508 /* GD->IE transition. For 64bit, change
4509 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4510 .word 0x6666; rex64; call __tls_get_addr@plt
4513 addq foo@gottpoff(%rip), %rax
4515 leaq foo@tlsgd(%rip), %rdi
4516 .word 0x6666; rex64; call __tls_get_addr@plt
4519 addq foo@gottpoff(%rip), %rax
4520 For largepic, change:
4521 leaq foo@tlsgd(%rip), %rdi
4522 movabsq $__tls_get_addr@pltoff, %rax
4527 addq foo@gottpoff(%rax), %rax
4528 nopw 0x0(%rax,%rax,1) */
4530 if (ABI_64_P (output_bfd)
4531 && contents[roff + 5] == (bfd_byte) '\xb8')
4533 memcpy (contents + roff - 3,
4534 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
4535 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4538 else if (ABI_64_P (output_bfd))
4539 memcpy (contents + roff - 4,
4540 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4543 memcpy (contents + roff - 3,
4544 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4547 relocation = (htab->elf.sgot->output_section->vma
4548 + htab->elf.sgot->output_offset + off
4551 - input_section->output_section->vma
4552 - input_section->output_offset
4554 bfd_put_32 (output_bfd, relocation,
4555 contents + roff + 8 + largepic);
4556 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4560 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
4562 /* GDesc -> IE transition.
4563 It's originally something like:
4564 leaq x@tlsdesc(%rip), %rax
4567 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
4569 /* Now modify the instruction as appropriate. To
4570 turn a leaq into a movq in the form we use it, it
4571 suffices to change the second byte from 0x8d to
4573 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4575 bfd_put_32 (output_bfd,
4576 htab->elf.sgot->output_section->vma
4577 + htab->elf.sgot->output_offset + off
4579 - input_section->output_section->vma
4580 - input_section->output_offset
4585 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
4587 /* GDesc -> IE transition.
4594 bfd_put_8 (output_bfd, 0x66, contents + roff);
4595 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4603 case R_X86_64_TLSLD:
4604 if (! elf_x86_64_tls_transition (info, input_bfd,
4605 input_section, contents,
4606 symtab_hdr, sym_hashes,
4607 &r_type, GOT_UNKNOWN,
4608 rel, relend, h, r_symndx))
4611 if (r_type != R_X86_64_TLSLD)
4613 /* LD->LE transition:
4614 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
4615 For 64bit, we change it into:
4616 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
4617 For 32bit, we change it into:
4618 nopl 0x0(%rax); movl %fs:0, %eax.
4619 For largepic, change:
4620 leaq foo@tlsgd(%rip), %rdi
4621 movabsq $__tls_get_addr@pltoff, %rax
4625 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
4628 BFD_ASSERT (r_type == R_X86_64_TPOFF32);
4629 if (ABI_64_P (output_bfd)
4630 && contents[rel->r_offset + 5] == (bfd_byte) '\xb8')
4631 memcpy (contents + rel->r_offset - 3,
4632 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
4633 "\x64\x48\x8b\x04\x25\0\0\0", 22);
4634 else if (ABI_64_P (output_bfd))
4635 memcpy (contents + rel->r_offset - 3,
4636 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
4638 memcpy (contents + rel->r_offset - 3,
4639 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
4640 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4645 if (htab->elf.sgot == NULL)
4648 off = htab->tls_ld_got.offset;
4653 Elf_Internal_Rela outrel;
4655 if (htab->elf.srelgot == NULL)
4658 outrel.r_offset = (htab->elf.sgot->output_section->vma
4659 + htab->elf.sgot->output_offset + off);
4661 bfd_put_64 (output_bfd, 0,
4662 htab->elf.sgot->contents + off);
4663 bfd_put_64 (output_bfd, 0,
4664 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4665 outrel.r_info = htab->r_info (0, R_X86_64_DTPMOD64);
4666 outrel.r_addend = 0;
4667 elf_append_rela (output_bfd, htab->elf.srelgot,
4669 htab->tls_ld_got.offset |= 1;
4671 relocation = htab->elf.sgot->output_section->vma
4672 + htab->elf.sgot->output_offset + off;
4673 unresolved_reloc = FALSE;
4676 case R_X86_64_DTPOFF32:
4677 if (!info->executable|| (input_section->flags & SEC_CODE) == 0)
4678 relocation -= elf_x86_64_dtpoff_base (info);
4680 relocation = elf_x86_64_tpoff (info, relocation);
4683 case R_X86_64_TPOFF32:
4684 case R_X86_64_TPOFF64:
4685 BFD_ASSERT (info->executable);
4686 relocation = elf_x86_64_tpoff (info, relocation);
4689 case R_X86_64_DTPOFF64:
4690 BFD_ASSERT ((input_section->flags & SEC_CODE) == 0);
4691 relocation -= elf_x86_64_dtpoff_base (info);
4698 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4699 because such sections are not SEC_ALLOC and thus ld.so will
4700 not process them. */
4701 if (unresolved_reloc
4702 && !((input_section->flags & SEC_DEBUGGING) != 0
4704 && _bfd_elf_section_offset (output_bfd, info, input_section,
4705 rel->r_offset) != (bfd_vma) -1)
4707 (*_bfd_error_handler)
4708 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4711 (long) rel->r_offset,
4713 h->root.root.string);
4718 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4719 contents, rel->r_offset,
4720 relocation, rel->r_addend);
4722 check_relocation_error:
4723 if (r != bfd_reloc_ok)
4728 name = h->root.root.string;
4731 name = bfd_elf_string_from_elf_section (input_bfd,
4732 symtab_hdr->sh_link,
4737 name = bfd_section_name (input_bfd, sec);
4740 if (r == bfd_reloc_overflow)
4742 if (! ((*info->callbacks->reloc_overflow)
4743 (info, (h ? &h->root : NULL), name, howto->name,
4744 (bfd_vma) 0, input_bfd, input_section,
4750 (*_bfd_error_handler)
4751 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4752 input_bfd, input_section,
4753 (long) rel->r_offset, name, (int) r);
4762 /* Finish up dynamic symbol handling. We set the contents of various
4763 dynamic sections here. */
4766 elf_x86_64_finish_dynamic_symbol (bfd *output_bfd,
4767 struct bfd_link_info *info,
4768 struct elf_link_hash_entry *h,
4769 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
4771 struct elf_x86_64_link_hash_table *htab;
4772 const struct elf_x86_64_backend_data *abed;
4773 bfd_boolean use_plt_bnd;
4775 htab = elf_x86_64_hash_table (info);
4779 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
4780 section only if there is .plt section. */
4781 use_plt_bnd = htab->elf.splt != NULL && htab->plt_bnd != NULL;
4783 ? &elf_x86_64_bnd_arch_bed
4784 : get_elf_x86_64_backend_data (output_bfd));
4786 if (h->plt.offset != (bfd_vma) -1)
4789 bfd_vma got_offset, plt_offset, plt_plt_offset, plt_got_offset;
4790 bfd_vma plt_plt_insn_end, plt_got_insn_size;
4791 Elf_Internal_Rela rela;
4793 asection *plt, *gotplt, *relplt, *resolved_plt;
4794 const struct elf_backend_data *bed;
4796 /* When building a static executable, use .iplt, .igot.plt and
4797 .rela.iplt sections for STT_GNU_IFUNC symbols. */
4798 if (htab->elf.splt != NULL)
4800 plt = htab->elf.splt;
4801 gotplt = htab->elf.sgotplt;
4802 relplt = htab->elf.srelplt;
4806 plt = htab->elf.iplt;
4807 gotplt = htab->elf.igotplt;
4808 relplt = htab->elf.irelplt;
4811 /* This symbol has an entry in the procedure linkage table. Set
4813 if ((h->dynindx == -1
4814 && !((h->forced_local || info->executable)
4816 && h->type == STT_GNU_IFUNC))
4822 /* Get the index in the procedure linkage table which
4823 corresponds to this symbol. This is the index of this symbol
4824 in all the symbols for which we are making plt entries. The
4825 first entry in the procedure linkage table is reserved.
4827 Get the offset into the .got table of the entry that
4828 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
4829 bytes. The first three are reserved for the dynamic linker.
4831 For static executables, we don't reserve anything. */
4833 if (plt == htab->elf.splt)
4835 got_offset = h->plt.offset / abed->plt_entry_size - 1;
4836 got_offset = (got_offset + 3) * GOT_ENTRY_SIZE;
4840 got_offset = h->plt.offset / abed->plt_entry_size;
4841 got_offset = got_offset * GOT_ENTRY_SIZE;
4844 plt_plt_insn_end = abed->plt_plt_insn_end;
4845 plt_plt_offset = abed->plt_plt_offset;
4846 plt_got_insn_size = abed->plt_got_insn_size;
4847 plt_got_offset = abed->plt_got_offset;
4850 /* Use the second PLT with BND relocations. */
4851 const bfd_byte *plt_entry, *plt2_entry;
4852 struct elf_x86_64_link_hash_entry *eh
4853 = (struct elf_x86_64_link_hash_entry *) h;
4855 if (eh->has_bnd_reloc)
4857 plt_entry = elf_x86_64_bnd_plt_entry;
4858 plt2_entry = elf_x86_64_bnd_plt2_entry;
4862 plt_entry = elf_x86_64_legacy_plt_entry;
4863 plt2_entry = elf_x86_64_legacy_plt2_entry;
4865 /* Subtract 1 since there is no BND prefix. */
4866 plt_plt_insn_end -= 1;
4867 plt_plt_offset -= 1;
4868 plt_got_insn_size -= 1;
4869 plt_got_offset -= 1;
4872 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry)
4873 == sizeof (elf_x86_64_legacy_plt_entry));
4875 /* Fill in the entry in the procedure linkage table. */
4876 memcpy (plt->contents + h->plt.offset,
4877 plt_entry, sizeof (elf_x86_64_legacy_plt_entry));
4878 /* Fill in the entry in the second PLT. */
4879 memcpy (htab->plt_bnd->contents + eh->plt_bnd.offset,
4880 plt2_entry, sizeof (elf_x86_64_legacy_plt2_entry));
4882 resolved_plt = htab->plt_bnd;
4883 plt_offset = eh->plt_bnd.offset;
4887 /* Fill in the entry in the procedure linkage table. */
4888 memcpy (plt->contents + h->plt.offset, abed->plt_entry,
4889 abed->plt_entry_size);
4892 plt_offset = h->plt.offset;
4895 /* Insert the relocation positions of the plt section. */
4897 /* Put offset the PC-relative instruction referring to the GOT entry,
4898 subtracting the size of that instruction. */
4899 bfd_put_32 (output_bfd,
4900 (gotplt->output_section->vma
4901 + gotplt->output_offset
4903 - resolved_plt->output_section->vma
4904 - resolved_plt->output_offset
4906 - plt_got_insn_size),
4907 resolved_plt->contents + plt_offset + plt_got_offset);
4909 /* Fill in the entry in the global offset table, initially this
4910 points to the second part of the PLT entry. */
4911 bfd_put_64 (output_bfd, (plt->output_section->vma
4912 + plt->output_offset
4913 + h->plt.offset + abed->plt_lazy_offset),
4914 gotplt->contents + got_offset);
4916 /* Fill in the entry in the .rela.plt section. */
4917 rela.r_offset = (gotplt->output_section->vma
4918 + gotplt->output_offset
4920 if (h->dynindx == -1
4921 || ((info->executable
4922 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4924 && h->type == STT_GNU_IFUNC))
4926 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4927 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
4928 rela.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
4929 rela.r_addend = (h->root.u.def.value
4930 + h->root.u.def.section->output_section->vma
4931 + h->root.u.def.section->output_offset);
4932 /* R_X86_64_IRELATIVE comes last. */
4933 plt_index = htab->next_irelative_index--;
4937 rela.r_info = htab->r_info (h->dynindx, R_X86_64_JUMP_SLOT);
4939 plt_index = htab->next_jump_slot_index++;
4942 /* Don't fill PLT entry for static executables. */
4943 if (plt == htab->elf.splt)
4945 /* Put relocation index. */
4946 bfd_put_32 (output_bfd, plt_index,
4947 plt->contents + h->plt.offset + abed->plt_reloc_offset);
4948 /* Put offset for jmp .PLT0. */
4949 bfd_put_32 (output_bfd, - (h->plt.offset + plt_plt_insn_end),
4950 plt->contents + h->plt.offset + plt_plt_offset);
4953 bed = get_elf_backend_data (output_bfd);
4954 loc = relplt->contents + plt_index * bed->s->sizeof_rela;
4955 bed->s->swap_reloca_out (output_bfd, &rela, loc);
4957 if (!h->def_regular)
4959 /* Mark the symbol as undefined, rather than as defined in
4960 the .plt section. Leave the value if there were any
4961 relocations where pointer equality matters (this is a clue
4962 for the dynamic linker, to make function pointer
4963 comparisons work between an application and shared
4964 library), otherwise set it to zero. If a function is only
4965 called from a binary, there is no need to slow down
4966 shared libraries because of that. */
4967 sym->st_shndx = SHN_UNDEF;
4968 if (!h->pointer_equality_needed)
4973 if (h->got.offset != (bfd_vma) -1
4974 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h)->tls_type)
4975 && elf_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE)
4977 Elf_Internal_Rela rela;
4979 /* This symbol has an entry in the global offset table. Set it
4981 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
4984 rela.r_offset = (htab->elf.sgot->output_section->vma
4985 + htab->elf.sgot->output_offset
4986 + (h->got.offset &~ (bfd_vma) 1));
4988 /* If this is a static link, or it is a -Bsymbolic link and the
4989 symbol is defined locally or was forced to be local because
4990 of a version file, we just want to emit a RELATIVE reloc.
4991 The entry in the global offset table will already have been
4992 initialized in the relocate_section function. */
4994 && h->type == STT_GNU_IFUNC)
4998 /* Generate R_X86_64_GLOB_DAT. */
5005 if (!h->pointer_equality_needed)
5008 /* For non-shared object, we can't use .got.plt, which
5009 contains the real function addres if we need pointer
5010 equality. We load the GOT entry with the PLT entry. */
5011 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
5012 bfd_put_64 (output_bfd, (plt->output_section->vma
5013 + plt->output_offset
5015 htab->elf.sgot->contents + h->got.offset);
5019 else if (info->shared
5020 && SYMBOL_REFERENCES_LOCAL (info, h))
5022 if (!h->def_regular)
5024 BFD_ASSERT((h->got.offset & 1) != 0);
5025 rela.r_info = htab->r_info (0, R_X86_64_RELATIVE);
5026 rela.r_addend = (h->root.u.def.value
5027 + h->root.u.def.section->output_section->vma
5028 + h->root.u.def.section->output_offset);
5032 BFD_ASSERT((h->got.offset & 1) == 0);
5034 bfd_put_64 (output_bfd, (bfd_vma) 0,
5035 htab->elf.sgot->contents + h->got.offset);
5036 rela.r_info = htab->r_info (h->dynindx, R_X86_64_GLOB_DAT);
5040 elf_append_rela (output_bfd, htab->elf.srelgot, &rela);
5045 Elf_Internal_Rela rela;
5047 /* This symbol needs a copy reloc. Set it up. */
5049 if (h->dynindx == -1
5050 || (h->root.type != bfd_link_hash_defined
5051 && h->root.type != bfd_link_hash_defweak)
5052 || htab->srelbss == NULL)
5055 rela.r_offset = (h->root.u.def.value
5056 + h->root.u.def.section->output_section->vma
5057 + h->root.u.def.section->output_offset);
5058 rela.r_info = htab->r_info (h->dynindx, R_X86_64_COPY);
5060 elf_append_rela (output_bfd, htab->srelbss, &rela);
5066 /* Finish up local dynamic symbol handling. We set the contents of
5067 various dynamic sections here. */
5070 elf_x86_64_finish_local_dynamic_symbol (void **slot, void *inf)
5072 struct elf_link_hash_entry *h
5073 = (struct elf_link_hash_entry *) *slot;
5074 struct bfd_link_info *info
5075 = (struct bfd_link_info *) inf;
5077 return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
5081 /* Used to decide how to sort relocs in an optimal manner for the
5082 dynamic linker, before writing them out. */
5084 static enum elf_reloc_type_class
5085 elf_x86_64_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
5086 const asection *rel_sec ATTRIBUTE_UNUSED,
5087 const Elf_Internal_Rela *rela)
5089 switch ((int) ELF32_R_TYPE (rela->r_info))
5091 case R_X86_64_RELATIVE:
5092 case R_X86_64_RELATIVE64:
5093 return reloc_class_relative;
5094 case R_X86_64_JUMP_SLOT:
5095 return reloc_class_plt;
5097 return reloc_class_copy;
5099 return reloc_class_normal;
5103 /* Finish up the dynamic sections. */
5106 elf_x86_64_finish_dynamic_sections (bfd *output_bfd,
5107 struct bfd_link_info *info)
5109 struct elf_x86_64_link_hash_table *htab;
5112 const struct elf_x86_64_backend_data *abed;
5114 htab = elf_x86_64_hash_table (info);
5118 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5119 section only if there is .plt section. */
5120 abed = (htab->elf.splt != NULL && htab->plt_bnd != NULL
5121 ? &elf_x86_64_bnd_arch_bed
5122 : get_elf_x86_64_backend_data (output_bfd));
5124 dynobj = htab->elf.dynobj;
5125 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
5127 if (htab->elf.dynamic_sections_created)
5129 bfd_byte *dyncon, *dynconend;
5130 const struct elf_backend_data *bed;
5131 bfd_size_type sizeof_dyn;
5133 if (sdyn == NULL || htab->elf.sgot == NULL)
5136 bed = get_elf_backend_data (dynobj);
5137 sizeof_dyn = bed->s->sizeof_dyn;
5138 dyncon = sdyn->contents;
5139 dynconend = sdyn->contents + sdyn->size;
5140 for (; dyncon < dynconend; dyncon += sizeof_dyn)
5142 Elf_Internal_Dyn dyn;
5145 (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
5153 s = htab->elf.sgotplt;
5154 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5158 dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
5162 s = htab->elf.srelplt->output_section;
5163 dyn.d_un.d_val = s->size;
5167 /* The procedure linkage table relocs (DT_JMPREL) should
5168 not be included in the overall relocs (DT_RELA).
5169 Therefore, we override the DT_RELASZ entry here to
5170 make it not include the JMPREL relocs. Since the
5171 linker script arranges for .rela.plt to follow all
5172 other relocation sections, we don't have to worry
5173 about changing the DT_RELA entry. */
5174 if (htab->elf.srelplt != NULL)
5176 s = htab->elf.srelplt->output_section;
5177 dyn.d_un.d_val -= s->size;
5181 case DT_TLSDESC_PLT:
5183 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
5184 + htab->tlsdesc_plt;
5187 case DT_TLSDESC_GOT:
5189 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
5190 + htab->tlsdesc_got;
5194 (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
5197 /* Fill in the special first entry in the procedure linkage table. */
5198 if (htab->elf.splt && htab->elf.splt->size > 0)
5200 /* Fill in the first entry in the procedure linkage table. */
5201 memcpy (htab->elf.splt->contents,
5202 abed->plt0_entry, abed->plt_entry_size);
5203 /* Add offset for pushq GOT+8(%rip), since the instruction
5204 uses 6 bytes subtract this value. */
5205 bfd_put_32 (output_bfd,
5206 (htab->elf.sgotplt->output_section->vma
5207 + htab->elf.sgotplt->output_offset
5209 - htab->elf.splt->output_section->vma
5210 - htab->elf.splt->output_offset
5212 htab->elf.splt->contents + abed->plt0_got1_offset);
5213 /* Add offset for the PC-relative instruction accessing GOT+16,
5214 subtracting the offset to the end of that instruction. */
5215 bfd_put_32 (output_bfd,
5216 (htab->elf.sgotplt->output_section->vma
5217 + htab->elf.sgotplt->output_offset
5219 - htab->elf.splt->output_section->vma
5220 - htab->elf.splt->output_offset
5221 - abed->plt0_got2_insn_end),
5222 htab->elf.splt->contents + abed->plt0_got2_offset);
5224 elf_section_data (htab->elf.splt->output_section)
5225 ->this_hdr.sh_entsize = abed->plt_entry_size;
5227 if (htab->tlsdesc_plt)
5229 bfd_put_64 (output_bfd, (bfd_vma) 0,
5230 htab->elf.sgot->contents + htab->tlsdesc_got);
5232 memcpy (htab->elf.splt->contents + htab->tlsdesc_plt,
5233 abed->plt0_entry, abed->plt_entry_size);
5235 /* Add offset for pushq GOT+8(%rip), since the
5236 instruction uses 6 bytes subtract this value. */
5237 bfd_put_32 (output_bfd,
5238 (htab->elf.sgotplt->output_section->vma
5239 + htab->elf.sgotplt->output_offset
5241 - htab->elf.splt->output_section->vma
5242 - htab->elf.splt->output_offset
5245 htab->elf.splt->contents
5246 + htab->tlsdesc_plt + abed->plt0_got1_offset);
5247 /* Add offset for the PC-relative instruction accessing GOT+TDG,
5248 where TGD stands for htab->tlsdesc_got, subtracting the offset
5249 to the end of that instruction. */
5250 bfd_put_32 (output_bfd,
5251 (htab->elf.sgot->output_section->vma
5252 + htab->elf.sgot->output_offset
5254 - htab->elf.splt->output_section->vma
5255 - htab->elf.splt->output_offset
5257 - abed->plt0_got2_insn_end),
5258 htab->elf.splt->contents
5259 + htab->tlsdesc_plt + abed->plt0_got2_offset);
5264 if (htab->plt_bnd != NULL)
5265 elf_section_data (htab->plt_bnd->output_section)
5266 ->this_hdr.sh_entsize = sizeof (elf_x86_64_bnd_plt2_entry);
5268 if (htab->elf.sgotplt)
5270 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
5272 (*_bfd_error_handler)
5273 (_("discarded output section: `%A'"), htab->elf.sgotplt);
5277 /* Fill in the first three entries in the global offset table. */
5278 if (htab->elf.sgotplt->size > 0)
5280 /* Set the first entry in the global offset table to the address of
5281 the dynamic section. */
5283 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents);
5285 bfd_put_64 (output_bfd,
5286 sdyn->output_section->vma + sdyn->output_offset,
5287 htab->elf.sgotplt->contents);
5288 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
5289 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
5290 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE*2);
5293 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize =
5297 /* Adjust .eh_frame for .plt section. */
5298 if (htab->plt_eh_frame != NULL
5299 && htab->plt_eh_frame->contents != NULL)
5301 if (htab->elf.splt != NULL
5302 && htab->elf.splt->size != 0
5303 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
5304 && htab->elf.splt->output_section != NULL
5305 && htab->plt_eh_frame->output_section != NULL)
5307 bfd_vma plt_start = htab->elf.splt->output_section->vma;
5308 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
5309 + htab->plt_eh_frame->output_offset
5310 + PLT_FDE_START_OFFSET;
5311 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
5312 htab->plt_eh_frame->contents
5313 + PLT_FDE_START_OFFSET);
5315 if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
5317 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
5319 htab->plt_eh_frame->contents))
5324 if (htab->elf.sgot && htab->elf.sgot->size > 0)
5325 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
5328 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5329 htab_traverse (htab->loc_hash_table,
5330 elf_x86_64_finish_local_dynamic_symbol,
5336 /* Return an array of PLT entry symbol values. */
5339 elf_x86_64_get_plt_sym_val (bfd *abfd, asymbol **dynsyms, asection *plt,
5342 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
5345 bfd_vma *plt_sym_val;
5347 bfd_byte *plt_contents;
5348 const struct elf_x86_64_backend_data *bed;
5349 Elf_Internal_Shdr *hdr;
5352 /* Get the .plt section contents. PLT passed down may point to the
5353 .plt.bnd section. Make sure that PLT always points to the .plt
5355 plt_bnd = bfd_get_section_by_name (abfd, ".plt.bnd");
5360 plt = bfd_get_section_by_name (abfd, ".plt");
5363 bed = &elf_x86_64_bnd_arch_bed;
5366 bed = get_elf_x86_64_backend_data (abfd);
5368 plt_contents = (bfd_byte *) bfd_malloc (plt->size);
5369 if (plt_contents == NULL)
5371 if (!bfd_get_section_contents (abfd, (asection *) plt,
5372 plt_contents, 0, plt->size))
5375 free (plt_contents);
5379 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
5380 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
5383 hdr = &elf_section_data (relplt)->this_hdr;
5384 count = relplt->size / hdr->sh_entsize;
5386 plt_sym_val = (bfd_vma *) bfd_malloc (sizeof (bfd_vma) * count);
5387 if (plt_sym_val == NULL)
5390 for (i = 0; i < count; i++, p++)
5391 plt_sym_val[i] = -1;
5393 plt_offset = bed->plt_entry_size;
5394 p = relplt->relocation;
5395 for (i = 0; i < count; i++, p++)
5399 if (p->howto->type != R_X86_64_JUMP_SLOT
5400 && p->howto->type != R_X86_64_IRELATIVE)
5403 reloc_index = H_GET_32 (abfd, (plt_contents + plt_offset
5404 + bed->plt_reloc_offset));
5405 if (reloc_index >= count)
5409 /* This is the index in .plt section. */
5410 long plt_index = plt_offset / bed->plt_entry_size;
5411 /* Store VMA + the offset in .plt.bnd section. */
5412 plt_sym_val[reloc_index] =
5414 + (plt_index - 1) * sizeof (elf_x86_64_legacy_plt2_entry));
5417 plt_sym_val[reloc_index] = plt->vma + plt_offset;
5418 plt_offset += bed->plt_entry_size;
5421 free (plt_contents);
5426 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
5430 elf_x86_64_get_synthetic_symtab (bfd *abfd,
5437 /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
5438 as PLT if it exists. */
5439 asection *plt = bfd_get_section_by_name (abfd, ".plt.bnd");
5441 plt = bfd_get_section_by_name (abfd, ".plt");
5442 return _bfd_elf_ifunc_get_synthetic_symtab (abfd, symcount, syms,
5443 dynsymcount, dynsyms, ret,
5445 elf_x86_64_get_plt_sym_val);
5448 /* Handle an x86-64 specific section when reading an object file. This
5449 is called when elfcode.h finds a section with an unknown type. */
5452 elf_x86_64_section_from_shdr (bfd *abfd, Elf_Internal_Shdr *hdr,
5453 const char *name, int shindex)
5455 if (hdr->sh_type != SHT_X86_64_UNWIND)
5458 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
5464 /* Hook called by the linker routine which adds symbols from an object
5465 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
5469 elf_x86_64_add_symbol_hook (bfd *abfd,
5470 struct bfd_link_info *info,
5471 Elf_Internal_Sym *sym,
5472 const char **namep ATTRIBUTE_UNUSED,
5473 flagword *flagsp ATTRIBUTE_UNUSED,
5479 switch (sym->st_shndx)
5481 case SHN_X86_64_LCOMMON:
5482 lcomm = bfd_get_section_by_name (abfd, "LARGE_COMMON");
5485 lcomm = bfd_make_section_with_flags (abfd,
5489 | SEC_LINKER_CREATED));
5492 elf_section_flags (lcomm) |= SHF_X86_64_LARGE;
5495 *valp = sym->st_size;
5499 if ((ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
5500 || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE)
5501 && (abfd->flags & DYNAMIC) == 0
5502 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
5503 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
5509 /* Given a BFD section, try to locate the corresponding ELF section
5513 elf_x86_64_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
5514 asection *sec, int *index_return)
5516 if (sec == &_bfd_elf_large_com_section)
5518 *index_return = SHN_X86_64_LCOMMON;
5524 /* Process a symbol. */
5527 elf_x86_64_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
5530 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
5532 switch (elfsym->internal_elf_sym.st_shndx)
5534 case SHN_X86_64_LCOMMON:
5535 asym->section = &_bfd_elf_large_com_section;
5536 asym->value = elfsym->internal_elf_sym.st_size;
5537 /* Common symbol doesn't set BSF_GLOBAL. */
5538 asym->flags &= ~BSF_GLOBAL;
5544 elf_x86_64_common_definition (Elf_Internal_Sym *sym)
5546 return (sym->st_shndx == SHN_COMMON
5547 || sym->st_shndx == SHN_X86_64_LCOMMON);
5551 elf_x86_64_common_section_index (asection *sec)
5553 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
5556 return SHN_X86_64_LCOMMON;
5560 elf_x86_64_common_section (asection *sec)
5562 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
5563 return bfd_com_section_ptr;
5565 return &_bfd_elf_large_com_section;
5569 elf_x86_64_merge_symbol (struct elf_link_hash_entry *h,
5570 const Elf_Internal_Sym *sym,
5575 const asection *oldsec)
5577 /* A normal common symbol and a large common symbol result in a
5578 normal common symbol. We turn the large common symbol into a
5581 && h->root.type == bfd_link_hash_common
5583 && bfd_is_com_section (*psec)
5586 if (sym->st_shndx == SHN_COMMON
5587 && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) != 0)
5589 h->root.u.c.p->section
5590 = bfd_make_section_old_way (oldbfd, "COMMON");
5591 h->root.u.c.p->section->flags = SEC_ALLOC;
5593 else if (sym->st_shndx == SHN_X86_64_LCOMMON
5594 && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) == 0)
5595 *psec = bfd_com_section_ptr;
5602 elf_x86_64_additional_program_headers (bfd *abfd,
5603 struct bfd_link_info *info ATTRIBUTE_UNUSED)
5608 /* Check to see if we need a large readonly segment. */
5609 s = bfd_get_section_by_name (abfd, ".lrodata");
5610 if (s && (s->flags & SEC_LOAD))
5613 /* Check to see if we need a large data segment. Since .lbss sections
5614 is placed right after the .bss section, there should be no need for
5615 a large data segment just because of .lbss. */
5616 s = bfd_get_section_by_name (abfd, ".ldata");
5617 if (s && (s->flags & SEC_LOAD))
5623 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
5626 elf_x86_64_hash_symbol (struct elf_link_hash_entry *h)
5628 if (h->plt.offset != (bfd_vma) -1
5630 && !h->pointer_equality_needed)
5633 return _bfd_elf_hash_symbol (h);
5636 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
5639 elf_x86_64_relocs_compatible (const bfd_target *input,
5640 const bfd_target *output)
5642 return ((xvec_get_elf_backend_data (input)->s->elfclass
5643 == xvec_get_elf_backend_data (output)->s->elfclass)
5644 && _bfd_elf_relocs_compatible (input, output));
5647 static const struct bfd_elf_special_section
5648 elf_x86_64_special_sections[]=
5650 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5651 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
5652 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR + SHF_X86_64_LARGE},
5653 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5654 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5655 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
5656 { NULL, 0, 0, 0, 0 }
5659 #define TARGET_LITTLE_SYM x86_64_elf64_vec
5660 #define TARGET_LITTLE_NAME "elf64-x86-64"
5661 #define ELF_ARCH bfd_arch_i386
5662 #define ELF_TARGET_ID X86_64_ELF_DATA
5663 #define ELF_MACHINE_CODE EM_X86_64
5664 #define ELF_MAXPAGESIZE 0x200000
5665 #define ELF_MINPAGESIZE 0x1000
5666 #define ELF_COMMONPAGESIZE 0x1000
5668 #define elf_backend_can_gc_sections 1
5669 #define elf_backend_can_refcount 1
5670 #define elf_backend_want_got_plt 1
5671 #define elf_backend_plt_readonly 1
5672 #define elf_backend_want_plt_sym 0
5673 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
5674 #define elf_backend_rela_normal 1
5675 #define elf_backend_plt_alignment 4
5677 #define elf_info_to_howto elf_x86_64_info_to_howto
5679 #define bfd_elf64_bfd_link_hash_table_create \
5680 elf_x86_64_link_hash_table_create
5681 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
5682 #define bfd_elf64_bfd_reloc_name_lookup \
5683 elf_x86_64_reloc_name_lookup
5685 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
5686 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
5687 #define elf_backend_check_relocs elf_x86_64_check_relocs
5688 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
5689 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
5690 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
5691 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
5692 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
5693 #define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
5694 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
5695 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
5697 #define elf_backend_write_core_note elf_x86_64_write_core_note
5699 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
5700 #define elf_backend_relocate_section elf_x86_64_relocate_section
5701 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
5702 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
5703 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
5704 #define elf_backend_object_p elf64_x86_64_elf_object_p
5705 #define bfd_elf64_mkobject elf_x86_64_mkobject
5706 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
5708 #define elf_backend_section_from_shdr \
5709 elf_x86_64_section_from_shdr
5711 #define elf_backend_section_from_bfd_section \
5712 elf_x86_64_elf_section_from_bfd_section
5713 #define elf_backend_add_symbol_hook \
5714 elf_x86_64_add_symbol_hook
5715 #define elf_backend_symbol_processing \
5716 elf_x86_64_symbol_processing
5717 #define elf_backend_common_section_index \
5718 elf_x86_64_common_section_index
5719 #define elf_backend_common_section \
5720 elf_x86_64_common_section
5721 #define elf_backend_common_definition \
5722 elf_x86_64_common_definition
5723 #define elf_backend_merge_symbol \
5724 elf_x86_64_merge_symbol
5725 #define elf_backend_special_sections \
5726 elf_x86_64_special_sections
5727 #define elf_backend_additional_program_headers \
5728 elf_x86_64_additional_program_headers
5729 #define elf_backend_hash_symbol \
5730 elf_x86_64_hash_symbol
5732 #include "elf64-target.h"
5734 /* FreeBSD support. */
5736 #undef TARGET_LITTLE_SYM
5737 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
5738 #undef TARGET_LITTLE_NAME
5739 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
5742 #define ELF_OSABI ELFOSABI_FREEBSD
5745 #define elf64_bed elf64_x86_64_fbsd_bed
5747 #include "elf64-target.h"
5749 /* Solaris 2 support. */
5751 #undef TARGET_LITTLE_SYM
5752 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
5753 #undef TARGET_LITTLE_NAME
5754 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
5756 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5757 objects won't be recognized. */
5761 #define elf64_bed elf64_x86_64_sol2_bed
5763 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
5765 #undef elf_backend_static_tls_alignment
5766 #define elf_backend_static_tls_alignment 16
5768 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5770 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5772 #undef elf_backend_want_plt_sym
5773 #define elf_backend_want_plt_sym 1
5775 #include "elf64-target.h"
5777 /* Native Client support. */
5780 elf64_x86_64_nacl_elf_object_p (bfd *abfd)
5782 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
5783 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64_nacl);
5787 #undef TARGET_LITTLE_SYM
5788 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
5789 #undef TARGET_LITTLE_NAME
5790 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
5792 #define elf64_bed elf64_x86_64_nacl_bed
5794 #undef ELF_MAXPAGESIZE
5795 #undef ELF_MINPAGESIZE
5796 #undef ELF_COMMONPAGESIZE
5797 #define ELF_MAXPAGESIZE 0x10000
5798 #define ELF_MINPAGESIZE 0x10000
5799 #define ELF_COMMONPAGESIZE 0x10000
5801 /* Restore defaults. */
5803 #undef elf_backend_static_tls_alignment
5804 #undef elf_backend_want_plt_sym
5805 #define elf_backend_want_plt_sym 0
5807 /* NaCl uses substantially different PLT entries for the same effects. */
5809 #undef elf_backend_plt_alignment
5810 #define elf_backend_plt_alignment 5
5811 #define NACL_PLT_ENTRY_SIZE 64
5812 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
5814 static const bfd_byte elf_x86_64_nacl_plt0_entry[NACL_PLT_ENTRY_SIZE] =
5816 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
5817 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
5818 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */
5819 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5820 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5822 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
5823 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
5825 /* 32 bytes of nop to pad out to the standard size. */
5826 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5827 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5828 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5829 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5830 0x66, /* excess data32 prefix */
5834 static const bfd_byte elf_x86_64_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
5836 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
5837 0x41, 0x83, 0xe3, NACLMASK, /* and $-32, %r11d */
5838 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5839 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5841 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
5842 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5843 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5845 /* Lazy GOT entries point here (32-byte aligned). */
5846 0x68, /* pushq immediate */
5847 0, 0, 0, 0, /* replaced with index into relocation table. */
5848 0xe9, /* jmp relative */
5849 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
5851 /* 22 bytes of nop to pad out to the standard size. */
5852 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
5853 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5854 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
5857 /* .eh_frame covering the .plt section. */
5859 static const bfd_byte elf_x86_64_nacl_eh_frame_plt[] =
5861 #if (PLT_CIE_LENGTH != 20 \
5862 || PLT_FDE_LENGTH != 36 \
5863 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
5864 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
5865 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
5867 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
5868 0, 0, 0, 0, /* CIE ID */
5869 1, /* CIE version */
5870 'z', 'R', 0, /* Augmentation string */
5871 1, /* Code alignment factor */
5872 0x78, /* Data alignment factor */
5873 16, /* Return address column */
5874 1, /* Augmentation size */
5875 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
5876 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
5877 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
5878 DW_CFA_nop, DW_CFA_nop,
5880 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
5881 PLT_CIE_LENGTH + 8, 0, 0, 0,/* CIE pointer */
5882 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
5883 0, 0, 0, 0, /* .plt size goes here */
5884 0, /* Augmentation size */
5885 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
5886 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
5887 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
5888 DW_CFA_advance_loc + 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
5889 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
5890 13, /* Block length */
5891 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
5892 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
5893 DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
5894 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
5895 DW_CFA_nop, DW_CFA_nop
5898 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed =
5900 elf_x86_64_nacl_plt0_entry, /* plt0_entry */
5901 elf_x86_64_nacl_plt_entry, /* plt_entry */
5902 NACL_PLT_ENTRY_SIZE, /* plt_entry_size */
5903 2, /* plt0_got1_offset */
5904 9, /* plt0_got2_offset */
5905 13, /* plt0_got2_insn_end */
5906 3, /* plt_got_offset */
5907 33, /* plt_reloc_offset */
5908 38, /* plt_plt_offset */
5909 7, /* plt_got_insn_size */
5910 42, /* plt_plt_insn_end */
5911 32, /* plt_lazy_offset */
5912 elf_x86_64_nacl_eh_frame_plt, /* eh_frame_plt */
5913 sizeof (elf_x86_64_nacl_eh_frame_plt), /* eh_frame_plt_size */
5916 #undef elf_backend_arch_data
5917 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
5919 #undef elf_backend_object_p
5920 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
5921 #undef elf_backend_modify_segment_map
5922 #define elf_backend_modify_segment_map nacl_modify_segment_map
5923 #undef elf_backend_modify_program_headers
5924 #define elf_backend_modify_program_headers nacl_modify_program_headers
5925 #undef elf_backend_final_write_processing
5926 #define elf_backend_final_write_processing nacl_final_write_processing
5928 #include "elf64-target.h"
5930 /* Native Client x32 support. */
5933 elf32_x86_64_nacl_elf_object_p (bfd *abfd)
5935 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
5936 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32_nacl);
5940 #undef TARGET_LITTLE_SYM
5941 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
5942 #undef TARGET_LITTLE_NAME
5943 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
5945 #define elf32_bed elf32_x86_64_nacl_bed
5947 #define bfd_elf32_bfd_link_hash_table_create \
5948 elf_x86_64_link_hash_table_create
5949 #define bfd_elf32_bfd_reloc_type_lookup \
5950 elf_x86_64_reloc_type_lookup
5951 #define bfd_elf32_bfd_reloc_name_lookup \
5952 elf_x86_64_reloc_name_lookup
5953 #define bfd_elf32_mkobject \
5955 #define bfd_elf32_get_synthetic_symtab \
5956 elf_x86_64_get_synthetic_symtab
5958 #undef elf_backend_object_p
5959 #define elf_backend_object_p \
5960 elf32_x86_64_nacl_elf_object_p
5962 #undef elf_backend_bfd_from_remote_memory
5963 #define elf_backend_bfd_from_remote_memory \
5964 _bfd_elf32_bfd_from_remote_memory
5966 #undef elf_backend_size_info
5967 #define elf_backend_size_info \
5968 _bfd_elf32_size_info
5970 #include "elf32-target.h"
5972 /* Restore defaults. */
5973 #undef elf_backend_object_p
5974 #define elf_backend_object_p elf64_x86_64_elf_object_p
5975 #undef elf_backend_bfd_from_remote_memory
5976 #undef elf_backend_size_info
5977 #undef elf_backend_modify_segment_map
5978 #undef elf_backend_modify_program_headers
5979 #undef elf_backend_final_write_processing
5981 /* Intel L1OM support. */
5984 elf64_l1om_elf_object_p (bfd *abfd)
5986 /* Set the right machine number for an L1OM elf64 file. */
5987 bfd_default_set_arch_mach (abfd, bfd_arch_l1om, bfd_mach_l1om);
5991 #undef TARGET_LITTLE_SYM
5992 #define TARGET_LITTLE_SYM l1om_elf64_vec
5993 #undef TARGET_LITTLE_NAME
5994 #define TARGET_LITTLE_NAME "elf64-l1om"
5996 #define ELF_ARCH bfd_arch_l1om
5998 #undef ELF_MACHINE_CODE
5999 #define ELF_MACHINE_CODE EM_L1OM
6004 #define elf64_bed elf64_l1om_bed
6006 #undef elf_backend_object_p
6007 #define elf_backend_object_p elf64_l1om_elf_object_p
6009 /* Restore defaults. */
6010 #undef ELF_MAXPAGESIZE
6011 #undef ELF_MINPAGESIZE
6012 #undef ELF_COMMONPAGESIZE
6013 #define ELF_MAXPAGESIZE 0x200000
6014 #define ELF_MINPAGESIZE 0x1000
6015 #define ELF_COMMONPAGESIZE 0x1000
6016 #undef elf_backend_plt_alignment
6017 #define elf_backend_plt_alignment 4
6018 #undef elf_backend_arch_data
6019 #define elf_backend_arch_data &elf_x86_64_arch_bed
6021 #include "elf64-target.h"
6023 /* FreeBSD L1OM support. */
6025 #undef TARGET_LITTLE_SYM
6026 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
6027 #undef TARGET_LITTLE_NAME
6028 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
6031 #define ELF_OSABI ELFOSABI_FREEBSD
6034 #define elf64_bed elf64_l1om_fbsd_bed
6036 #include "elf64-target.h"
6038 /* Intel K1OM support. */
6041 elf64_k1om_elf_object_p (bfd *abfd)
6043 /* Set the right machine number for an K1OM elf64 file. */
6044 bfd_default_set_arch_mach (abfd, bfd_arch_k1om, bfd_mach_k1om);
6048 #undef TARGET_LITTLE_SYM
6049 #define TARGET_LITTLE_SYM k1om_elf64_vec
6050 #undef TARGET_LITTLE_NAME
6051 #define TARGET_LITTLE_NAME "elf64-k1om"
6053 #define ELF_ARCH bfd_arch_k1om
6055 #undef ELF_MACHINE_CODE
6056 #define ELF_MACHINE_CODE EM_K1OM
6061 #define elf64_bed elf64_k1om_bed
6063 #undef elf_backend_object_p
6064 #define elf_backend_object_p elf64_k1om_elf_object_p
6066 #undef elf_backend_static_tls_alignment
6068 #undef elf_backend_want_plt_sym
6069 #define elf_backend_want_plt_sym 0
6071 #include "elf64-target.h"
6073 /* FreeBSD K1OM support. */
6075 #undef TARGET_LITTLE_SYM
6076 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
6077 #undef TARGET_LITTLE_NAME
6078 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
6081 #define ELF_OSABI ELFOSABI_FREEBSD
6084 #define elf64_bed elf64_k1om_fbsd_bed
6086 #include "elf64-target.h"
6088 /* 32bit x86-64 support. */
6090 #undef TARGET_LITTLE_SYM
6091 #define TARGET_LITTLE_SYM x86_64_elf32_vec
6092 #undef TARGET_LITTLE_NAME
6093 #define TARGET_LITTLE_NAME "elf32-x86-64"
6097 #define ELF_ARCH bfd_arch_i386
6099 #undef ELF_MACHINE_CODE
6100 #define ELF_MACHINE_CODE EM_X86_64
6104 #undef elf_backend_object_p
6105 #define elf_backend_object_p \
6106 elf32_x86_64_elf_object_p
6108 #undef elf_backend_bfd_from_remote_memory
6109 #define elf_backend_bfd_from_remote_memory \
6110 _bfd_elf32_bfd_from_remote_memory
6112 #undef elf_backend_size_info
6113 #define elf_backend_size_info \
6114 _bfd_elf32_size_info
6116 #include "elf32-target.h"