1 /* X86-64 specific support for ELF
2 Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
4 Free Software Foundation, Inc.
5 Contributed by Jan Hubicka <jh@suse.cz>.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
29 #include "bfd_stdint.h"
33 #include "libiberty.h"
35 #include "elf/x86-64.h"
42 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
43 #define MINUS_ONE (~ (bfd_vma) 0)
45 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
46 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
47 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
48 since they are the same. */
50 #define ABI_64_P(abfd) \
51 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
53 /* The relocation "howto" table. Order of fields:
54 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
55 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
56 static reloc_howto_type x86_64_elf_howto_table[] =
58 HOWTO(R_X86_64_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
59 bfd_elf_generic_reloc, "R_X86_64_NONE", FALSE, 0x00000000, 0x00000000,
61 HOWTO(R_X86_64_64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
62 bfd_elf_generic_reloc, "R_X86_64_64", FALSE, MINUS_ONE, MINUS_ONE,
64 HOWTO(R_X86_64_PC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
65 bfd_elf_generic_reloc, "R_X86_64_PC32", FALSE, 0xffffffff, 0xffffffff,
67 HOWTO(R_X86_64_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
68 bfd_elf_generic_reloc, "R_X86_64_GOT32", FALSE, 0xffffffff, 0xffffffff,
70 HOWTO(R_X86_64_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
71 bfd_elf_generic_reloc, "R_X86_64_PLT32", FALSE, 0xffffffff, 0xffffffff,
73 HOWTO(R_X86_64_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
74 bfd_elf_generic_reloc, "R_X86_64_COPY", FALSE, 0xffffffff, 0xffffffff,
76 HOWTO(R_X86_64_GLOB_DAT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
77 bfd_elf_generic_reloc, "R_X86_64_GLOB_DAT", FALSE, MINUS_ONE,
79 HOWTO(R_X86_64_JUMP_SLOT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
80 bfd_elf_generic_reloc, "R_X86_64_JUMP_SLOT", FALSE, MINUS_ONE,
82 HOWTO(R_X86_64_RELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
83 bfd_elf_generic_reloc, "R_X86_64_RELATIVE", FALSE, MINUS_ONE,
85 HOWTO(R_X86_64_GOTPCREL, 0, 2, 32, TRUE, 0, complain_overflow_signed,
86 bfd_elf_generic_reloc, "R_X86_64_GOTPCREL", FALSE, 0xffffffff,
88 HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
89 bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
91 HOWTO(R_X86_64_32S, 0, 2, 32, FALSE, 0, complain_overflow_signed,
92 bfd_elf_generic_reloc, "R_X86_64_32S", FALSE, 0xffffffff, 0xffffffff,
94 HOWTO(R_X86_64_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
95 bfd_elf_generic_reloc, "R_X86_64_16", FALSE, 0xffff, 0xffff, FALSE),
96 HOWTO(R_X86_64_PC16,0, 1, 16, TRUE, 0, complain_overflow_bitfield,
97 bfd_elf_generic_reloc, "R_X86_64_PC16", FALSE, 0xffff, 0xffff, TRUE),
98 HOWTO(R_X86_64_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
99 bfd_elf_generic_reloc, "R_X86_64_8", FALSE, 0xff, 0xff, FALSE),
100 HOWTO(R_X86_64_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
101 bfd_elf_generic_reloc, "R_X86_64_PC8", FALSE, 0xff, 0xff, TRUE),
102 HOWTO(R_X86_64_DTPMOD64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
103 bfd_elf_generic_reloc, "R_X86_64_DTPMOD64", FALSE, MINUS_ONE,
105 HOWTO(R_X86_64_DTPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
106 bfd_elf_generic_reloc, "R_X86_64_DTPOFF64", FALSE, MINUS_ONE,
108 HOWTO(R_X86_64_TPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
109 bfd_elf_generic_reloc, "R_X86_64_TPOFF64", FALSE, MINUS_ONE,
111 HOWTO(R_X86_64_TLSGD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
112 bfd_elf_generic_reloc, "R_X86_64_TLSGD", FALSE, 0xffffffff,
114 HOWTO(R_X86_64_TLSLD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
115 bfd_elf_generic_reloc, "R_X86_64_TLSLD", FALSE, 0xffffffff,
117 HOWTO(R_X86_64_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
118 bfd_elf_generic_reloc, "R_X86_64_DTPOFF32", FALSE, 0xffffffff,
120 HOWTO(R_X86_64_GOTTPOFF, 0, 2, 32, TRUE, 0, complain_overflow_signed,
121 bfd_elf_generic_reloc, "R_X86_64_GOTTPOFF", FALSE, 0xffffffff,
123 HOWTO(R_X86_64_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
124 bfd_elf_generic_reloc, "R_X86_64_TPOFF32", FALSE, 0xffffffff,
126 HOWTO(R_X86_64_PC64, 0, 4, 64, TRUE, 0, complain_overflow_bitfield,
127 bfd_elf_generic_reloc, "R_X86_64_PC64", FALSE, MINUS_ONE, MINUS_ONE,
129 HOWTO(R_X86_64_GOTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
130 bfd_elf_generic_reloc, "R_X86_64_GOTOFF64",
131 FALSE, MINUS_ONE, MINUS_ONE, FALSE),
132 HOWTO(R_X86_64_GOTPC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
133 bfd_elf_generic_reloc, "R_X86_64_GOTPC32",
134 FALSE, 0xffffffff, 0xffffffff, TRUE),
135 HOWTO(R_X86_64_GOT64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
136 bfd_elf_generic_reloc, "R_X86_64_GOT64", FALSE, MINUS_ONE, MINUS_ONE,
138 HOWTO(R_X86_64_GOTPCREL64, 0, 4, 64, TRUE, 0, complain_overflow_signed,
139 bfd_elf_generic_reloc, "R_X86_64_GOTPCREL64", FALSE, MINUS_ONE,
141 HOWTO(R_X86_64_GOTPC64, 0, 4, 64, TRUE, 0, complain_overflow_signed,
142 bfd_elf_generic_reloc, "R_X86_64_GOTPC64",
143 FALSE, MINUS_ONE, MINUS_ONE, TRUE),
144 HOWTO(R_X86_64_GOTPLT64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
145 bfd_elf_generic_reloc, "R_X86_64_GOTPLT64", FALSE, MINUS_ONE,
147 HOWTO(R_X86_64_PLTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
148 bfd_elf_generic_reloc, "R_X86_64_PLTOFF64", FALSE, MINUS_ONE,
152 HOWTO(R_X86_64_GOTPC32_TLSDESC, 0, 2, 32, TRUE, 0,
153 complain_overflow_bitfield, bfd_elf_generic_reloc,
154 "R_X86_64_GOTPC32_TLSDESC",
155 FALSE, 0xffffffff, 0xffffffff, TRUE),
156 HOWTO(R_X86_64_TLSDESC_CALL, 0, 0, 0, FALSE, 0,
157 complain_overflow_dont, bfd_elf_generic_reloc,
158 "R_X86_64_TLSDESC_CALL",
160 HOWTO(R_X86_64_TLSDESC, 0, 4, 64, FALSE, 0,
161 complain_overflow_bitfield, bfd_elf_generic_reloc,
163 FALSE, MINUS_ONE, MINUS_ONE, FALSE),
164 HOWTO(R_X86_64_IRELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
165 bfd_elf_generic_reloc, "R_X86_64_IRELATIVE", FALSE, MINUS_ONE,
167 HOWTO(R_X86_64_RELATIVE64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
168 bfd_elf_generic_reloc, "R_X86_64_RELATIVE64", FALSE, MINUS_ONE,
171 /* We have a gap in the reloc numbers here.
172 R_X86_64_standard counts the number up to this point, and
173 R_X86_64_vt_offset is the value to subtract from a reloc type of
174 R_X86_64_GNU_VT* to form an index into this table. */
175 #define R_X86_64_standard (R_X86_64_IRELATIVE + 1)
176 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
178 /* GNU extension to record C++ vtable hierarchy. */
179 HOWTO (R_X86_64_GNU_VTINHERIT, 0, 4, 0, FALSE, 0, complain_overflow_dont,
180 NULL, "R_X86_64_GNU_VTINHERIT", FALSE, 0, 0, FALSE),
182 /* GNU extension to record C++ vtable member usage. */
183 HOWTO (R_X86_64_GNU_VTENTRY, 0, 4, 0, FALSE, 0, complain_overflow_dont,
184 _bfd_elf_rel_vtable_reloc_fn, "R_X86_64_GNU_VTENTRY", FALSE, 0, 0,
187 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
188 HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
189 bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
193 #define IS_X86_64_PCREL_TYPE(TYPE) \
194 ( ((TYPE) == R_X86_64_PC8) \
195 || ((TYPE) == R_X86_64_PC16) \
196 || ((TYPE) == R_X86_64_PC32) \
197 || ((TYPE) == R_X86_64_PC64))
199 /* Map BFD relocs to the x86_64 elf relocs. */
202 bfd_reloc_code_real_type bfd_reloc_val;
203 unsigned char elf_reloc_val;
206 static const struct elf_reloc_map x86_64_reloc_map[] =
208 { BFD_RELOC_NONE, R_X86_64_NONE, },
209 { BFD_RELOC_64, R_X86_64_64, },
210 { BFD_RELOC_32_PCREL, R_X86_64_PC32, },
211 { BFD_RELOC_X86_64_GOT32, R_X86_64_GOT32,},
212 { BFD_RELOC_X86_64_PLT32, R_X86_64_PLT32,},
213 { BFD_RELOC_X86_64_COPY, R_X86_64_COPY, },
214 { BFD_RELOC_X86_64_GLOB_DAT, R_X86_64_GLOB_DAT, },
215 { BFD_RELOC_X86_64_JUMP_SLOT, R_X86_64_JUMP_SLOT, },
216 { BFD_RELOC_X86_64_RELATIVE, R_X86_64_RELATIVE, },
217 { BFD_RELOC_X86_64_GOTPCREL, R_X86_64_GOTPCREL, },
218 { BFD_RELOC_32, R_X86_64_32, },
219 { BFD_RELOC_X86_64_32S, R_X86_64_32S, },
220 { BFD_RELOC_16, R_X86_64_16, },
221 { BFD_RELOC_16_PCREL, R_X86_64_PC16, },
222 { BFD_RELOC_8, R_X86_64_8, },
223 { BFD_RELOC_8_PCREL, R_X86_64_PC8, },
224 { BFD_RELOC_X86_64_DTPMOD64, R_X86_64_DTPMOD64, },
225 { BFD_RELOC_X86_64_DTPOFF64, R_X86_64_DTPOFF64, },
226 { BFD_RELOC_X86_64_TPOFF64, R_X86_64_TPOFF64, },
227 { BFD_RELOC_X86_64_TLSGD, R_X86_64_TLSGD, },
228 { BFD_RELOC_X86_64_TLSLD, R_X86_64_TLSLD, },
229 { BFD_RELOC_X86_64_DTPOFF32, R_X86_64_DTPOFF32, },
230 { BFD_RELOC_X86_64_GOTTPOFF, R_X86_64_GOTTPOFF, },
231 { BFD_RELOC_X86_64_TPOFF32, R_X86_64_TPOFF32, },
232 { BFD_RELOC_64_PCREL, R_X86_64_PC64, },
233 { BFD_RELOC_X86_64_GOTOFF64, R_X86_64_GOTOFF64, },
234 { BFD_RELOC_X86_64_GOTPC32, R_X86_64_GOTPC32, },
235 { BFD_RELOC_X86_64_GOT64, R_X86_64_GOT64, },
236 { BFD_RELOC_X86_64_GOTPCREL64,R_X86_64_GOTPCREL64, },
237 { BFD_RELOC_X86_64_GOTPC64, R_X86_64_GOTPC64, },
238 { BFD_RELOC_X86_64_GOTPLT64, R_X86_64_GOTPLT64, },
239 { BFD_RELOC_X86_64_PLTOFF64, R_X86_64_PLTOFF64, },
240 { BFD_RELOC_X86_64_GOTPC32_TLSDESC, R_X86_64_GOTPC32_TLSDESC, },
241 { BFD_RELOC_X86_64_TLSDESC_CALL, R_X86_64_TLSDESC_CALL, },
242 { BFD_RELOC_X86_64_TLSDESC, R_X86_64_TLSDESC, },
243 { BFD_RELOC_X86_64_IRELATIVE, R_X86_64_IRELATIVE, },
244 { BFD_RELOC_VTABLE_INHERIT, R_X86_64_GNU_VTINHERIT, },
245 { BFD_RELOC_VTABLE_ENTRY, R_X86_64_GNU_VTENTRY, },
248 static reloc_howto_type *
249 elf_x86_64_rtype_to_howto (bfd *abfd, unsigned r_type)
253 if (r_type == (unsigned int) R_X86_64_32)
258 i = ARRAY_SIZE (x86_64_elf_howto_table) - 1;
260 else if (r_type < (unsigned int) R_X86_64_GNU_VTINHERIT
261 || r_type >= (unsigned int) R_X86_64_max)
263 if (r_type >= (unsigned int) R_X86_64_standard)
265 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
267 r_type = R_X86_64_NONE;
272 i = r_type - (unsigned int) R_X86_64_vt_offset;
273 BFD_ASSERT (x86_64_elf_howto_table[i].type == r_type);
274 return &x86_64_elf_howto_table[i];
277 /* Given a BFD reloc type, return a HOWTO structure. */
278 static reloc_howto_type *
279 elf_x86_64_reloc_type_lookup (bfd *abfd,
280 bfd_reloc_code_real_type code)
284 for (i = 0; i < sizeof (x86_64_reloc_map) / sizeof (struct elf_reloc_map);
287 if (x86_64_reloc_map[i].bfd_reloc_val == code)
288 return elf_x86_64_rtype_to_howto (abfd,
289 x86_64_reloc_map[i].elf_reloc_val);
294 static reloc_howto_type *
295 elf_x86_64_reloc_name_lookup (bfd *abfd,
300 if (!ABI_64_P (abfd) && strcasecmp (r_name, "R_X86_64_32") == 0)
302 /* Get x32 R_X86_64_32. */
303 reloc_howto_type *reloc
304 = &x86_64_elf_howto_table[ARRAY_SIZE (x86_64_elf_howto_table) - 1];
305 BFD_ASSERT (reloc->type == (unsigned int) R_X86_64_32);
309 for (i = 0; i < ARRAY_SIZE (x86_64_elf_howto_table); i++)
310 if (x86_64_elf_howto_table[i].name != NULL
311 && strcasecmp (x86_64_elf_howto_table[i].name, r_name) == 0)
312 return &x86_64_elf_howto_table[i];
317 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
320 elf_x86_64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
321 Elf_Internal_Rela *dst)
325 r_type = ELF32_R_TYPE (dst->r_info);
326 cache_ptr->howto = elf_x86_64_rtype_to_howto (abfd, r_type);
327 BFD_ASSERT (r_type == cache_ptr->howto->type);
330 /* Support for core dump NOTE sections. */
332 elf_x86_64_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
337 switch (note->descsz)
342 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
344 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
347 elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24);
355 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
357 elf_tdata (abfd)->core_signal
358 = bfd_get_16 (abfd, note->descdata + 12);
361 elf_tdata (abfd)->core_lwpid
362 = bfd_get_32 (abfd, note->descdata + 32);
371 /* Make a ".reg/999" section. */
372 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
373 size, note->descpos + offset);
377 elf_x86_64_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
379 switch (note->descsz)
384 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
385 elf_tdata (abfd)->core_pid
386 = bfd_get_32 (abfd, note->descdata + 12);
387 elf_tdata (abfd)->core_program
388 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
389 elf_tdata (abfd)->core_command
390 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
393 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
394 elf_tdata (abfd)->core_pid
395 = bfd_get_32 (abfd, note->descdata + 24);
396 elf_tdata (abfd)->core_program
397 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
398 elf_tdata (abfd)->core_command
399 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
402 /* Note that for some reason, a spurious space is tacked
403 onto the end of the args in some (at least one anyway)
404 implementations, so strip it off if it exists. */
407 char *command = elf_tdata (abfd)->core_command;
408 int n = strlen (command);
410 if (0 < n && command[n - 1] == ' ')
411 command[n - 1] = '\0';
419 elf_x86_64_write_core_note (bfd *abfd, char *buf, int *bufsiz,
422 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
426 const char *fname, *psargs;
437 va_start (ap, note_type);
438 fname = va_arg (ap, const char *);
439 psargs = va_arg (ap, const char *);
442 if (bed->s->elfclass == ELFCLASS32)
445 memset (&data, 0, sizeof (data));
446 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
447 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
448 p = (const void *) &data;
449 size = sizeof (data);
454 memset (&data, 0, sizeof (data));
455 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
456 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
457 p = (const void *) &data;
458 size = sizeof (data);
463 va_start (ap, note_type);
464 pid = va_arg (ap, long);
465 cursig = va_arg (ap, int);
466 gregs = va_arg (ap, const void *);
469 if (bed->s->elfclass == ELFCLASS32)
471 if (bed->elf_machine_code == EM_X86_64)
473 prstatusx32_t prstat;
474 memset (&prstat, 0, sizeof (prstat));
476 prstat.pr_cursig = cursig;
477 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
478 p = (const void *) &prstat;
479 size = sizeof (prstat);
484 memset (&prstat, 0, sizeof (prstat));
486 prstat.pr_cursig = cursig;
487 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
488 p = (const void *) &prstat;
489 size = sizeof (prstat);
495 memset (&prstat, 0, sizeof (prstat));
497 prstat.pr_cursig = cursig;
498 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
499 p = (const void *) &prstat;
500 size = sizeof (prstat);
505 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type, p,
510 /* Functions for the x86-64 ELF linker. */
512 /* The name of the dynamic interpreter. This is put in the .interp
515 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
516 #define ELF32_DYNAMIC_INTERPRETER "/lib/ld32.so.1"
518 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
519 copying dynamic variables from a shared lib into an app's dynbss
520 section, and instead use a dynamic relocation to point into the
522 #define ELIMINATE_COPY_RELOCS 1
524 /* The size in bytes of an entry in the global offset table. */
526 #define GOT_ENTRY_SIZE 8
528 /* The size in bytes of an entry in the procedure linkage table. */
530 #define PLT_ENTRY_SIZE 16
532 /* The first entry in a procedure linkage table looks like this. See the
533 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
535 static const bfd_byte elf_x86_64_plt0_entry[PLT_ENTRY_SIZE] =
537 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
538 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
539 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
542 /* Subsequent entries in a procedure linkage table look like this. */
544 static const bfd_byte elf_x86_64_plt_entry[PLT_ENTRY_SIZE] =
546 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
547 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
548 0x68, /* pushq immediate */
549 0, 0, 0, 0, /* replaced with index into relocation table. */
550 0xe9, /* jmp relative */
551 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
554 /* .eh_frame covering the .plt section. */
556 static const bfd_byte elf_x86_64_eh_frame_plt[] =
558 #define PLT_CIE_LENGTH 20
559 #define PLT_FDE_LENGTH 36
560 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
561 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
562 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
563 0, 0, 0, 0, /* CIE ID */
565 'z', 'R', 0, /* Augmentation string */
566 1, /* Code alignment factor */
567 0x78, /* Data alignment factor */
568 16, /* Return address column */
569 1, /* Augmentation size */
570 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
571 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
572 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
573 DW_CFA_nop, DW_CFA_nop,
575 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
576 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
577 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
578 0, 0, 0, 0, /* .plt size goes here */
579 0, /* Augmentation size */
580 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
581 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
582 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
583 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
584 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
585 11, /* Block length */
586 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
587 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
588 DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
589 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
590 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
593 /* x86-64 ELF linker hash entry. */
595 struct elf_x86_64_link_hash_entry
597 struct elf_link_hash_entry elf;
599 /* Track dynamic relocs copied for this symbol. */
600 struct elf_dyn_relocs *dyn_relocs;
602 #define GOT_UNKNOWN 0
606 #define GOT_TLS_GDESC 4
607 #define GOT_TLS_GD_BOTH_P(type) \
608 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
609 #define GOT_TLS_GD_P(type) \
610 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
611 #define GOT_TLS_GDESC_P(type) \
612 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
613 #define GOT_TLS_GD_ANY_P(type) \
614 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
615 unsigned char tls_type;
617 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
618 starting at the end of the jump table. */
622 #define elf_x86_64_hash_entry(ent) \
623 ((struct elf_x86_64_link_hash_entry *)(ent))
625 struct elf_x86_64_obj_tdata
627 struct elf_obj_tdata root;
629 /* tls_type for each local got entry. */
630 char *local_got_tls_type;
632 /* GOTPLT entries for TLS descriptors. */
633 bfd_vma *local_tlsdesc_gotent;
636 #define elf_x86_64_tdata(abfd) \
637 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
639 #define elf_x86_64_local_got_tls_type(abfd) \
640 (elf_x86_64_tdata (abfd)->local_got_tls_type)
642 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
643 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
645 #define is_x86_64_elf(bfd) \
646 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
647 && elf_tdata (bfd) != NULL \
648 && elf_object_id (bfd) == X86_64_ELF_DATA)
651 elf_x86_64_mkobject (bfd *abfd)
653 return bfd_elf_allocate_object (abfd, sizeof (struct elf_x86_64_obj_tdata),
657 /* x86-64 ELF linker hash table. */
659 struct elf_x86_64_link_hash_table
661 struct elf_link_hash_table elf;
663 /* Short-cuts to get to dynamic linker sections. */
666 asection *plt_eh_frame;
670 bfd_signed_vma refcount;
674 /* The amount of space used by the jump slots in the GOT. */
675 bfd_vma sgotplt_jump_table_size;
677 /* Small local sym cache. */
678 struct sym_cache sym_cache;
680 bfd_vma (*r_info) (bfd_vma, bfd_vma);
681 bfd_vma (*r_sym) (bfd_vma);
682 unsigned int pointer_r_type;
683 const char *dynamic_interpreter;
684 int dynamic_interpreter_size;
686 /* _TLS_MODULE_BASE_ symbol. */
687 struct bfd_link_hash_entry *tls_module_base;
689 /* Used by local STT_GNU_IFUNC symbols. */
690 htab_t loc_hash_table;
691 void * loc_hash_memory;
693 /* The offset into splt of the PLT entry for the TLS descriptor
694 resolver. Special values are 0, if not necessary (or not found
695 to be necessary yet), and -1 if needed but not determined
698 /* The offset into sgot of the GOT entry used by the PLT entry
703 /* Get the x86-64 ELF linker hash table from a link_info structure. */
705 #define elf_x86_64_hash_table(p) \
706 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
707 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
709 #define elf_x86_64_compute_jump_table_size(htab) \
710 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
712 /* Create an entry in an x86-64 ELF linker hash table. */
714 static struct bfd_hash_entry *
715 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry *entry,
716 struct bfd_hash_table *table,
719 /* Allocate the structure if it has not already been allocated by a
723 entry = (struct bfd_hash_entry *)
724 bfd_hash_allocate (table,
725 sizeof (struct elf_x86_64_link_hash_entry));
730 /* Call the allocation method of the superclass. */
731 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
734 struct elf_x86_64_link_hash_entry *eh;
736 eh = (struct elf_x86_64_link_hash_entry *) entry;
737 eh->dyn_relocs = NULL;
738 eh->tls_type = GOT_UNKNOWN;
739 eh->tlsdesc_got = (bfd_vma) -1;
745 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
746 for local symbol so that we can handle local STT_GNU_IFUNC symbols
747 as global symbol. We reuse indx and dynstr_index for local symbol
748 hash since they aren't used by global symbols in this backend. */
751 elf_x86_64_local_htab_hash (const void *ptr)
753 struct elf_link_hash_entry *h
754 = (struct elf_link_hash_entry *) ptr;
755 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
758 /* Compare local hash entries. */
761 elf_x86_64_local_htab_eq (const void *ptr1, const void *ptr2)
763 struct elf_link_hash_entry *h1
764 = (struct elf_link_hash_entry *) ptr1;
765 struct elf_link_hash_entry *h2
766 = (struct elf_link_hash_entry *) ptr2;
768 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
771 /* Find and/or create a hash entry for local symbol. */
773 static struct elf_link_hash_entry *
774 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table *htab,
775 bfd *abfd, const Elf_Internal_Rela *rel,
778 struct elf_x86_64_link_hash_entry e, *ret;
779 asection *sec = abfd->sections;
780 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
781 htab->r_sym (rel->r_info));
784 e.elf.indx = sec->id;
785 e.elf.dynstr_index = htab->r_sym (rel->r_info);
786 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
787 create ? INSERT : NO_INSERT);
794 ret = (struct elf_x86_64_link_hash_entry *) *slot;
798 ret = (struct elf_x86_64_link_hash_entry *)
799 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
800 sizeof (struct elf_x86_64_link_hash_entry));
803 memset (ret, 0, sizeof (*ret));
804 ret->elf.indx = sec->id;
805 ret->elf.dynstr_index = htab->r_sym (rel->r_info);
806 ret->elf.dynindx = -1;
812 /* Create an X86-64 ELF linker hash table. */
814 static struct bfd_link_hash_table *
815 elf_x86_64_link_hash_table_create (bfd *abfd)
817 struct elf_x86_64_link_hash_table *ret;
818 bfd_size_type amt = sizeof (struct elf_x86_64_link_hash_table);
820 ret = (struct elf_x86_64_link_hash_table *) bfd_malloc (amt);
824 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
825 elf_x86_64_link_hash_newfunc,
826 sizeof (struct elf_x86_64_link_hash_entry),
835 ret->plt_eh_frame = NULL;
836 ret->sym_cache.abfd = NULL;
837 ret->tlsdesc_plt = 0;
838 ret->tlsdesc_got = 0;
839 ret->tls_ld_got.refcount = 0;
840 ret->sgotplt_jump_table_size = 0;
841 ret->tls_module_base = NULL;
845 ret->r_info = elf64_r_info;
846 ret->r_sym = elf64_r_sym;
847 ret->pointer_r_type = R_X86_64_64;
848 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
849 ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
853 ret->r_info = elf32_r_info;
854 ret->r_sym = elf32_r_sym;
855 ret->pointer_r_type = R_X86_64_32;
856 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
857 ret->dynamic_interpreter_size = sizeof ELF32_DYNAMIC_INTERPRETER;
860 ret->loc_hash_table = htab_try_create (1024,
861 elf_x86_64_local_htab_hash,
862 elf_x86_64_local_htab_eq,
864 ret->loc_hash_memory = objalloc_create ();
865 if (!ret->loc_hash_table || !ret->loc_hash_memory)
871 return &ret->elf.root;
874 /* Destroy an X86-64 ELF linker hash table. */
877 elf_x86_64_link_hash_table_free (struct bfd_link_hash_table *hash)
879 struct elf_x86_64_link_hash_table *htab
880 = (struct elf_x86_64_link_hash_table *) hash;
882 if (htab->loc_hash_table)
883 htab_delete (htab->loc_hash_table);
884 if (htab->loc_hash_memory)
885 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
886 _bfd_generic_link_hash_table_free (hash);
889 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
890 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
894 elf_x86_64_create_dynamic_sections (bfd *dynobj,
895 struct bfd_link_info *info)
897 struct elf_x86_64_link_hash_table *htab;
899 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
902 htab = elf_x86_64_hash_table (info);
906 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
908 htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
911 || (!info->shared && !htab->srelbss))
914 if (!info->no_ld_generated_unwind_info
915 && bfd_get_section_by_name (dynobj, ".eh_frame") == NULL
916 && htab->elf.splt != NULL)
918 flagword flags = get_elf_backend_data (dynobj)->dynamic_sec_flags;
920 = bfd_make_section_with_flags (dynobj, ".eh_frame",
921 flags | SEC_READONLY);
922 if (htab->plt_eh_frame == NULL
923 || !bfd_set_section_alignment (dynobj, htab->plt_eh_frame, 3))
926 htab->plt_eh_frame->size = sizeof (elf_x86_64_eh_frame_plt);
927 htab->plt_eh_frame->contents
928 = bfd_alloc (dynobj, htab->plt_eh_frame->size);
929 memcpy (htab->plt_eh_frame->contents, elf_x86_64_eh_frame_plt,
930 sizeof (elf_x86_64_eh_frame_plt));
935 /* Copy the extra info we tack onto an elf_link_hash_entry. */
938 elf_x86_64_copy_indirect_symbol (struct bfd_link_info *info,
939 struct elf_link_hash_entry *dir,
940 struct elf_link_hash_entry *ind)
942 struct elf_x86_64_link_hash_entry *edir, *eind;
944 edir = (struct elf_x86_64_link_hash_entry *) dir;
945 eind = (struct elf_x86_64_link_hash_entry *) ind;
947 if (eind->dyn_relocs != NULL)
949 if (edir->dyn_relocs != NULL)
951 struct elf_dyn_relocs **pp;
952 struct elf_dyn_relocs *p;
954 /* Add reloc counts against the indirect sym to the direct sym
955 list. Merge any entries against the same section. */
956 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
958 struct elf_dyn_relocs *q;
960 for (q = edir->dyn_relocs; q != NULL; q = q->next)
961 if (q->sec == p->sec)
963 q->pc_count += p->pc_count;
964 q->count += p->count;
971 *pp = edir->dyn_relocs;
974 edir->dyn_relocs = eind->dyn_relocs;
975 eind->dyn_relocs = NULL;
978 if (ind->root.type == bfd_link_hash_indirect
979 && dir->got.refcount <= 0)
981 edir->tls_type = eind->tls_type;
982 eind->tls_type = GOT_UNKNOWN;
985 if (ELIMINATE_COPY_RELOCS
986 && ind->root.type != bfd_link_hash_indirect
987 && dir->dynamic_adjusted)
989 /* If called to transfer flags for a weakdef during processing
990 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
991 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
992 dir->ref_dynamic |= ind->ref_dynamic;
993 dir->ref_regular |= ind->ref_regular;
994 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
995 dir->needs_plt |= ind->needs_plt;
996 dir->pointer_equality_needed |= ind->pointer_equality_needed;
999 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1003 elf64_x86_64_elf_object_p (bfd *abfd)
1005 /* Set the right machine number for an x86-64 elf64 file. */
1006 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64);
1024 /* Return TRUE if the TLS access code sequence support transition
1028 elf_x86_64_check_tls_transition (bfd *abfd,
1029 struct bfd_link_info *info,
1032 Elf_Internal_Shdr *symtab_hdr,
1033 struct elf_link_hash_entry **sym_hashes,
1034 unsigned int r_type,
1035 const Elf_Internal_Rela *rel,
1036 const Elf_Internal_Rela *relend)
1039 unsigned long r_symndx;
1040 struct elf_link_hash_entry *h;
1042 struct elf_x86_64_link_hash_table *htab;
1044 /* Get the section contents. */
1045 if (contents == NULL)
1047 if (elf_section_data (sec)->this_hdr.contents != NULL)
1048 contents = elf_section_data (sec)->this_hdr.contents;
1051 /* FIXME: How to better handle error condition? */
1052 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1055 /* Cache the section contents for elf_link_input_bfd. */
1056 elf_section_data (sec)->this_hdr.contents = contents;
1060 htab = elf_x86_64_hash_table (info);
1061 offset = rel->r_offset;
1064 case R_X86_64_TLSGD:
1065 case R_X86_64_TLSLD:
1066 if ((rel + 1) >= relend)
1069 if (r_type == R_X86_64_TLSGD)
1071 /* Check transition from GD access model. For 64bit, only
1072 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1073 .word 0x6666; rex64; call __tls_get_addr
1074 can transit to different access model. For 32bit, only
1075 leaq foo@tlsgd(%rip), %rdi
1076 .word 0x6666; rex64; call __tls_get_addr
1077 can transit to different access model. */
1079 static x86_64_opcode32 call = { { 0x66, 0x66, 0x48, 0xe8 } };
1080 if ((offset + 12) > sec->size
1081 || bfd_get_32 (abfd, contents + offset + 4) != call.i)
1084 if (ABI_64_P (abfd))
1086 static x86_64_opcode32 leaq = { { 0x66, 0x48, 0x8d, 0x3d } };
1088 || bfd_get_32 (abfd, contents + offset - 4) != leaq.i)
1093 static x86_64_opcode16 lea = { { 0x8d, 0x3d } };
1095 || bfd_get_8 (abfd, contents + offset - 3) != 0x48
1096 || bfd_get_16 (abfd, contents + offset - 2) != lea.i)
1102 /* Check transition from LD access model. Only
1103 leaq foo@tlsld(%rip), %rdi;
1105 can transit to different access model. */
1107 static x86_64_opcode32 ld = { { 0x48, 0x8d, 0x3d, 0xe8 } };
1110 if (offset < 3 || (offset + 9) > sec->size)
1113 op.i = bfd_get_32 (abfd, contents + offset - 3);
1114 op.c[3] = bfd_get_8 (abfd, contents + offset + 4);
1119 r_symndx = htab->r_sym (rel[1].r_info);
1120 if (r_symndx < symtab_hdr->sh_info)
1123 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1124 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1125 may be versioned. */
1127 && h->root.root.string != NULL
1128 && (ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PC32
1129 || ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PLT32)
1130 && (strncmp (h->root.root.string,
1131 "__tls_get_addr", 14) == 0));
1133 case R_X86_64_GOTTPOFF:
1134 /* Check transition from IE access model:
1135 mov foo@gottpoff(%rip), %reg
1136 add foo@gottpoff(%rip), %reg
1139 /* Check REX prefix first. */
1140 if (offset >= 3 && (offset + 4) <= sec->size)
1142 val = bfd_get_8 (abfd, contents + offset - 3);
1143 if (val != 0x48 && val != 0x4c)
1145 /* X32 may have 0x44 REX prefix or no REX prefix. */
1146 if (ABI_64_P (abfd))
1152 /* X32 may not have any REX prefix. */
1153 if (ABI_64_P (abfd))
1155 if (offset < 2 || (offset + 3) > sec->size)
1159 val = bfd_get_8 (abfd, contents + offset - 2);
1160 if (val != 0x8b && val != 0x03)
1163 val = bfd_get_8 (abfd, contents + offset - 1);
1164 return (val & 0xc7) == 5;
1166 case R_X86_64_GOTPC32_TLSDESC:
1167 /* Check transition from GDesc access model:
1168 leaq x@tlsdesc(%rip), %rax
1170 Make sure it's a leaq adding rip to a 32-bit offset
1171 into any register, although it's probably almost always
1174 if (offset < 3 || (offset + 4) > sec->size)
1177 val = bfd_get_8 (abfd, contents + offset - 3);
1178 if ((val & 0xfb) != 0x48)
1181 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1184 val = bfd_get_8 (abfd, contents + offset - 1);
1185 return (val & 0xc7) == 0x05;
1187 case R_X86_64_TLSDESC_CALL:
1188 /* Check transition from GDesc access model:
1189 call *x@tlsdesc(%rax)
1191 if (offset + 2 <= sec->size)
1193 /* Make sure that it's a call *x@tlsdesc(%rax). */
1194 static x86_64_opcode16 call = { { 0xff, 0x10 } };
1195 return bfd_get_16 (abfd, contents + offset) == call.i;
1205 /* Return TRUE if the TLS access transition is OK or no transition
1206 will be performed. Update R_TYPE if there is a transition. */
1209 elf_x86_64_tls_transition (struct bfd_link_info *info, bfd *abfd,
1210 asection *sec, bfd_byte *contents,
1211 Elf_Internal_Shdr *symtab_hdr,
1212 struct elf_link_hash_entry **sym_hashes,
1213 unsigned int *r_type, int tls_type,
1214 const Elf_Internal_Rela *rel,
1215 const Elf_Internal_Rela *relend,
1216 struct elf_link_hash_entry *h,
1217 unsigned long r_symndx)
1219 unsigned int from_type = *r_type;
1220 unsigned int to_type = from_type;
1221 bfd_boolean check = TRUE;
1223 /* Skip TLS transition for functions. */
1225 && (h->type == STT_FUNC
1226 || h->type == STT_GNU_IFUNC))
1231 case R_X86_64_TLSGD:
1232 case R_X86_64_GOTPC32_TLSDESC:
1233 case R_X86_64_TLSDESC_CALL:
1234 case R_X86_64_GOTTPOFF:
1235 if (info->executable)
1238 to_type = R_X86_64_TPOFF32;
1240 to_type = R_X86_64_GOTTPOFF;
1243 /* When we are called from elf_x86_64_relocate_section,
1244 CONTENTS isn't NULL and there may be additional transitions
1245 based on TLS_TYPE. */
1246 if (contents != NULL)
1248 unsigned int new_to_type = to_type;
1250 if (info->executable
1253 && tls_type == GOT_TLS_IE)
1254 new_to_type = R_X86_64_TPOFF32;
1256 if (to_type == R_X86_64_TLSGD
1257 || to_type == R_X86_64_GOTPC32_TLSDESC
1258 || to_type == R_X86_64_TLSDESC_CALL)
1260 if (tls_type == GOT_TLS_IE)
1261 new_to_type = R_X86_64_GOTTPOFF;
1264 /* We checked the transition before when we were called from
1265 elf_x86_64_check_relocs. We only want to check the new
1266 transition which hasn't been checked before. */
1267 check = new_to_type != to_type && from_type == to_type;
1268 to_type = new_to_type;
1273 case R_X86_64_TLSLD:
1274 if (info->executable)
1275 to_type = R_X86_64_TPOFF32;
1282 /* Return TRUE if there is no transition. */
1283 if (from_type == to_type)
1286 /* Check if the transition can be performed. */
1288 && ! elf_x86_64_check_tls_transition (abfd, info, sec, contents,
1289 symtab_hdr, sym_hashes,
1290 from_type, rel, relend))
1292 reloc_howto_type *from, *to;
1295 from = elf_x86_64_rtype_to_howto (abfd, from_type);
1296 to = elf_x86_64_rtype_to_howto (abfd, to_type);
1299 name = h->root.root.string;
1302 struct elf_x86_64_link_hash_table *htab;
1304 htab = elf_x86_64_hash_table (info);
1309 Elf_Internal_Sym *isym;
1311 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1313 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1317 (*_bfd_error_handler)
1318 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1319 "in section `%A' failed"),
1320 abfd, sec, from->name, to->name, name,
1321 (unsigned long) rel->r_offset);
1322 bfd_set_error (bfd_error_bad_value);
1330 /* Look through the relocs for a section during the first phase, and
1331 calculate needed space in the global offset table, procedure
1332 linkage table, and dynamic reloc sections. */
1335 elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info,
1337 const Elf_Internal_Rela *relocs)
1339 struct elf_x86_64_link_hash_table *htab;
1340 Elf_Internal_Shdr *symtab_hdr;
1341 struct elf_link_hash_entry **sym_hashes;
1342 const Elf_Internal_Rela *rel;
1343 const Elf_Internal_Rela *rel_end;
1346 if (info->relocatable)
1349 BFD_ASSERT (is_x86_64_elf (abfd));
1351 htab = elf_x86_64_hash_table (info);
1355 symtab_hdr = &elf_symtab_hdr (abfd);
1356 sym_hashes = elf_sym_hashes (abfd);
1360 rel_end = relocs + sec->reloc_count;
1361 for (rel = relocs; rel < rel_end; rel++)
1363 unsigned int r_type;
1364 unsigned long r_symndx;
1365 struct elf_link_hash_entry *h;
1366 Elf_Internal_Sym *isym;
1369 r_symndx = htab->r_sym (rel->r_info);
1370 r_type = ELF32_R_TYPE (rel->r_info);
1372 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1374 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1379 if (r_symndx < symtab_hdr->sh_info)
1381 /* A local symbol. */
1382 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1387 /* Check relocation against local STT_GNU_IFUNC symbol. */
1388 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1390 h = elf_x86_64_get_local_sym_hash (htab, abfd, rel,
1395 /* Fake a STT_GNU_IFUNC symbol. */
1396 h->type = STT_GNU_IFUNC;
1399 h->forced_local = 1;
1400 h->root.type = bfd_link_hash_defined;
1408 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1409 while (h->root.type == bfd_link_hash_indirect
1410 || h->root.type == bfd_link_hash_warning)
1411 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1414 /* Check invalid x32 relocations. */
1415 if (!ABI_64_P (abfd))
1421 case R_X86_64_DTPOFF64:
1422 case R_X86_64_TPOFF64:
1424 case R_X86_64_GOTOFF64:
1425 case R_X86_64_GOT64:
1426 case R_X86_64_GOTPCREL64:
1427 case R_X86_64_GOTPC64:
1428 case R_X86_64_GOTPLT64:
1429 case R_X86_64_PLTOFF64:
1432 name = h->root.root.string;
1434 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1436 (*_bfd_error_handler)
1437 (_("%B: relocation %s against symbol `%s' isn't "
1438 "supported in x32 mode"), abfd,
1439 x86_64_elf_howto_table[r_type].name, name);
1440 bfd_set_error (bfd_error_bad_value);
1448 /* Create the ifunc sections for static executables. If we
1449 never see an indirect function symbol nor we are building
1450 a static executable, those sections will be empty and
1451 won't appear in output. */
1462 case R_X86_64_PLT32:
1463 case R_X86_64_GOTPCREL:
1464 case R_X86_64_GOTPCREL64:
1465 if (htab->elf.dynobj == NULL)
1466 htab->elf.dynobj = abfd;
1467 if (!_bfd_elf_create_ifunc_sections (htab->elf.dynobj, info))
1472 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
1473 it here if it is defined in a non-shared object. */
1474 if (h->type == STT_GNU_IFUNC
1477 /* It is referenced by a non-shared object. */
1481 /* STT_GNU_IFUNC symbol must go through PLT. */
1482 h->plt.refcount += 1;
1484 /* STT_GNU_IFUNC needs dynamic sections. */
1485 if (htab->elf.dynobj == NULL)
1486 htab->elf.dynobj = abfd;
1491 if (h->root.root.string)
1492 name = h->root.root.string;
1494 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1496 (*_bfd_error_handler)
1497 (_("%B: relocation %s against STT_GNU_IFUNC "
1498 "symbol `%s' isn't handled by %s"), abfd,
1499 x86_64_elf_howto_table[r_type].name,
1500 name, __FUNCTION__);
1501 bfd_set_error (bfd_error_bad_value);
1505 if (ABI_64_P (abfd))
1509 h->pointer_equality_needed = 1;
1512 /* We must copy these reloc types into the output
1513 file. Create a reloc section in dynobj and
1514 make room for this reloc. */
1515 sreloc = _bfd_elf_create_ifunc_dyn_reloc
1516 (abfd, info, sec, sreloc,
1517 &((struct elf_x86_64_link_hash_entry *) h)->dyn_relocs);
1528 if (r_type != R_X86_64_PC32
1529 && r_type != R_X86_64_PC64)
1530 h->pointer_equality_needed = 1;
1533 case R_X86_64_PLT32:
1536 case R_X86_64_GOTPCREL:
1537 case R_X86_64_GOTPCREL64:
1538 h->got.refcount += 1;
1539 if (htab->elf.sgot == NULL
1540 && !_bfd_elf_create_got_section (htab->elf.dynobj,
1550 if (! elf_x86_64_tls_transition (info, abfd, sec, NULL,
1551 symtab_hdr, sym_hashes,
1552 &r_type, GOT_UNKNOWN,
1553 rel, rel_end, h, r_symndx))
1558 case R_X86_64_TLSLD:
1559 htab->tls_ld_got.refcount += 1;
1562 case R_X86_64_TPOFF32:
1563 if (!info->executable && ABI_64_P (abfd))
1566 name = h->root.root.string;
1568 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1570 (*_bfd_error_handler)
1571 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1573 x86_64_elf_howto_table[r_type].name, name);
1574 bfd_set_error (bfd_error_bad_value);
1579 case R_X86_64_GOTTPOFF:
1580 if (!info->executable)
1581 info->flags |= DF_STATIC_TLS;
1584 case R_X86_64_GOT32:
1585 case R_X86_64_GOTPCREL:
1586 case R_X86_64_TLSGD:
1587 case R_X86_64_GOT64:
1588 case R_X86_64_GOTPCREL64:
1589 case R_X86_64_GOTPLT64:
1590 case R_X86_64_GOTPC32_TLSDESC:
1591 case R_X86_64_TLSDESC_CALL:
1592 /* This symbol requires a global offset table entry. */
1594 int tls_type, old_tls_type;
1598 default: tls_type = GOT_NORMAL; break;
1599 case R_X86_64_TLSGD: tls_type = GOT_TLS_GD; break;
1600 case R_X86_64_GOTTPOFF: tls_type = GOT_TLS_IE; break;
1601 case R_X86_64_GOTPC32_TLSDESC:
1602 case R_X86_64_TLSDESC_CALL:
1603 tls_type = GOT_TLS_GDESC; break;
1608 if (r_type == R_X86_64_GOTPLT64)
1610 /* This relocation indicates that we also need
1611 a PLT entry, as this is a function. We don't need
1612 a PLT entry for local symbols. */
1614 h->plt.refcount += 1;
1616 h->got.refcount += 1;
1617 old_tls_type = elf_x86_64_hash_entry (h)->tls_type;
1621 bfd_signed_vma *local_got_refcounts;
1623 /* This is a global offset table entry for a local symbol. */
1624 local_got_refcounts = elf_local_got_refcounts (abfd);
1625 if (local_got_refcounts == NULL)
1629 size = symtab_hdr->sh_info;
1630 size *= sizeof (bfd_signed_vma)
1631 + sizeof (bfd_vma) + sizeof (char);
1632 local_got_refcounts = ((bfd_signed_vma *)
1633 bfd_zalloc (abfd, size));
1634 if (local_got_refcounts == NULL)
1636 elf_local_got_refcounts (abfd) = local_got_refcounts;
1637 elf_x86_64_local_tlsdesc_gotent (abfd)
1638 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
1639 elf_x86_64_local_got_tls_type (abfd)
1640 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
1642 local_got_refcounts[r_symndx] += 1;
1644 = elf_x86_64_local_got_tls_type (abfd) [r_symndx];
1647 /* If a TLS symbol is accessed using IE at least once,
1648 there is no point to use dynamic model for it. */
1649 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1650 && (! GOT_TLS_GD_ANY_P (old_tls_type)
1651 || tls_type != GOT_TLS_IE))
1653 if (old_tls_type == GOT_TLS_IE && GOT_TLS_GD_ANY_P (tls_type))
1654 tls_type = old_tls_type;
1655 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1656 && GOT_TLS_GD_ANY_P (tls_type))
1657 tls_type |= old_tls_type;
1661 name = h->root.root.string;
1663 name = bfd_elf_sym_name (abfd, symtab_hdr,
1665 (*_bfd_error_handler)
1666 (_("%B: '%s' accessed both as normal and thread local symbol"),
1672 if (old_tls_type != tls_type)
1675 elf_x86_64_hash_entry (h)->tls_type = tls_type;
1677 elf_x86_64_local_got_tls_type (abfd) [r_symndx] = tls_type;
1682 case R_X86_64_GOTOFF64:
1683 case R_X86_64_GOTPC32:
1684 case R_X86_64_GOTPC64:
1686 if (htab->elf.sgot == NULL)
1688 if (htab->elf.dynobj == NULL)
1689 htab->elf.dynobj = abfd;
1690 if (!_bfd_elf_create_got_section (htab->elf.dynobj,
1696 case R_X86_64_PLT32:
1697 /* This symbol requires a procedure linkage table entry. We
1698 actually build the entry in adjust_dynamic_symbol,
1699 because this might be a case of linking PIC code which is
1700 never referenced by a dynamic object, in which case we
1701 don't need to generate a procedure linkage table entry
1704 /* If this is a local symbol, we resolve it directly without
1705 creating a procedure linkage table entry. */
1710 h->plt.refcount += 1;
1713 case R_X86_64_PLTOFF64:
1714 /* This tries to form the 'address' of a function relative
1715 to GOT. For global symbols we need a PLT entry. */
1719 h->plt.refcount += 1;
1724 if (!ABI_64_P (abfd))
1729 /* Let's help debug shared library creation. These relocs
1730 cannot be used in shared libs. Don't error out for
1731 sections we don't care about, such as debug sections or
1732 non-constant sections. */
1734 && (sec->flags & SEC_ALLOC) != 0
1735 && (sec->flags & SEC_READONLY) != 0)
1738 name = h->root.root.string;
1740 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1741 (*_bfd_error_handler)
1742 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1743 abfd, x86_64_elf_howto_table[r_type].name, name);
1744 bfd_set_error (bfd_error_bad_value);
1755 if (h != NULL && info->executable)
1757 /* If this reloc is in a read-only section, we might
1758 need a copy reloc. We can't check reliably at this
1759 stage whether the section is read-only, as input
1760 sections have not yet been mapped to output sections.
1761 Tentatively set the flag for now, and correct in
1762 adjust_dynamic_symbol. */
1765 /* We may need a .plt entry if the function this reloc
1766 refers to is in a shared lib. */
1767 h->plt.refcount += 1;
1768 if (r_type != R_X86_64_PC32 && r_type != R_X86_64_PC64)
1769 h->pointer_equality_needed = 1;
1772 /* If we are creating a shared library, and this is a reloc
1773 against a global symbol, or a non PC relative reloc
1774 against a local symbol, then we need to copy the reloc
1775 into the shared library. However, if we are linking with
1776 -Bsymbolic, we do not need to copy a reloc against a
1777 global symbol which is defined in an object we are
1778 including in the link (i.e., DEF_REGULAR is set). At
1779 this point we have not seen all the input files, so it is
1780 possible that DEF_REGULAR is not set now but will be set
1781 later (it is never cleared). In case of a weak definition,
1782 DEF_REGULAR may be cleared later by a strong definition in
1783 a shared library. We account for that possibility below by
1784 storing information in the relocs_copied field of the hash
1785 table entry. A similar situation occurs when creating
1786 shared libraries and symbol visibility changes render the
1789 If on the other hand, we are creating an executable, we
1790 may need to keep relocations for symbols satisfied by a
1791 dynamic library if we manage to avoid copy relocs for the
1794 && (sec->flags & SEC_ALLOC) != 0
1795 && (! IS_X86_64_PCREL_TYPE (r_type)
1797 && (! SYMBOLIC_BIND (info, h)
1798 || h->root.type == bfd_link_hash_defweak
1799 || !h->def_regular))))
1800 || (ELIMINATE_COPY_RELOCS
1802 && (sec->flags & SEC_ALLOC) != 0
1804 && (h->root.type == bfd_link_hash_defweak
1805 || !h->def_regular)))
1807 struct elf_dyn_relocs *p;
1808 struct elf_dyn_relocs **head;
1810 /* We must copy these reloc types into the output file.
1811 Create a reloc section in dynobj and make room for
1815 if (htab->elf.dynobj == NULL)
1816 htab->elf.dynobj = abfd;
1818 sreloc = _bfd_elf_make_dynamic_reloc_section
1819 (sec, htab->elf.dynobj, ABI_64_P (abfd) ? 3 : 2,
1820 abfd, /*rela?*/ TRUE);
1826 /* If this is a global symbol, we count the number of
1827 relocations we need for this symbol. */
1830 head = &((struct elf_x86_64_link_hash_entry *) h)->dyn_relocs;
1834 /* Track dynamic relocs needed for local syms too.
1835 We really need local syms available to do this
1840 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1845 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1849 /* Beware of type punned pointers vs strict aliasing
1851 vpp = &(elf_section_data (s)->local_dynrel);
1852 head = (struct elf_dyn_relocs **)vpp;
1856 if (p == NULL || p->sec != sec)
1858 bfd_size_type amt = sizeof *p;
1860 p = ((struct elf_dyn_relocs *)
1861 bfd_alloc (htab->elf.dynobj, amt));
1872 if (IS_X86_64_PCREL_TYPE (r_type))
1877 /* This relocation describes the C++ object vtable hierarchy.
1878 Reconstruct it for later use during GC. */
1879 case R_X86_64_GNU_VTINHERIT:
1880 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1884 /* This relocation describes which C++ vtable entries are actually
1885 used. Record for later use during GC. */
1886 case R_X86_64_GNU_VTENTRY:
1887 BFD_ASSERT (h != NULL);
1889 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1901 /* Return the section that should be marked against GC for a given
1905 elf_x86_64_gc_mark_hook (asection *sec,
1906 struct bfd_link_info *info,
1907 Elf_Internal_Rela *rel,
1908 struct elf_link_hash_entry *h,
1909 Elf_Internal_Sym *sym)
1912 switch (ELF32_R_TYPE (rel->r_info))
1914 case R_X86_64_GNU_VTINHERIT:
1915 case R_X86_64_GNU_VTENTRY:
1919 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1922 /* Update the got entry reference counts for the section being removed. */
1925 elf_x86_64_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1927 const Elf_Internal_Rela *relocs)
1929 struct elf_x86_64_link_hash_table *htab;
1930 Elf_Internal_Shdr *symtab_hdr;
1931 struct elf_link_hash_entry **sym_hashes;
1932 bfd_signed_vma *local_got_refcounts;
1933 const Elf_Internal_Rela *rel, *relend;
1935 if (info->relocatable)
1938 htab = elf_x86_64_hash_table (info);
1942 elf_section_data (sec)->local_dynrel = NULL;
1944 symtab_hdr = &elf_symtab_hdr (abfd);
1945 sym_hashes = elf_sym_hashes (abfd);
1946 local_got_refcounts = elf_local_got_refcounts (abfd);
1948 htab = elf_x86_64_hash_table (info);
1949 relend = relocs + sec->reloc_count;
1950 for (rel = relocs; rel < relend; rel++)
1952 unsigned long r_symndx;
1953 unsigned int r_type;
1954 struct elf_link_hash_entry *h = NULL;
1956 r_symndx = htab->r_sym (rel->r_info);
1957 if (r_symndx >= symtab_hdr->sh_info)
1959 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1960 while (h->root.type == bfd_link_hash_indirect
1961 || h->root.type == bfd_link_hash_warning)
1962 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1966 /* A local symbol. */
1967 Elf_Internal_Sym *isym;
1969 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1972 /* Check relocation against local STT_GNU_IFUNC symbol. */
1974 && ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1976 h = elf_x86_64_get_local_sym_hash (htab, abfd, rel, FALSE);
1984 struct elf_x86_64_link_hash_entry *eh;
1985 struct elf_dyn_relocs **pp;
1986 struct elf_dyn_relocs *p;
1988 eh = (struct elf_x86_64_link_hash_entry *) h;
1990 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1993 /* Everything must go for SEC. */
1999 r_type = ELF32_R_TYPE (rel->r_info);
2000 if (! elf_x86_64_tls_transition (info, abfd, sec, NULL,
2001 symtab_hdr, sym_hashes,
2002 &r_type, GOT_UNKNOWN,
2003 rel, relend, h, r_symndx))
2008 case R_X86_64_TLSLD:
2009 if (htab->tls_ld_got.refcount > 0)
2010 htab->tls_ld_got.refcount -= 1;
2013 case R_X86_64_TLSGD:
2014 case R_X86_64_GOTPC32_TLSDESC:
2015 case R_X86_64_TLSDESC_CALL:
2016 case R_X86_64_GOTTPOFF:
2017 case R_X86_64_GOT32:
2018 case R_X86_64_GOTPCREL:
2019 case R_X86_64_GOT64:
2020 case R_X86_64_GOTPCREL64:
2021 case R_X86_64_GOTPLT64:
2024 if (r_type == R_X86_64_GOTPLT64 && h->plt.refcount > 0)
2025 h->plt.refcount -= 1;
2026 if (h->got.refcount > 0)
2027 h->got.refcount -= 1;
2028 if (h->type == STT_GNU_IFUNC)
2030 if (h->plt.refcount > 0)
2031 h->plt.refcount -= 1;
2034 else if (local_got_refcounts != NULL)
2036 if (local_got_refcounts[r_symndx] > 0)
2037 local_got_refcounts[r_symndx] -= 1;
2051 && (h == NULL || h->type != STT_GNU_IFUNC))
2055 case R_X86_64_PLT32:
2056 case R_X86_64_PLTOFF64:
2059 if (h->plt.refcount > 0)
2060 h->plt.refcount -= 1;
2072 /* Adjust a symbol defined by a dynamic object and referenced by a
2073 regular object. The current definition is in some section of the
2074 dynamic object, but we're not including those sections. We have to
2075 change the definition to something the rest of the link can
2079 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info *info,
2080 struct elf_link_hash_entry *h)
2082 struct elf_x86_64_link_hash_table *htab;
2085 /* STT_GNU_IFUNC symbol must go through PLT. */
2086 if (h->type == STT_GNU_IFUNC)
2088 if (h->plt.refcount <= 0)
2090 h->plt.offset = (bfd_vma) -1;
2096 /* If this is a function, put it in the procedure linkage table. We
2097 will fill in the contents of the procedure linkage table later,
2098 when we know the address of the .got section. */
2099 if (h->type == STT_FUNC
2102 if (h->plt.refcount <= 0
2103 || SYMBOL_CALLS_LOCAL (info, h)
2104 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2105 && h->root.type == bfd_link_hash_undefweak))
2107 /* This case can occur if we saw a PLT32 reloc in an input
2108 file, but the symbol was never referred to by a dynamic
2109 object, or if all references were garbage collected. In
2110 such a case, we don't actually need to build a procedure
2111 linkage table, and we can just do a PC32 reloc instead. */
2112 h->plt.offset = (bfd_vma) -1;
2119 /* It's possible that we incorrectly decided a .plt reloc was
2120 needed for an R_X86_64_PC32 reloc to a non-function sym in
2121 check_relocs. We can't decide accurately between function and
2122 non-function syms in check-relocs; Objects loaded later in
2123 the link may change h->type. So fix it now. */
2124 h->plt.offset = (bfd_vma) -1;
2126 /* If this is a weak symbol, and there is a real definition, the
2127 processor independent code will have arranged for us to see the
2128 real definition first, and we can just use the same value. */
2129 if (h->u.weakdef != NULL)
2131 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2132 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2133 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2134 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2135 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
2136 h->non_got_ref = h->u.weakdef->non_got_ref;
2140 /* This is a reference to a symbol defined by a dynamic object which
2141 is not a function. */
2143 /* If we are creating a shared library, we must presume that the
2144 only references to the symbol are via the global offset table.
2145 For such cases we need not do anything here; the relocations will
2146 be handled correctly by relocate_section. */
2150 /* If there are no references to this symbol that do not use the
2151 GOT, we don't need to generate a copy reloc. */
2152 if (!h->non_got_ref)
2155 /* If -z nocopyreloc was given, we won't generate them either. */
2156 if (info->nocopyreloc)
2162 if (ELIMINATE_COPY_RELOCS)
2164 struct elf_x86_64_link_hash_entry * eh;
2165 struct elf_dyn_relocs *p;
2167 eh = (struct elf_x86_64_link_hash_entry *) h;
2168 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2170 s = p->sec->output_section;
2171 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2175 /* If we didn't find any dynamic relocs in read-only sections, then
2176 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2186 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
2187 h->root.root.string);
2191 /* We must allocate the symbol in our .dynbss section, which will
2192 become part of the .bss section of the executable. There will be
2193 an entry for this symbol in the .dynsym section. The dynamic
2194 object will contain position independent code, so all references
2195 from the dynamic object to this symbol will go through the global
2196 offset table. The dynamic linker will use the .dynsym entry to
2197 determine the address it must put in the global offset table, so
2198 both the dynamic object and the regular object will refer to the
2199 same memory location for the variable. */
2201 htab = elf_x86_64_hash_table (info);
2205 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2206 to copy the initial value out of the dynamic object and into the
2207 runtime process image. */
2208 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2210 const struct elf_backend_data *bed;
2211 bed = get_elf_backend_data (info->output_bfd);
2212 htab->srelbss->size += bed->s->sizeof_rela;
2218 return _bfd_elf_adjust_dynamic_copy (h, s);
2221 /* Allocate space in .plt, .got and associated reloc sections for
2225 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2227 struct bfd_link_info *info;
2228 struct elf_x86_64_link_hash_table *htab;
2229 struct elf_x86_64_link_hash_entry *eh;
2230 struct elf_dyn_relocs *p;
2231 const struct elf_backend_data *bed;
2233 if (h->root.type == bfd_link_hash_indirect)
2236 eh = (struct elf_x86_64_link_hash_entry *) h;
2238 info = (struct bfd_link_info *) inf;
2239 htab = elf_x86_64_hash_table (info);
2242 bed = get_elf_backend_data (info->output_bfd);
2244 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2245 here if it is defined and referenced in a non-shared object. */
2246 if (h->type == STT_GNU_IFUNC
2248 return _bfd_elf_allocate_ifunc_dyn_relocs (info, h,
2252 else if (htab->elf.dynamic_sections_created
2253 && h->plt.refcount > 0)
2255 /* Make sure this symbol is output as a dynamic symbol.
2256 Undefined weak syms won't yet be marked as dynamic. */
2257 if (h->dynindx == -1
2258 && !h->forced_local)
2260 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2265 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2267 asection *s = htab->elf.splt;
2269 /* If this is the first .plt entry, make room for the special
2272 s->size += PLT_ENTRY_SIZE;
2274 h->plt.offset = s->size;
2276 /* If this symbol is not defined in a regular file, and we are
2277 not generating a shared library, then set the symbol to this
2278 location in the .plt. This is required to make function
2279 pointers compare as equal between the normal executable and
2280 the shared library. */
2284 h->root.u.def.section = s;
2285 h->root.u.def.value = h->plt.offset;
2288 /* Make room for this entry. */
2289 s->size += PLT_ENTRY_SIZE;
2291 /* We also need to make an entry in the .got.plt section, which
2292 will be placed in the .got section by the linker script. */
2293 htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
2295 /* We also need to make an entry in the .rela.plt section. */
2296 htab->elf.srelplt->size += bed->s->sizeof_rela;
2297 htab->elf.srelplt->reloc_count++;
2301 h->plt.offset = (bfd_vma) -1;
2307 h->plt.offset = (bfd_vma) -1;
2311 eh->tlsdesc_got = (bfd_vma) -1;
2313 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2314 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2315 if (h->got.refcount > 0
2318 && elf_x86_64_hash_entry (h)->tls_type == GOT_TLS_IE)
2320 h->got.offset = (bfd_vma) -1;
2322 else if (h->got.refcount > 0)
2326 int tls_type = elf_x86_64_hash_entry (h)->tls_type;
2328 /* Make sure this symbol is output as a dynamic symbol.
2329 Undefined weak syms won't yet be marked as dynamic. */
2330 if (h->dynindx == -1
2331 && !h->forced_local)
2333 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2337 if (GOT_TLS_GDESC_P (tls_type))
2339 eh->tlsdesc_got = htab->elf.sgotplt->size
2340 - elf_x86_64_compute_jump_table_size (htab);
2341 htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
2342 h->got.offset = (bfd_vma) -2;
2344 if (! GOT_TLS_GDESC_P (tls_type)
2345 || GOT_TLS_GD_P (tls_type))
2348 h->got.offset = s->size;
2349 s->size += GOT_ENTRY_SIZE;
2350 if (GOT_TLS_GD_P (tls_type))
2351 s->size += GOT_ENTRY_SIZE;
2353 dyn = htab->elf.dynamic_sections_created;
2354 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2356 R_X86_64_GOTTPOFF needs one dynamic relocation. */
2357 if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
2358 || tls_type == GOT_TLS_IE)
2359 htab->elf.srelgot->size += bed->s->sizeof_rela;
2360 else if (GOT_TLS_GD_P (tls_type))
2361 htab->elf.srelgot->size += 2 * bed->s->sizeof_rela;
2362 else if (! GOT_TLS_GDESC_P (tls_type)
2363 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2364 || h->root.type != bfd_link_hash_undefweak)
2366 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
2367 htab->elf.srelgot->size += bed->s->sizeof_rela;
2368 if (GOT_TLS_GDESC_P (tls_type))
2370 htab->elf.srelplt->size += bed->s->sizeof_rela;
2371 htab->tlsdesc_plt = (bfd_vma) -1;
2375 h->got.offset = (bfd_vma) -1;
2377 if (eh->dyn_relocs == NULL)
2380 /* In the shared -Bsymbolic case, discard space allocated for
2381 dynamic pc-relative relocs against symbols which turn out to be
2382 defined in regular objects. For the normal shared case, discard
2383 space for pc-relative relocs that have become local due to symbol
2384 visibility changes. */
2388 /* Relocs that use pc_count are those that appear on a call
2389 insn, or certain REL relocs that can generated via assembly.
2390 We want calls to protected symbols to resolve directly to the
2391 function rather than going via the plt. If people want
2392 function pointer comparisons to work as expected then they
2393 should avoid writing weird assembly. */
2394 if (SYMBOL_CALLS_LOCAL (info, h))
2396 struct elf_dyn_relocs **pp;
2398 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2400 p->count -= p->pc_count;
2409 /* Also discard relocs on undefined weak syms with non-default
2411 if (eh->dyn_relocs != NULL
2412 && h->root.type == bfd_link_hash_undefweak)
2414 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2415 eh->dyn_relocs = NULL;
2417 /* Make sure undefined weak symbols are output as a dynamic
2419 else if (h->dynindx == -1
2420 && ! h->forced_local
2421 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2426 else if (ELIMINATE_COPY_RELOCS)
2428 /* For the non-shared case, discard space for relocs against
2429 symbols which turn out to need copy relocs or are not
2435 || (htab->elf.dynamic_sections_created
2436 && (h->root.type == bfd_link_hash_undefweak
2437 || h->root.type == bfd_link_hash_undefined))))
2439 /* Make sure this symbol is output as a dynamic symbol.
2440 Undefined weak syms won't yet be marked as dynamic. */
2441 if (h->dynindx == -1
2442 && ! h->forced_local
2443 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2446 /* If that succeeded, we know we'll be keeping all the
2448 if (h->dynindx != -1)
2452 eh->dyn_relocs = NULL;
2457 /* Finally, allocate space. */
2458 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2462 sreloc = elf_section_data (p->sec)->sreloc;
2464 BFD_ASSERT (sreloc != NULL);
2466 sreloc->size += p->count * bed->s->sizeof_rela;
2472 /* Allocate space in .plt, .got and associated reloc sections for
2473 local dynamic relocs. */
2476 elf_x86_64_allocate_local_dynrelocs (void **slot, void *inf)
2478 struct elf_link_hash_entry *h
2479 = (struct elf_link_hash_entry *) *slot;
2481 if (h->type != STT_GNU_IFUNC
2485 || h->root.type != bfd_link_hash_defined)
2488 return elf_x86_64_allocate_dynrelocs (h, inf);
2491 /* Find any dynamic relocs that apply to read-only sections. */
2494 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry *h,
2497 struct elf_x86_64_link_hash_entry *eh;
2498 struct elf_dyn_relocs *p;
2500 /* Skip local IFUNC symbols. */
2501 if (h->forced_local && h->type == STT_GNU_IFUNC)
2504 eh = (struct elf_x86_64_link_hash_entry *) h;
2505 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2507 asection *s = p->sec->output_section;
2509 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2511 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2513 info->flags |= DF_TEXTREL;
2515 if (info->warn_shared_textrel && info->shared)
2516 info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2517 p->sec->owner, h->root.root.string,
2520 /* Not an error, just cut short the traversal. */
2527 /* Set the sizes of the dynamic sections. */
2530 elf_x86_64_size_dynamic_sections (bfd *output_bfd,
2531 struct bfd_link_info *info)
2533 struct elf_x86_64_link_hash_table *htab;
2538 const struct elf_backend_data *bed;
2540 htab = elf_x86_64_hash_table (info);
2543 bed = get_elf_backend_data (output_bfd);
2545 dynobj = htab->elf.dynobj;
2549 if (htab->elf.dynamic_sections_created)
2551 /* Set the contents of the .interp section to the interpreter. */
2552 if (info->executable)
2554 s = bfd_get_section_by_name (dynobj, ".interp");
2557 s->size = htab->dynamic_interpreter_size;
2558 s->contents = (unsigned char *) htab->dynamic_interpreter;
2562 /* Set up .got offsets for local syms, and space for local dynamic
2564 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2566 bfd_signed_vma *local_got;
2567 bfd_signed_vma *end_local_got;
2568 char *local_tls_type;
2569 bfd_vma *local_tlsdesc_gotent;
2570 bfd_size_type locsymcount;
2571 Elf_Internal_Shdr *symtab_hdr;
2574 if (! is_x86_64_elf (ibfd))
2577 for (s = ibfd->sections; s != NULL; s = s->next)
2579 struct elf_dyn_relocs *p;
2581 for (p = (struct elf_dyn_relocs *)
2582 (elf_section_data (s)->local_dynrel);
2586 if (!bfd_is_abs_section (p->sec)
2587 && bfd_is_abs_section (p->sec->output_section))
2589 /* Input section has been discarded, either because
2590 it is a copy of a linkonce section or due to
2591 linker script /DISCARD/, so we'll be discarding
2594 else if (p->count != 0)
2596 srel = elf_section_data (p->sec)->sreloc;
2597 srel->size += p->count * bed->s->sizeof_rela;
2598 if ((p->sec->output_section->flags & SEC_READONLY) != 0
2599 && (info->flags & DF_TEXTREL) == 0)
2601 info->flags |= DF_TEXTREL;
2602 if (info->warn_shared_textrel && info->shared)
2603 info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
2604 p->sec->owner, p->sec);
2610 local_got = elf_local_got_refcounts (ibfd);
2614 symtab_hdr = &elf_symtab_hdr (ibfd);
2615 locsymcount = symtab_hdr->sh_info;
2616 end_local_got = local_got + locsymcount;
2617 local_tls_type = elf_x86_64_local_got_tls_type (ibfd);
2618 local_tlsdesc_gotent = elf_x86_64_local_tlsdesc_gotent (ibfd);
2620 srel = htab->elf.srelgot;
2621 for (; local_got < end_local_got;
2622 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
2624 *local_tlsdesc_gotent = (bfd_vma) -1;
2627 if (GOT_TLS_GDESC_P (*local_tls_type))
2629 *local_tlsdesc_gotent = htab->elf.sgotplt->size
2630 - elf_x86_64_compute_jump_table_size (htab);
2631 htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
2632 *local_got = (bfd_vma) -2;
2634 if (! GOT_TLS_GDESC_P (*local_tls_type)
2635 || GOT_TLS_GD_P (*local_tls_type))
2637 *local_got = s->size;
2638 s->size += GOT_ENTRY_SIZE;
2639 if (GOT_TLS_GD_P (*local_tls_type))
2640 s->size += GOT_ENTRY_SIZE;
2643 || GOT_TLS_GD_ANY_P (*local_tls_type)
2644 || *local_tls_type == GOT_TLS_IE)
2646 if (GOT_TLS_GDESC_P (*local_tls_type))
2648 htab->elf.srelplt->size
2649 += bed->s->sizeof_rela;
2650 htab->tlsdesc_plt = (bfd_vma) -1;
2652 if (! GOT_TLS_GDESC_P (*local_tls_type)
2653 || GOT_TLS_GD_P (*local_tls_type))
2654 srel->size += bed->s->sizeof_rela;
2658 *local_got = (bfd_vma) -1;
2662 if (htab->tls_ld_got.refcount > 0)
2664 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
2666 htab->tls_ld_got.offset = htab->elf.sgot->size;
2667 htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
2668 htab->elf.srelgot->size += bed->s->sizeof_rela;
2671 htab->tls_ld_got.offset = -1;
2673 /* Allocate global sym .plt and .got entries, and space for global
2674 sym dynamic relocs. */
2675 elf_link_hash_traverse (&htab->elf, elf_x86_64_allocate_dynrelocs,
2678 /* Allocate .plt and .got entries, and space for local symbols. */
2679 htab_traverse (htab->loc_hash_table,
2680 elf_x86_64_allocate_local_dynrelocs,
2683 /* For every jump slot reserved in the sgotplt, reloc_count is
2684 incremented. However, when we reserve space for TLS descriptors,
2685 it's not incremented, so in order to compute the space reserved
2686 for them, it suffices to multiply the reloc count by the jump
2688 if (htab->elf.srelplt)
2689 htab->sgotplt_jump_table_size
2690 = elf_x86_64_compute_jump_table_size (htab);
2692 if (htab->tlsdesc_plt)
2694 /* If we're not using lazy TLS relocations, don't generate the
2695 PLT and GOT entries they require. */
2696 if ((info->flags & DF_BIND_NOW))
2697 htab->tlsdesc_plt = 0;
2700 htab->tlsdesc_got = htab->elf.sgot->size;
2701 htab->elf.sgot->size += GOT_ENTRY_SIZE;
2702 /* Reserve room for the initial entry.
2703 FIXME: we could probably do away with it in this case. */
2704 if (htab->elf.splt->size == 0)
2705 htab->elf.splt->size += PLT_ENTRY_SIZE;
2706 htab->tlsdesc_plt = htab->elf.splt->size;
2707 htab->elf.splt->size += PLT_ENTRY_SIZE;
2711 if (htab->elf.sgotplt)
2713 struct elf_link_hash_entry *got;
2714 got = elf_link_hash_lookup (elf_hash_table (info),
2715 "_GLOBAL_OFFSET_TABLE_",
2716 FALSE, FALSE, FALSE);
2718 /* Don't allocate .got.plt section if there are no GOT nor PLT
2719 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
2721 || !got->ref_regular_nonweak)
2722 && (htab->elf.sgotplt->size
2723 == get_elf_backend_data (output_bfd)->got_header_size)
2724 && (htab->elf.splt == NULL
2725 || htab->elf.splt->size == 0)
2726 && (htab->elf.sgot == NULL
2727 || htab->elf.sgot->size == 0)
2728 && (htab->elf.iplt == NULL
2729 || htab->elf.iplt->size == 0)
2730 && (htab->elf.igotplt == NULL
2731 || htab->elf.igotplt->size == 0))
2732 htab->elf.sgotplt->size = 0;
2735 /* We now have determined the sizes of the various dynamic sections.
2736 Allocate memory for them. */
2738 for (s = dynobj->sections; s != NULL; s = s->next)
2740 if ((s->flags & SEC_LINKER_CREATED) == 0)
2743 if (s == htab->elf.splt
2744 || s == htab->elf.sgot
2745 || s == htab->elf.sgotplt
2746 || s == htab->elf.iplt
2747 || s == htab->elf.igotplt
2748 || s == htab->sdynbss)
2750 /* Strip this section if we don't need it; see the
2753 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2755 if (s->size != 0 && s != htab->elf.srelplt)
2758 /* We use the reloc_count field as a counter if we need
2759 to copy relocs into the output file. */
2760 if (s != htab->elf.srelplt)
2765 /* It's not one of our sections, so don't allocate space. */
2771 /* If we don't need this section, strip it from the
2772 output file. This is mostly to handle .rela.bss and
2773 .rela.plt. We must create both sections in
2774 create_dynamic_sections, because they must be created
2775 before the linker maps input sections to output
2776 sections. The linker does that before
2777 adjust_dynamic_symbol is called, and it is that
2778 function which decides whether anything needs to go
2779 into these sections. */
2781 s->flags |= SEC_EXCLUDE;
2785 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2788 /* Allocate memory for the section contents. We use bfd_zalloc
2789 here in case unused entries are not reclaimed before the
2790 section's contents are written out. This should not happen,
2791 but this way if it does, we get a R_X86_64_NONE reloc instead
2793 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2794 if (s->contents == NULL)
2798 if (htab->plt_eh_frame != NULL
2799 && htab->elf.splt != NULL
2800 && htab->elf.splt->size != 0
2801 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0)
2802 bfd_put_32 (dynobj, htab->elf.splt->size,
2803 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
2805 if (htab->elf.dynamic_sections_created)
2807 /* Add some entries to the .dynamic section. We fill in the
2808 values later, in elf_x86_64_finish_dynamic_sections, but we
2809 must add the entries now so that we get the correct size for
2810 the .dynamic section. The DT_DEBUG entry is filled in by the
2811 dynamic linker and used by the debugger. */
2812 #define add_dynamic_entry(TAG, VAL) \
2813 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2815 if (info->executable)
2817 if (!add_dynamic_entry (DT_DEBUG, 0))
2821 if (htab->elf.splt->size != 0)
2823 if (!add_dynamic_entry (DT_PLTGOT, 0)
2824 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2825 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2826 || !add_dynamic_entry (DT_JMPREL, 0))
2829 if (htab->tlsdesc_plt
2830 && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
2831 || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
2837 if (!add_dynamic_entry (DT_RELA, 0)
2838 || !add_dynamic_entry (DT_RELASZ, 0)
2839 || !add_dynamic_entry (DT_RELAENT, bed->s->sizeof_rela))
2842 /* If any dynamic relocs apply to a read-only section,
2843 then we need a DT_TEXTREL entry. */
2844 if ((info->flags & DF_TEXTREL) == 0)
2845 elf_link_hash_traverse (&htab->elf,
2846 elf_x86_64_readonly_dynrelocs,
2849 if ((info->flags & DF_TEXTREL) != 0)
2851 if (!add_dynamic_entry (DT_TEXTREL, 0))
2856 #undef add_dynamic_entry
2862 elf_x86_64_always_size_sections (bfd *output_bfd,
2863 struct bfd_link_info *info)
2865 asection *tls_sec = elf_hash_table (info)->tls_sec;
2869 struct elf_link_hash_entry *tlsbase;
2871 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
2872 "_TLS_MODULE_BASE_",
2873 FALSE, FALSE, FALSE);
2875 if (tlsbase && tlsbase->type == STT_TLS)
2877 struct elf_x86_64_link_hash_table *htab;
2878 struct bfd_link_hash_entry *bh = NULL;
2879 const struct elf_backend_data *bed
2880 = get_elf_backend_data (output_bfd);
2882 htab = elf_x86_64_hash_table (info);
2886 if (!(_bfd_generic_link_add_one_symbol
2887 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
2888 tls_sec, 0, NULL, FALSE,
2889 bed->collect, &bh)))
2892 htab->tls_module_base = bh;
2894 tlsbase = (struct elf_link_hash_entry *)bh;
2895 tlsbase->def_regular = 1;
2896 tlsbase->other = STV_HIDDEN;
2897 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
2904 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
2905 executables. Rather than setting it to the beginning of the TLS
2906 section, we have to set it to the end. This function may be called
2907 multiple times, it is idempotent. */
2910 elf_x86_64_set_tls_module_base (struct bfd_link_info *info)
2912 struct elf_x86_64_link_hash_table *htab;
2913 struct bfd_link_hash_entry *base;
2915 if (!info->executable)
2918 htab = elf_x86_64_hash_table (info);
2922 base = htab->tls_module_base;
2926 base->u.def.value = htab->elf.tls_size;
2929 /* Return the base VMA address which should be subtracted from real addresses
2930 when resolving @dtpoff relocation.
2931 This is PT_TLS segment p_vaddr. */
2934 elf_x86_64_dtpoff_base (struct bfd_link_info *info)
2936 /* If tls_sec is NULL, we should have signalled an error already. */
2937 if (elf_hash_table (info)->tls_sec == NULL)
2939 return elf_hash_table (info)->tls_sec->vma;
2942 /* Return the relocation value for @tpoff relocation
2943 if STT_TLS virtual address is ADDRESS. */
2946 elf_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address)
2948 struct elf_link_hash_table *htab = elf_hash_table (info);
2949 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
2950 bfd_vma static_tls_size;
2952 /* If tls_segment is NULL, we should have signalled an error already. */
2953 if (htab->tls_sec == NULL)
2956 /* Consider special static TLS alignment requirements. */
2957 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
2958 return address - static_tls_size - htab->tls_sec->vma;
2961 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
2965 is_32bit_relative_branch (bfd_byte *contents, bfd_vma offset)
2967 /* Opcode Instruction
2970 0x0f 0x8x conditional jump */
2972 && (contents [offset - 1] == 0xe8
2973 || contents [offset - 1] == 0xe9))
2975 && contents [offset - 2] == 0x0f
2976 && (contents [offset - 1] & 0xf0) == 0x80));
2979 /* Relocate an x86_64 ELF section. */
2982 elf_x86_64_relocate_section (bfd *output_bfd,
2983 struct bfd_link_info *info,
2985 asection *input_section,
2987 Elf_Internal_Rela *relocs,
2988 Elf_Internal_Sym *local_syms,
2989 asection **local_sections)
2991 struct elf_x86_64_link_hash_table *htab;
2992 Elf_Internal_Shdr *symtab_hdr;
2993 struct elf_link_hash_entry **sym_hashes;
2994 bfd_vma *local_got_offsets;
2995 bfd_vma *local_tlsdesc_gotents;
2996 Elf_Internal_Rela *rel;
2997 Elf_Internal_Rela *relend;
2999 BFD_ASSERT (is_x86_64_elf (input_bfd));
3001 htab = elf_x86_64_hash_table (info);
3004 symtab_hdr = &elf_symtab_hdr (input_bfd);
3005 sym_hashes = elf_sym_hashes (input_bfd);
3006 local_got_offsets = elf_local_got_offsets (input_bfd);
3007 local_tlsdesc_gotents = elf_x86_64_local_tlsdesc_gotent (input_bfd);
3009 elf_x86_64_set_tls_module_base (info);
3012 relend = relocs + input_section->reloc_count;
3013 for (; rel < relend; rel++)
3015 unsigned int r_type;
3016 reloc_howto_type *howto;
3017 unsigned long r_symndx;
3018 struct elf_link_hash_entry *h;
3019 Elf_Internal_Sym *sym;
3021 bfd_vma off, offplt;
3023 bfd_boolean unresolved_reloc;
3024 bfd_reloc_status_type r;
3028 r_type = ELF32_R_TYPE (rel->r_info);
3029 if (r_type == (int) R_X86_64_GNU_VTINHERIT
3030 || r_type == (int) R_X86_64_GNU_VTENTRY)
3033 if (r_type >= R_X86_64_max)
3035 bfd_set_error (bfd_error_bad_value);
3039 if (r_type != (int) R_X86_64_32
3040 || ABI_64_P (output_bfd))
3041 howto = x86_64_elf_howto_table + r_type;
3043 howto = (x86_64_elf_howto_table
3044 + ARRAY_SIZE (x86_64_elf_howto_table) - 1);
3045 r_symndx = htab->r_sym (rel->r_info);
3049 unresolved_reloc = FALSE;
3050 if (r_symndx < symtab_hdr->sh_info)
3052 sym = local_syms + r_symndx;
3053 sec = local_sections[r_symndx];
3055 relocation = _bfd_elf_rela_local_sym (output_bfd, sym,
3058 /* Relocate against local STT_GNU_IFUNC symbol. */
3059 if (!info->relocatable
3060 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3062 h = elf_x86_64_get_local_sym_hash (htab, input_bfd,
3067 /* Set STT_GNU_IFUNC symbol value. */
3068 h->root.u.def.value = sym->st_value;
3069 h->root.u.def.section = sec;
3074 bfd_boolean warned ATTRIBUTE_UNUSED;
3076 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3077 r_symndx, symtab_hdr, sym_hashes,
3079 unresolved_reloc, warned);
3082 if (sec != NULL && elf_discarded_section (sec))
3083 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3084 rel, relend, howto, contents);
3086 if (info->relocatable)
3089 if (rel->r_addend == 0
3090 && r_type == R_X86_64_64
3091 && !ABI_64_P (output_bfd))
3093 /* For x32, treat R_X86_64_64 like R_X86_64_32 and zero-extend
3094 it to 64bit if addend is zero. */
3095 r_type = R_X86_64_32;
3096 memset (contents + rel->r_offset + 4, 0, 4);
3099 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3100 it here if it is defined in a non-shared object. */
3102 && h->type == STT_GNU_IFUNC
3109 if ((input_section->flags & SEC_ALLOC) == 0
3110 || h->plt.offset == (bfd_vma) -1)
3113 /* STT_GNU_IFUNC symbol must go through PLT. */
3114 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
3115 relocation = (plt->output_section->vma
3116 + plt->output_offset + h->plt.offset);
3121 if (h->root.root.string)
3122 name = h->root.root.string;
3124 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3126 (*_bfd_error_handler)
3127 (_("%B: relocation %s against STT_GNU_IFUNC "
3128 "symbol `%s' isn't handled by %s"), input_bfd,
3129 x86_64_elf_howto_table[r_type].name,
3130 name, __FUNCTION__);
3131 bfd_set_error (bfd_error_bad_value);
3140 if (ABI_64_P (output_bfd))
3144 if (rel->r_addend != 0)
3146 if (h->root.root.string)
3147 name = h->root.root.string;
3149 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
3151 (*_bfd_error_handler)
3152 (_("%B: relocation %s against STT_GNU_IFUNC "
3153 "symbol `%s' has non-zero addend: %d"),
3154 input_bfd, x86_64_elf_howto_table[r_type].name,
3155 name, rel->r_addend);
3156 bfd_set_error (bfd_error_bad_value);
3160 /* Generate dynamic relcoation only when there is a
3161 non-GOF reference in a shared object. */
3162 if (info->shared && h->non_got_ref)
3164 Elf_Internal_Rela outrel;
3167 /* Need a dynamic relocation to get the real function
3169 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
3173 if (outrel.r_offset == (bfd_vma) -1
3174 || outrel.r_offset == (bfd_vma) -2)
3177 outrel.r_offset += (input_section->output_section->vma
3178 + input_section->output_offset);
3180 if (h->dynindx == -1
3182 || info->executable)
3184 /* This symbol is resolved locally. */
3185 outrel.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
3186 outrel.r_addend = (h->root.u.def.value
3187 + h->root.u.def.section->output_section->vma
3188 + h->root.u.def.section->output_offset);
3192 outrel.r_info = htab->r_info (h->dynindx, r_type);
3193 outrel.r_addend = 0;
3196 sreloc = htab->elf.irelifunc;
3197 elf_append_rela (output_bfd, sreloc, &outrel);
3199 /* If this reloc is against an external symbol, we
3200 do not want to fiddle with the addend. Otherwise,
3201 we need to include the symbol value so that it
3202 becomes an addend for the dynamic reloc. For an
3203 internal symbol, we have updated addend. */
3209 case R_X86_64_PLT32:
3212 case R_X86_64_GOTPCREL:
3213 case R_X86_64_GOTPCREL64:
3214 base_got = htab->elf.sgot;
3215 off = h->got.offset;
3217 if (base_got == NULL)
3220 if (off == (bfd_vma) -1)
3222 /* We can't use h->got.offset here to save state, or
3223 even just remember the offset, as finish_dynamic_symbol
3224 would use that as offset into .got. */
3226 if (htab->elf.splt != NULL)
3228 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3229 off = (plt_index + 3) * GOT_ENTRY_SIZE;
3230 base_got = htab->elf.sgotplt;
3234 plt_index = h->plt.offset / PLT_ENTRY_SIZE;
3235 off = plt_index * GOT_ENTRY_SIZE;
3236 base_got = htab->elf.igotplt;
3239 if (h->dynindx == -1
3243 /* This references the local defitionion. We must
3244 initialize this entry in the global offset table.
3245 Since the offset must always be a multiple of 8,
3246 we use the least significant bit to record
3247 whether we have initialized it already.
3249 When doing a dynamic link, we create a .rela.got
3250 relocation entry to initialize the value. This
3251 is done in the finish_dynamic_symbol routine. */
3256 bfd_put_64 (output_bfd, relocation,
3257 base_got->contents + off);
3258 /* Note that this is harmless for the GOTPLT64
3259 case, as -1 | 1 still is -1. */
3265 relocation = (base_got->output_section->vma
3266 + base_got->output_offset + off);
3272 /* When generating a shared object, the relocations handled here are
3273 copied into the output file to be resolved at run time. */
3276 case R_X86_64_GOT32:
3277 case R_X86_64_GOT64:
3278 /* Relocation is to the entry for this symbol in the global
3280 case R_X86_64_GOTPCREL:
3281 case R_X86_64_GOTPCREL64:
3282 /* Use global offset table entry as symbol value. */
3283 case R_X86_64_GOTPLT64:
3284 /* This is the same as GOT64 for relocation purposes, but
3285 indicates the existence of a PLT entry. The difficulty is,
3286 that we must calculate the GOT slot offset from the PLT
3287 offset, if this symbol got a PLT entry (it was global).
3288 Additionally if it's computed from the PLT entry, then that
3289 GOT offset is relative to .got.plt, not to .got. */
3290 base_got = htab->elf.sgot;
3292 if (htab->elf.sgot == NULL)
3299 off = h->got.offset;
3301 && h->plt.offset != (bfd_vma)-1
3302 && off == (bfd_vma)-1)
3304 /* We can't use h->got.offset here to save
3305 state, or even just remember the offset, as
3306 finish_dynamic_symbol would use that as offset into
3308 bfd_vma plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3309 off = (plt_index + 3) * GOT_ENTRY_SIZE;
3310 base_got = htab->elf.sgotplt;
3313 dyn = htab->elf.dynamic_sections_created;
3315 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3317 && SYMBOL_REFERENCES_LOCAL (info, h))
3318 || (ELF_ST_VISIBILITY (h->other)
3319 && h->root.type == bfd_link_hash_undefweak))
3321 /* This is actually a static link, or it is a -Bsymbolic
3322 link and the symbol is defined locally, or the symbol
3323 was forced to be local because of a version file. We
3324 must initialize this entry in the global offset table.
3325 Since the offset must always be a multiple of 8, we
3326 use the least significant bit to record whether we
3327 have initialized it already.
3329 When doing a dynamic link, we create a .rela.got
3330 relocation entry to initialize the value. This is
3331 done in the finish_dynamic_symbol routine. */
3336 bfd_put_64 (output_bfd, relocation,
3337 base_got->contents + off);
3338 /* Note that this is harmless for the GOTPLT64 case,
3339 as -1 | 1 still is -1. */
3344 unresolved_reloc = FALSE;
3348 if (local_got_offsets == NULL)
3351 off = local_got_offsets[r_symndx];
3353 /* The offset must always be a multiple of 8. We use
3354 the least significant bit to record whether we have
3355 already generated the necessary reloc. */
3360 bfd_put_64 (output_bfd, relocation,
3361 base_got->contents + off);
3366 Elf_Internal_Rela outrel;
3368 /* We need to generate a R_X86_64_RELATIVE reloc
3369 for the dynamic linker. */
3370 s = htab->elf.srelgot;
3374 outrel.r_offset = (base_got->output_section->vma
3375 + base_got->output_offset
3377 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
3378 outrel.r_addend = relocation;
3379 elf_append_rela (output_bfd, s, &outrel);
3382 local_got_offsets[r_symndx] |= 1;
3386 if (off >= (bfd_vma) -2)
3389 relocation = base_got->output_section->vma
3390 + base_got->output_offset + off;
3391 if (r_type != R_X86_64_GOTPCREL && r_type != R_X86_64_GOTPCREL64)
3392 relocation -= htab->elf.sgotplt->output_section->vma
3393 - htab->elf.sgotplt->output_offset;
3397 case R_X86_64_GOTOFF64:
3398 /* Relocation is relative to the start of the global offset
3401 /* Check to make sure it isn't a protected function symbol
3402 for shared library since it may not be local when used
3403 as function address. */
3407 && h->type == STT_FUNC
3408 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
3410 (*_bfd_error_handler)
3411 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
3412 input_bfd, h->root.root.string);
3413 bfd_set_error (bfd_error_bad_value);
3417 /* Note that sgot is not involved in this
3418 calculation. We always want the start of .got.plt. If we
3419 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3420 permitted by the ABI, we might have to change this
3422 relocation -= htab->elf.sgotplt->output_section->vma
3423 + htab->elf.sgotplt->output_offset;
3426 case R_X86_64_GOTPC32:
3427 case R_X86_64_GOTPC64:
3428 /* Use global offset table as symbol value. */
3429 relocation = htab->elf.sgotplt->output_section->vma
3430 + htab->elf.sgotplt->output_offset;
3431 unresolved_reloc = FALSE;
3434 case R_X86_64_PLTOFF64:
3435 /* Relocation is PLT entry relative to GOT. For local
3436 symbols it's the symbol itself relative to GOT. */
3438 /* See PLT32 handling. */
3439 && h->plt.offset != (bfd_vma) -1
3440 && htab->elf.splt != NULL)
3442 relocation = (htab->elf.splt->output_section->vma
3443 + htab->elf.splt->output_offset
3445 unresolved_reloc = FALSE;
3448 relocation -= htab->elf.sgotplt->output_section->vma
3449 + htab->elf.sgotplt->output_offset;
3452 case R_X86_64_PLT32:
3453 /* Relocation is to the entry for this symbol in the
3454 procedure linkage table. */
3456 /* Resolve a PLT32 reloc against a local symbol directly,
3457 without using the procedure linkage table. */
3461 if (h->plt.offset == (bfd_vma) -1
3462 || htab->elf.splt == NULL)
3464 /* We didn't make a PLT entry for this symbol. This
3465 happens when statically linking PIC code, or when
3466 using -Bsymbolic. */
3470 relocation = (htab->elf.splt->output_section->vma
3471 + htab->elf.splt->output_offset
3473 unresolved_reloc = FALSE;
3480 && ABI_64_P (output_bfd)
3481 && (input_section->flags & SEC_ALLOC) != 0
3482 && (input_section->flags & SEC_READONLY) != 0
3485 bfd_boolean fail = FALSE;
3487 = (r_type == R_X86_64_PC32
3488 && is_32bit_relative_branch (contents, rel->r_offset));
3490 if (SYMBOL_REFERENCES_LOCAL (info, h))
3492 /* Symbol is referenced locally. Make sure it is
3493 defined locally or for a branch. */
3494 fail = !h->def_regular && !branch;
3498 /* Symbol isn't referenced locally. We only allow
3499 branch to symbol with non-default visibility. */
3501 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT);
3508 const char *pic = "";
3510 switch (ELF_ST_VISIBILITY (h->other))
3513 v = _("hidden symbol");
3516 v = _("internal symbol");
3519 v = _("protected symbol");
3523 pic = _("; recompile with -fPIC");
3528 fmt = _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
3530 fmt = _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
3532 (*_bfd_error_handler) (fmt, input_bfd,
3533 x86_64_elf_howto_table[r_type].name,
3534 v, h->root.root.string, pic);
3535 bfd_set_error (bfd_error_bad_value);
3546 /* FIXME: The ABI says the linker should make sure the value is
3547 the same when it's zeroextended to 64 bit. */
3549 if ((input_section->flags & SEC_ALLOC) == 0)
3554 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3555 || h->root.type != bfd_link_hash_undefweak)
3556 && (! IS_X86_64_PCREL_TYPE (r_type)
3557 || ! SYMBOL_CALLS_LOCAL (info, h)))
3558 || (ELIMINATE_COPY_RELOCS
3565 || h->root.type == bfd_link_hash_undefweak
3566 || h->root.type == bfd_link_hash_undefined)))
3568 Elf_Internal_Rela outrel;
3569 bfd_boolean skip, relocate;
3572 /* When generating a shared object, these relocations
3573 are copied into the output file to be resolved at run
3579 _bfd_elf_section_offset (output_bfd, info, input_section,
3581 if (outrel.r_offset == (bfd_vma) -1)
3583 else if (outrel.r_offset == (bfd_vma) -2)
3584 skip = TRUE, relocate = TRUE;
3586 outrel.r_offset += (input_section->output_section->vma
3587 + input_section->output_offset);
3590 memset (&outrel, 0, sizeof outrel);
3592 /* h->dynindx may be -1 if this symbol was marked to
3596 && (IS_X86_64_PCREL_TYPE (r_type)
3598 || ! SYMBOLIC_BIND (info, h)
3599 || ! h->def_regular))
3601 outrel.r_info = htab->r_info (h->dynindx, r_type);
3602 outrel.r_addend = rel->r_addend;
3606 /* This symbol is local, or marked to become local. */
3607 if (r_type == htab->pointer_r_type)
3610 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
3611 outrel.r_addend = relocation + rel->r_addend;
3613 else if (r_type == R_X86_64_64
3614 && !ABI_64_P (output_bfd))
3617 outrel.r_info = htab->r_info (0,
3618 R_X86_64_RELATIVE64);
3619 outrel.r_addend = relocation + rel->r_addend;
3625 if (bfd_is_abs_section (sec))
3627 else if (sec == NULL || sec->owner == NULL)
3629 bfd_set_error (bfd_error_bad_value);
3636 /* We are turning this relocation into one
3637 against a section symbol. It would be
3638 proper to subtract the symbol's value,
3639 osec->vma, from the emitted reloc addend,
3640 but ld.so expects buggy relocs. */
3641 osec = sec->output_section;
3642 sindx = elf_section_data (osec)->dynindx;
3645 asection *oi = htab->elf.text_index_section;
3646 sindx = elf_section_data (oi)->dynindx;
3648 BFD_ASSERT (sindx != 0);
3651 outrel.r_info = htab->r_info (sindx, r_type);
3652 outrel.r_addend = relocation + rel->r_addend;
3656 sreloc = elf_section_data (input_section)->sreloc;
3658 if (sreloc == NULL || sreloc->contents == NULL)
3660 r = bfd_reloc_notsupported;
3661 goto check_relocation_error;
3664 elf_append_rela (output_bfd, sreloc, &outrel);
3666 /* If this reloc is against an external symbol, we do
3667 not want to fiddle with the addend. Otherwise, we
3668 need to include the symbol value so that it becomes
3669 an addend for the dynamic reloc. */
3676 case R_X86_64_TLSGD:
3677 case R_X86_64_GOTPC32_TLSDESC:
3678 case R_X86_64_TLSDESC_CALL:
3679 case R_X86_64_GOTTPOFF:
3680 tls_type = GOT_UNKNOWN;
3681 if (h == NULL && local_got_offsets)
3682 tls_type = elf_x86_64_local_got_tls_type (input_bfd) [r_symndx];
3684 tls_type = elf_x86_64_hash_entry (h)->tls_type;
3686 if (! elf_x86_64_tls_transition (info, input_bfd,
3687 input_section, contents,
3688 symtab_hdr, sym_hashes,
3689 &r_type, tls_type, rel,
3690 relend, h, r_symndx))
3693 if (r_type == R_X86_64_TPOFF32)
3695 bfd_vma roff = rel->r_offset;
3697 BFD_ASSERT (! unresolved_reloc);
3699 if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
3701 /* GD->LE transition. For 64bit, change
3702 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3703 .word 0x6666; rex64; call __tls_get_addr
3706 leaq foo@tpoff(%rax), %rax
3708 leaq foo@tlsgd(%rip), %rdi
3709 .word 0x6666; rex64; call __tls_get_addr
3712 leaq foo@tpoff(%rax), %rax */
3713 if (ABI_64_P (output_bfd))
3714 memcpy (contents + roff - 4,
3715 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3718 memcpy (contents + roff - 3,
3719 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3721 bfd_put_32 (output_bfd,
3722 elf_x86_64_tpoff (info, relocation),
3723 contents + roff + 8);
3724 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
3728 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
3730 /* GDesc -> LE transition.
3731 It's originally something like:
3732 leaq x@tlsdesc(%rip), %rax
3735 movl $x@tpoff, %rax. */
3737 unsigned int val, type;
3739 type = bfd_get_8 (input_bfd, contents + roff - 3);
3740 val = bfd_get_8 (input_bfd, contents + roff - 1);
3741 bfd_put_8 (output_bfd, 0x48 | ((type >> 2) & 1),
3742 contents + roff - 3);
3743 bfd_put_8 (output_bfd, 0xc7, contents + roff - 2);
3744 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3745 contents + roff - 1);
3746 bfd_put_32 (output_bfd,
3747 elf_x86_64_tpoff (info, relocation),
3751 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
3753 /* GDesc -> LE transition.
3758 bfd_put_8 (output_bfd, 0x66, contents + roff);
3759 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3762 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTTPOFF)
3764 /* IE->LE transition:
3765 Originally it can be one of:
3766 movq foo@gottpoff(%rip), %reg
3767 addq foo@gottpoff(%rip), %reg
3770 leaq foo(%reg), %reg
3773 unsigned int val, type, reg;
3775 val = bfd_get_8 (input_bfd, contents + roff - 3);
3776 type = bfd_get_8 (input_bfd, contents + roff - 2);
3777 reg = bfd_get_8 (input_bfd, contents + roff - 1);
3783 bfd_put_8 (output_bfd, 0x49,
3784 contents + roff - 3);
3785 else if (!ABI_64_P (output_bfd) && val == 0x44)
3786 bfd_put_8 (output_bfd, 0x41,
3787 contents + roff - 3);
3788 bfd_put_8 (output_bfd, 0xc7,
3789 contents + roff - 2);
3790 bfd_put_8 (output_bfd, 0xc0 | reg,
3791 contents + roff - 1);
3795 /* addq -> addq - addressing with %rsp/%r12 is
3798 bfd_put_8 (output_bfd, 0x49,
3799 contents + roff - 3);
3800 else if (!ABI_64_P (output_bfd) && val == 0x44)
3801 bfd_put_8 (output_bfd, 0x41,
3802 contents + roff - 3);
3803 bfd_put_8 (output_bfd, 0x81,
3804 contents + roff - 2);
3805 bfd_put_8 (output_bfd, 0xc0 | reg,
3806 contents + roff - 1);
3812 bfd_put_8 (output_bfd, 0x4d,
3813 contents + roff - 3);
3814 else if (!ABI_64_P (output_bfd) && val == 0x44)
3815 bfd_put_8 (output_bfd, 0x45,
3816 contents + roff - 3);
3817 bfd_put_8 (output_bfd, 0x8d,
3818 contents + roff - 2);
3819 bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
3820 contents + roff - 1);
3822 bfd_put_32 (output_bfd,
3823 elf_x86_64_tpoff (info, relocation),
3831 if (htab->elf.sgot == NULL)
3836 off = h->got.offset;
3837 offplt = elf_x86_64_hash_entry (h)->tlsdesc_got;
3841 if (local_got_offsets == NULL)
3844 off = local_got_offsets[r_symndx];
3845 offplt = local_tlsdesc_gotents[r_symndx];
3852 Elf_Internal_Rela outrel;
3856 if (htab->elf.srelgot == NULL)
3859 indx = h && h->dynindx != -1 ? h->dynindx : 0;
3861 if (GOT_TLS_GDESC_P (tls_type))
3863 outrel.r_info = htab->r_info (indx, R_X86_64_TLSDESC);
3864 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt
3865 + 2 * GOT_ENTRY_SIZE <= htab->elf.sgotplt->size);
3866 outrel.r_offset = (htab->elf.sgotplt->output_section->vma
3867 + htab->elf.sgotplt->output_offset
3869 + htab->sgotplt_jump_table_size);
3870 sreloc = htab->elf.srelplt;
3872 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
3874 outrel.r_addend = 0;
3875 elf_append_rela (output_bfd, sreloc, &outrel);
3878 sreloc = htab->elf.srelgot;
3880 outrel.r_offset = (htab->elf.sgot->output_section->vma
3881 + htab->elf.sgot->output_offset + off);
3883 if (GOT_TLS_GD_P (tls_type))
3884 dr_type = R_X86_64_DTPMOD64;
3885 else if (GOT_TLS_GDESC_P (tls_type))
3888 dr_type = R_X86_64_TPOFF64;
3890 bfd_put_64 (output_bfd, 0, htab->elf.sgot->contents + off);
3891 outrel.r_addend = 0;
3892 if ((dr_type == R_X86_64_TPOFF64
3893 || dr_type == R_X86_64_TLSDESC) && indx == 0)
3894 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
3895 outrel.r_info = htab->r_info (indx, dr_type);
3897 elf_append_rela (output_bfd, sreloc, &outrel);
3899 if (GOT_TLS_GD_P (tls_type))
3903 BFD_ASSERT (! unresolved_reloc);
3904 bfd_put_64 (output_bfd,
3905 relocation - elf_x86_64_dtpoff_base (info),
3906 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3910 bfd_put_64 (output_bfd, 0,
3911 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3912 outrel.r_info = htab->r_info (indx,
3914 outrel.r_offset += GOT_ENTRY_SIZE;
3915 elf_append_rela (output_bfd, sreloc,
3924 local_got_offsets[r_symndx] |= 1;
3927 if (off >= (bfd_vma) -2
3928 && ! GOT_TLS_GDESC_P (tls_type))
3930 if (r_type == ELF32_R_TYPE (rel->r_info))
3932 if (r_type == R_X86_64_GOTPC32_TLSDESC
3933 || r_type == R_X86_64_TLSDESC_CALL)
3934 relocation = htab->elf.sgotplt->output_section->vma
3935 + htab->elf.sgotplt->output_offset
3936 + offplt + htab->sgotplt_jump_table_size;
3938 relocation = htab->elf.sgot->output_section->vma
3939 + htab->elf.sgot->output_offset + off;
3940 unresolved_reloc = FALSE;
3944 bfd_vma roff = rel->r_offset;
3946 if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
3948 /* GD->IE transition. For 64bit, change
3949 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3950 .word 0x6666; rex64; call __tls_get_addr@plt
3953 addq foo@gottpoff(%rip), %rax
3955 leaq foo@tlsgd(%rip), %rdi
3956 .word 0x6666; rex64; call __tls_get_addr@plt
3959 addq foo@gottpoff(%rip), %rax */
3960 if (ABI_64_P (output_bfd))
3961 memcpy (contents + roff - 4,
3962 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
3965 memcpy (contents + roff - 3,
3966 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
3969 relocation = (htab->elf.sgot->output_section->vma
3970 + htab->elf.sgot->output_offset + off
3972 - input_section->output_section->vma
3973 - input_section->output_offset
3975 bfd_put_32 (output_bfd, relocation,
3976 contents + roff + 8);
3977 /* Skip R_X86_64_PLT32. */
3981 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
3983 /* GDesc -> IE transition.
3984 It's originally something like:
3985 leaq x@tlsdesc(%rip), %rax
3988 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
3990 /* Now modify the instruction as appropriate. To
3991 turn a leaq into a movq in the form we use it, it
3992 suffices to change the second byte from 0x8d to
3994 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
3996 bfd_put_32 (output_bfd,
3997 htab->elf.sgot->output_section->vma
3998 + htab->elf.sgot->output_offset + off
4000 - input_section->output_section->vma
4001 - input_section->output_offset
4006 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
4008 /* GDesc -> IE transition.
4015 bfd_put_8 (output_bfd, 0x66, contents + roff);
4016 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4024 case R_X86_64_TLSLD:
4025 if (! elf_x86_64_tls_transition (info, input_bfd,
4026 input_section, contents,
4027 symtab_hdr, sym_hashes,
4028 &r_type, GOT_UNKNOWN,
4029 rel, relend, h, r_symndx))
4032 if (r_type != R_X86_64_TLSLD)
4034 /* LD->LE transition:
4035 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
4036 For 64bit, we change it into:
4037 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
4038 For 32bit, we change it into:
4039 nopl 0x0(%rax); movl %fs:0, %eax. */
4041 BFD_ASSERT (r_type == R_X86_64_TPOFF32);
4042 if (ABI_64_P (output_bfd))
4043 memcpy (contents + rel->r_offset - 3,
4044 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
4046 memcpy (contents + rel->r_offset - 3,
4047 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
4048 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
4053 if (htab->elf.sgot == NULL)
4056 off = htab->tls_ld_got.offset;
4061 Elf_Internal_Rela outrel;
4063 if (htab->elf.srelgot == NULL)
4066 outrel.r_offset = (htab->elf.sgot->output_section->vma
4067 + htab->elf.sgot->output_offset + off);
4069 bfd_put_64 (output_bfd, 0,
4070 htab->elf.sgot->contents + off);
4071 bfd_put_64 (output_bfd, 0,
4072 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4073 outrel.r_info = htab->r_info (0, R_X86_64_DTPMOD64);
4074 outrel.r_addend = 0;
4075 elf_append_rela (output_bfd, htab->elf.srelgot,
4077 htab->tls_ld_got.offset |= 1;
4079 relocation = htab->elf.sgot->output_section->vma
4080 + htab->elf.sgot->output_offset + off;
4081 unresolved_reloc = FALSE;
4084 case R_X86_64_DTPOFF32:
4085 if (!info->executable|| (input_section->flags & SEC_CODE) == 0)
4086 relocation -= elf_x86_64_dtpoff_base (info);
4088 relocation = elf_x86_64_tpoff (info, relocation);
4091 case R_X86_64_TPOFF32:
4092 case R_X86_64_TPOFF64:
4093 BFD_ASSERT (info->executable);
4094 relocation = elf_x86_64_tpoff (info, relocation);
4101 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4102 because such sections are not SEC_ALLOC and thus ld.so will
4103 not process them. */
4104 if (unresolved_reloc
4105 && !((input_section->flags & SEC_DEBUGGING) != 0
4107 (*_bfd_error_handler)
4108 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4111 (long) rel->r_offset,
4113 h->root.root.string);
4116 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4117 contents, rel->r_offset,
4118 relocation, rel->r_addend);
4120 check_relocation_error:
4121 if (r != bfd_reloc_ok)
4126 name = h->root.root.string;
4129 name = bfd_elf_string_from_elf_section (input_bfd,
4130 symtab_hdr->sh_link,
4135 name = bfd_section_name (input_bfd, sec);
4138 if (r == bfd_reloc_overflow)
4140 if (! ((*info->callbacks->reloc_overflow)
4141 (info, (h ? &h->root : NULL), name, howto->name,
4142 (bfd_vma) 0, input_bfd, input_section,
4148 (*_bfd_error_handler)
4149 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4150 input_bfd, input_section,
4151 (long) rel->r_offset, name, (int) r);
4160 /* Finish up dynamic symbol handling. We set the contents of various
4161 dynamic sections here. */
4164 elf_x86_64_finish_dynamic_symbol (bfd *output_bfd,
4165 struct bfd_link_info *info,
4166 struct elf_link_hash_entry *h,
4167 Elf_Internal_Sym *sym)
4169 struct elf_x86_64_link_hash_table *htab;
4171 htab = elf_x86_64_hash_table (info);
4175 if (h->plt.offset != (bfd_vma) -1)
4179 Elf_Internal_Rela rela;
4181 asection *plt, *gotplt, *relplt;
4182 const struct elf_backend_data *bed;
4184 /* When building a static executable, use .iplt, .igot.plt and
4185 .rela.iplt sections for STT_GNU_IFUNC symbols. */
4186 if (htab->elf.splt != NULL)
4188 plt = htab->elf.splt;
4189 gotplt = htab->elf.sgotplt;
4190 relplt = htab->elf.srelplt;
4194 plt = htab->elf.iplt;
4195 gotplt = htab->elf.igotplt;
4196 relplt = htab->elf.irelplt;
4199 /* This symbol has an entry in the procedure linkage table. Set
4201 if ((h->dynindx == -1
4202 && !((h->forced_local || info->executable)
4204 && h->type == STT_GNU_IFUNC))
4210 /* Get the index in the procedure linkage table which
4211 corresponds to this symbol. This is the index of this symbol
4212 in all the symbols for which we are making plt entries. The
4213 first entry in the procedure linkage table is reserved.
4215 Get the offset into the .got table of the entry that
4216 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
4217 bytes. The first three are reserved for the dynamic linker.
4219 For static executables, we don't reserve anything. */
4221 if (plt == htab->elf.splt)
4223 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
4224 got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
4228 plt_index = h->plt.offset / PLT_ENTRY_SIZE;
4229 got_offset = plt_index * GOT_ENTRY_SIZE;
4232 /* Fill in the entry in the procedure linkage table. */
4233 memcpy (plt->contents + h->plt.offset, elf_x86_64_plt_entry,
4236 /* Insert the relocation positions of the plt section. The magic
4237 numbers at the end of the statements are the positions of the
4238 relocations in the plt section. */
4239 /* Put offset for jmp *name@GOTPCREL(%rip), since the
4240 instruction uses 6 bytes, subtract this value. */
4241 bfd_put_32 (output_bfd,
4242 (gotplt->output_section->vma
4243 + gotplt->output_offset
4245 - plt->output_section->vma
4246 - plt->output_offset
4249 plt->contents + h->plt.offset + 2);
4251 /* Don't fill PLT entry for static executables. */
4252 if (plt == htab->elf.splt)
4254 /* Put relocation index. */
4255 bfd_put_32 (output_bfd, plt_index,
4256 plt->contents + h->plt.offset + 7);
4257 /* Put offset for jmp .PLT0. */
4258 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
4259 plt->contents + h->plt.offset + 12);
4262 /* Fill in the entry in the global offset table, initially this
4263 points to the pushq instruction in the PLT which is at offset 6. */
4264 bfd_put_64 (output_bfd, (plt->output_section->vma
4265 + plt->output_offset
4266 + h->plt.offset + 6),
4267 gotplt->contents + got_offset);
4269 /* Fill in the entry in the .rela.plt section. */
4270 rela.r_offset = (gotplt->output_section->vma
4271 + gotplt->output_offset
4273 if (h->dynindx == -1
4274 || ((info->executable
4275 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4277 && h->type == STT_GNU_IFUNC))
4279 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4280 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
4281 rela.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
4282 rela.r_addend = (h->root.u.def.value
4283 + h->root.u.def.section->output_section->vma
4284 + h->root.u.def.section->output_offset);
4288 rela.r_info = htab->r_info (h->dynindx, R_X86_64_JUMP_SLOT);
4292 bed = get_elf_backend_data (output_bfd);
4293 loc = relplt->contents + plt_index * bed->s->sizeof_rela;
4294 bed->s->swap_reloca_out (output_bfd, &rela, loc);
4296 if (!h->def_regular)
4298 /* Mark the symbol as undefined, rather than as defined in
4299 the .plt section. Leave the value if there were any
4300 relocations where pointer equality matters (this is a clue
4301 for the dynamic linker, to make function pointer
4302 comparisons work between an application and shared
4303 library), otherwise set it to zero. If a function is only
4304 called from a binary, there is no need to slow down
4305 shared libraries because of that. */
4306 sym->st_shndx = SHN_UNDEF;
4307 if (!h->pointer_equality_needed)
4312 if (h->got.offset != (bfd_vma) -1
4313 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h)->tls_type)
4314 && elf_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE)
4316 Elf_Internal_Rela rela;
4318 /* This symbol has an entry in the global offset table. Set it
4320 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
4323 rela.r_offset = (htab->elf.sgot->output_section->vma
4324 + htab->elf.sgot->output_offset
4325 + (h->got.offset &~ (bfd_vma) 1));
4327 /* If this is a static link, or it is a -Bsymbolic link and the
4328 symbol is defined locally or was forced to be local because
4329 of a version file, we just want to emit a RELATIVE reloc.
4330 The entry in the global offset table will already have been
4331 initialized in the relocate_section function. */
4333 && h->type == STT_GNU_IFUNC)
4337 /* Generate R_X86_64_GLOB_DAT. */
4344 if (!h->pointer_equality_needed)
4347 /* For non-shared object, we can't use .got.plt, which
4348 contains the real function addres if we need pointer
4349 equality. We load the GOT entry with the PLT entry. */
4350 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4351 bfd_put_64 (output_bfd, (plt->output_section->vma
4352 + plt->output_offset
4354 htab->elf.sgot->contents + h->got.offset);
4358 else if (info->shared
4359 && SYMBOL_REFERENCES_LOCAL (info, h))
4361 if (!h->def_regular)
4363 BFD_ASSERT((h->got.offset & 1) != 0);
4364 rela.r_info = htab->r_info (0, R_X86_64_RELATIVE);
4365 rela.r_addend = (h->root.u.def.value
4366 + h->root.u.def.section->output_section->vma
4367 + h->root.u.def.section->output_offset);
4371 BFD_ASSERT((h->got.offset & 1) == 0);
4373 bfd_put_64 (output_bfd, (bfd_vma) 0,
4374 htab->elf.sgot->contents + h->got.offset);
4375 rela.r_info = htab->r_info (h->dynindx, R_X86_64_GLOB_DAT);
4379 elf_append_rela (output_bfd, htab->elf.srelgot, &rela);
4384 Elf_Internal_Rela rela;
4386 /* This symbol needs a copy reloc. Set it up. */
4388 if (h->dynindx == -1
4389 || (h->root.type != bfd_link_hash_defined
4390 && h->root.type != bfd_link_hash_defweak)
4391 || htab->srelbss == NULL)
4394 rela.r_offset = (h->root.u.def.value
4395 + h->root.u.def.section->output_section->vma
4396 + h->root.u.def.section->output_offset);
4397 rela.r_info = htab->r_info (h->dynindx, R_X86_64_COPY);
4399 elf_append_rela (output_bfd, htab->srelbss, &rela);
4402 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. SYM may
4403 be NULL for local symbols. */
4405 && (strcmp (h->root.root.string, "_DYNAMIC") == 0
4406 || h == htab->elf.hgot))
4407 sym->st_shndx = SHN_ABS;
4412 /* Finish up local dynamic symbol handling. We set the contents of
4413 various dynamic sections here. */
4416 elf_x86_64_finish_local_dynamic_symbol (void **slot, void *inf)
4418 struct elf_link_hash_entry *h
4419 = (struct elf_link_hash_entry *) *slot;
4420 struct bfd_link_info *info
4421 = (struct bfd_link_info *) inf;
4423 return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
4427 /* Used to decide how to sort relocs in an optimal manner for the
4428 dynamic linker, before writing them out. */
4430 static enum elf_reloc_type_class
4431 elf_x86_64_reloc_type_class (const Elf_Internal_Rela *rela)
4433 switch ((int) ELF32_R_TYPE (rela->r_info))
4435 case R_X86_64_RELATIVE:
4436 return reloc_class_relative;
4437 case R_X86_64_JUMP_SLOT:
4438 return reloc_class_plt;
4440 return reloc_class_copy;
4442 return reloc_class_normal;
4446 /* Finish up the dynamic sections. */
4449 elf_x86_64_finish_dynamic_sections (bfd *output_bfd,
4450 struct bfd_link_info *info)
4452 struct elf_x86_64_link_hash_table *htab;
4456 htab = elf_x86_64_hash_table (info);
4460 dynobj = htab->elf.dynobj;
4461 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4463 if (htab->elf.dynamic_sections_created)
4465 bfd_byte *dyncon, *dynconend;
4466 const struct elf_backend_data *bed;
4467 bfd_size_type sizeof_dyn;
4469 if (sdyn == NULL || htab->elf.sgot == NULL)
4472 bed = get_elf_backend_data (dynobj);
4473 sizeof_dyn = bed->s->sizeof_dyn;
4474 dyncon = sdyn->contents;
4475 dynconend = sdyn->contents + sdyn->size;
4476 for (; dyncon < dynconend; dyncon += sizeof_dyn)
4478 Elf_Internal_Dyn dyn;
4481 (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
4489 s = htab->elf.sgotplt;
4490 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4494 dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
4498 s = htab->elf.srelplt->output_section;
4499 dyn.d_un.d_val = s->size;
4503 /* The procedure linkage table relocs (DT_JMPREL) should
4504 not be included in the overall relocs (DT_RELA).
4505 Therefore, we override the DT_RELASZ entry here to
4506 make it not include the JMPREL relocs. Since the
4507 linker script arranges for .rela.plt to follow all
4508 other relocation sections, we don't have to worry
4509 about changing the DT_RELA entry. */
4510 if (htab->elf.srelplt != NULL)
4512 s = htab->elf.srelplt->output_section;
4513 dyn.d_un.d_val -= s->size;
4517 case DT_TLSDESC_PLT:
4519 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
4520 + htab->tlsdesc_plt;
4523 case DT_TLSDESC_GOT:
4525 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
4526 + htab->tlsdesc_got;
4530 (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
4533 /* Fill in the special first entry in the procedure linkage table. */
4534 if (htab->elf.splt && htab->elf.splt->size > 0)
4536 /* Fill in the first entry in the procedure linkage table. */
4537 memcpy (htab->elf.splt->contents, elf_x86_64_plt0_entry,
4539 /* Add offset for pushq GOT+8(%rip), since the instruction
4540 uses 6 bytes subtract this value. */
4541 bfd_put_32 (output_bfd,
4542 (htab->elf.sgotplt->output_section->vma
4543 + htab->elf.sgotplt->output_offset
4545 - htab->elf.splt->output_section->vma
4546 - htab->elf.splt->output_offset
4548 htab->elf.splt->contents + 2);
4549 /* Add offset for jmp *GOT+16(%rip). The 12 is the offset to
4550 the end of the instruction. */
4551 bfd_put_32 (output_bfd,
4552 (htab->elf.sgotplt->output_section->vma
4553 + htab->elf.sgotplt->output_offset
4555 - htab->elf.splt->output_section->vma
4556 - htab->elf.splt->output_offset
4558 htab->elf.splt->contents + 8);
4560 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize =
4563 if (htab->tlsdesc_plt)
4565 bfd_put_64 (output_bfd, (bfd_vma) 0,
4566 htab->elf.sgot->contents + htab->tlsdesc_got);
4568 memcpy (htab->elf.splt->contents + htab->tlsdesc_plt,
4569 elf_x86_64_plt0_entry,
4572 /* Add offset for pushq GOT+8(%rip), since the
4573 instruction uses 6 bytes subtract this value. */
4574 bfd_put_32 (output_bfd,
4575 (htab->elf.sgotplt->output_section->vma
4576 + htab->elf.sgotplt->output_offset
4578 - htab->elf.splt->output_section->vma
4579 - htab->elf.splt->output_offset
4582 htab->elf.splt->contents + htab->tlsdesc_plt + 2);
4583 /* Add offset for jmp *GOT+TDG(%rip), where TGD stands for
4584 htab->tlsdesc_got. The 12 is the offset to the end of
4586 bfd_put_32 (output_bfd,
4587 (htab->elf.sgot->output_section->vma
4588 + htab->elf.sgot->output_offset
4590 - htab->elf.splt->output_section->vma
4591 - htab->elf.splt->output_offset
4594 htab->elf.splt->contents + htab->tlsdesc_plt + 8);
4599 if (htab->elf.sgotplt)
4601 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
4603 (*_bfd_error_handler)
4604 (_("discarded output section: `%A'"), htab->elf.sgotplt);
4608 /* Fill in the first three entries in the global offset table. */
4609 if (htab->elf.sgotplt->size > 0)
4611 /* Set the first entry in the global offset table to the address of
4612 the dynamic section. */
4614 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents);
4616 bfd_put_64 (output_bfd,
4617 sdyn->output_section->vma + sdyn->output_offset,
4618 htab->elf.sgotplt->contents);
4619 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
4620 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
4621 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE*2);
4624 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize =
4628 /* Adjust .eh_frame for .plt section. */
4629 if (htab->plt_eh_frame != NULL)
4631 if (htab->elf.splt != NULL
4632 && htab->elf.splt->size != 0
4633 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
4634 && htab->elf.splt->output_section != NULL
4635 && htab->plt_eh_frame->output_section != NULL)
4637 bfd_vma plt_start = htab->elf.splt->output_section->vma;
4638 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
4639 + htab->plt_eh_frame->output_offset
4640 + PLT_FDE_START_OFFSET;
4641 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
4642 htab->plt_eh_frame->contents
4643 + PLT_FDE_START_OFFSET);
4645 if (htab->plt_eh_frame->sec_info_type
4646 == ELF_INFO_TYPE_EH_FRAME)
4648 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
4650 htab->plt_eh_frame->contents))
4655 if (htab->elf.sgot && htab->elf.sgot->size > 0)
4656 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
4659 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4660 htab_traverse (htab->loc_hash_table,
4661 elf_x86_64_finish_local_dynamic_symbol,
4667 /* Return address for Ith PLT stub in section PLT, for relocation REL
4668 or (bfd_vma) -1 if it should not be included. */
4671 elf_x86_64_plt_sym_val (bfd_vma i, const asection *plt,
4672 const arelent *rel ATTRIBUTE_UNUSED)
4674 return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
4677 /* Handle an x86-64 specific section when reading an object file. This
4678 is called when elfcode.h finds a section with an unknown type. */
4681 elf_x86_64_section_from_shdr (bfd *abfd,
4682 Elf_Internal_Shdr *hdr,
4686 if (hdr->sh_type != SHT_X86_64_UNWIND)
4689 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
4695 /* Hook called by the linker routine which adds symbols from an object
4696 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
4700 elf_x86_64_add_symbol_hook (bfd *abfd,
4701 struct bfd_link_info *info,
4702 Elf_Internal_Sym *sym,
4703 const char **namep ATTRIBUTE_UNUSED,
4704 flagword *flagsp ATTRIBUTE_UNUSED,
4710 switch (sym->st_shndx)
4712 case SHN_X86_64_LCOMMON:
4713 lcomm = bfd_get_section_by_name (abfd, "LARGE_COMMON");
4716 lcomm = bfd_make_section_with_flags (abfd,
4720 | SEC_LINKER_CREATED));
4723 elf_section_flags (lcomm) |= SHF_X86_64_LARGE;
4726 *valp = sym->st_size;
4730 if ((abfd->flags & DYNAMIC) == 0
4731 && (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
4732 || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE))
4733 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4739 /* Given a BFD section, try to locate the corresponding ELF section
4743 elf_x86_64_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
4744 asection *sec, int *index_return)
4746 if (sec == &_bfd_elf_large_com_section)
4748 *index_return = SHN_X86_64_LCOMMON;
4754 /* Process a symbol. */
4757 elf_x86_64_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
4760 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
4762 switch (elfsym->internal_elf_sym.st_shndx)
4764 case SHN_X86_64_LCOMMON:
4765 asym->section = &_bfd_elf_large_com_section;
4766 asym->value = elfsym->internal_elf_sym.st_size;
4767 /* Common symbol doesn't set BSF_GLOBAL. */
4768 asym->flags &= ~BSF_GLOBAL;
4774 elf_x86_64_common_definition (Elf_Internal_Sym *sym)
4776 return (sym->st_shndx == SHN_COMMON
4777 || sym->st_shndx == SHN_X86_64_LCOMMON);
4781 elf_x86_64_common_section_index (asection *sec)
4783 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
4786 return SHN_X86_64_LCOMMON;
4790 elf_x86_64_common_section (asection *sec)
4792 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
4793 return bfd_com_section_ptr;
4795 return &_bfd_elf_large_com_section;
4799 elf_x86_64_merge_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
4800 struct elf_link_hash_entry **sym_hash ATTRIBUTE_UNUSED,
4801 struct elf_link_hash_entry *h,
4802 Elf_Internal_Sym *sym,
4804 bfd_vma *pvalue ATTRIBUTE_UNUSED,
4805 unsigned int *pold_alignment ATTRIBUTE_UNUSED,
4806 bfd_boolean *skip ATTRIBUTE_UNUSED,
4807 bfd_boolean *override ATTRIBUTE_UNUSED,
4808 bfd_boolean *type_change_ok ATTRIBUTE_UNUSED,
4809 bfd_boolean *size_change_ok ATTRIBUTE_UNUSED,
4810 bfd_boolean *newdyn ATTRIBUTE_UNUSED,
4811 bfd_boolean *newdef,
4812 bfd_boolean *newdyncommon ATTRIBUTE_UNUSED,
4813 bfd_boolean *newweak ATTRIBUTE_UNUSED,
4814 bfd *abfd ATTRIBUTE_UNUSED,
4816 bfd_boolean *olddyn ATTRIBUTE_UNUSED,
4817 bfd_boolean *olddef,
4818 bfd_boolean *olddyncommon ATTRIBUTE_UNUSED,
4819 bfd_boolean *oldweak ATTRIBUTE_UNUSED,
4823 /* A normal common symbol and a large common symbol result in a
4824 normal common symbol. We turn the large common symbol into a
4827 && h->root.type == bfd_link_hash_common
4829 && bfd_is_com_section (*sec)
4832 if (sym->st_shndx == SHN_COMMON
4833 && (elf_section_flags (*oldsec) & SHF_X86_64_LARGE) != 0)
4835 h->root.u.c.p->section
4836 = bfd_make_section_old_way (oldbfd, "COMMON");
4837 h->root.u.c.p->section->flags = SEC_ALLOC;
4839 else if (sym->st_shndx == SHN_X86_64_LCOMMON
4840 && (elf_section_flags (*oldsec) & SHF_X86_64_LARGE) == 0)
4841 *psec = *sec = bfd_com_section_ptr;
4848 elf_x86_64_additional_program_headers (bfd *abfd,
4849 struct bfd_link_info *info ATTRIBUTE_UNUSED)
4854 /* Check to see if we need a large readonly segment. */
4855 s = bfd_get_section_by_name (abfd, ".lrodata");
4856 if (s && (s->flags & SEC_LOAD))
4859 /* Check to see if we need a large data segment. Since .lbss sections
4860 is placed right after the .bss section, there should be no need for
4861 a large data segment just because of .lbss. */
4862 s = bfd_get_section_by_name (abfd, ".ldata");
4863 if (s && (s->flags & SEC_LOAD))
4869 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
4872 elf_x86_64_hash_symbol (struct elf_link_hash_entry *h)
4874 if (h->plt.offset != (bfd_vma) -1
4876 && !h->pointer_equality_needed)
4879 return _bfd_elf_hash_symbol (h);
4882 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
4885 elf_x86_64_relocs_compatible (const bfd_target *input,
4886 const bfd_target *output)
4888 return ((xvec_get_elf_backend_data (input)->s->elfclass
4889 == xvec_get_elf_backend_data (output)->s->elfclass)
4890 && _bfd_elf_relocs_compatible (input, output));
4893 static const struct bfd_elf_special_section
4894 elf_x86_64_special_sections[]=
4896 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
4897 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
4898 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR + SHF_X86_64_LARGE},
4899 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
4900 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
4901 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
4902 { NULL, 0, 0, 0, 0 }
4905 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_vec
4906 #define TARGET_LITTLE_NAME "elf64-x86-64"
4907 #define ELF_ARCH bfd_arch_i386
4908 #define ELF_TARGET_ID X86_64_ELF_DATA
4909 #define ELF_MACHINE_CODE EM_X86_64
4910 #define ELF_MAXPAGESIZE 0x200000
4911 #define ELF_MINPAGESIZE 0x1000
4912 #define ELF_COMMONPAGESIZE 0x1000
4914 #define elf_backend_can_gc_sections 1
4915 #define elf_backend_can_refcount 1
4916 #define elf_backend_want_got_plt 1
4917 #define elf_backend_plt_readonly 1
4918 #define elf_backend_want_plt_sym 0
4919 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
4920 #define elf_backend_rela_normal 1
4921 #define elf_backend_plt_alignment 4
4923 #define elf_info_to_howto elf_x86_64_info_to_howto
4925 #define bfd_elf64_bfd_link_hash_table_create \
4926 elf_x86_64_link_hash_table_create
4927 #define bfd_elf64_bfd_link_hash_table_free \
4928 elf_x86_64_link_hash_table_free
4929 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
4930 #define bfd_elf64_bfd_reloc_name_lookup \
4931 elf_x86_64_reloc_name_lookup
4933 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
4934 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
4935 #define elf_backend_check_relocs elf_x86_64_check_relocs
4936 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
4937 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
4938 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
4939 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
4940 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
4941 #define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
4942 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
4943 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
4945 #define elf_backend_write_core_note elf_x86_64_write_core_note
4947 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
4948 #define elf_backend_relocate_section elf_x86_64_relocate_section
4949 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
4950 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
4951 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
4952 #define elf_backend_plt_sym_val elf_x86_64_plt_sym_val
4953 #define elf_backend_object_p elf64_x86_64_elf_object_p
4954 #define bfd_elf64_mkobject elf_x86_64_mkobject
4956 #define elf_backend_section_from_shdr \
4957 elf_x86_64_section_from_shdr
4959 #define elf_backend_section_from_bfd_section \
4960 elf_x86_64_elf_section_from_bfd_section
4961 #define elf_backend_add_symbol_hook \
4962 elf_x86_64_add_symbol_hook
4963 #define elf_backend_symbol_processing \
4964 elf_x86_64_symbol_processing
4965 #define elf_backend_common_section_index \
4966 elf_x86_64_common_section_index
4967 #define elf_backend_common_section \
4968 elf_x86_64_common_section
4969 #define elf_backend_common_definition \
4970 elf_x86_64_common_definition
4971 #define elf_backend_merge_symbol \
4972 elf_x86_64_merge_symbol
4973 #define elf_backend_special_sections \
4974 elf_x86_64_special_sections
4975 #define elf_backend_additional_program_headers \
4976 elf_x86_64_additional_program_headers
4977 #define elf_backend_hash_symbol \
4978 elf_x86_64_hash_symbol
4980 #define elf_backend_post_process_headers _bfd_elf_set_osabi
4982 #include "elf64-target.h"
4984 /* FreeBSD support. */
4986 #undef TARGET_LITTLE_SYM
4987 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_freebsd_vec
4988 #undef TARGET_LITTLE_NAME
4989 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
4992 #define ELF_OSABI ELFOSABI_FREEBSD
4995 #define elf64_bed elf64_x86_64_fbsd_bed
4997 #include "elf64-target.h"
4999 /* Solaris 2 support. */
5001 #undef TARGET_LITTLE_SYM
5002 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_sol2_vec
5003 #undef TARGET_LITTLE_NAME
5004 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
5006 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5007 objects won't be recognized. */
5011 #define elf64_bed elf64_x86_64_sol2_bed
5013 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
5015 #undef elf_backend_static_tls_alignment
5016 #define elf_backend_static_tls_alignment 16
5018 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5020 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5022 #undef elf_backend_want_plt_sym
5023 #define elf_backend_want_plt_sym 1
5025 #include "elf64-target.h"
5027 /* Intel L1OM support. */
5030 elf64_l1om_elf_object_p (bfd *abfd)
5032 /* Set the right machine number for an L1OM elf64 file. */
5033 bfd_default_set_arch_mach (abfd, bfd_arch_l1om, bfd_mach_l1om);
5037 #undef TARGET_LITTLE_SYM
5038 #define TARGET_LITTLE_SYM bfd_elf64_l1om_vec
5039 #undef TARGET_LITTLE_NAME
5040 #define TARGET_LITTLE_NAME "elf64-l1om"
5042 #define ELF_ARCH bfd_arch_l1om
5044 #undef ELF_MACHINE_CODE
5045 #define ELF_MACHINE_CODE EM_L1OM
5050 #define elf64_bed elf64_l1om_bed
5052 #undef elf_backend_object_p
5053 #define elf_backend_object_p elf64_l1om_elf_object_p
5055 #undef elf_backend_static_tls_alignment
5057 #undef elf_backend_want_plt_sym
5058 #define elf_backend_want_plt_sym 0
5060 #include "elf64-target.h"
5062 /* FreeBSD L1OM support. */
5064 #undef TARGET_LITTLE_SYM
5065 #define TARGET_LITTLE_SYM bfd_elf64_l1om_freebsd_vec
5066 #undef TARGET_LITTLE_NAME
5067 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
5070 #define ELF_OSABI ELFOSABI_FREEBSD
5073 #define elf64_bed elf64_l1om_fbsd_bed
5075 #include "elf64-target.h"
5077 /* Intel K1OM support. */
5080 elf64_k1om_elf_object_p (bfd *abfd)
5082 /* Set the right machine number for an K1OM elf64 file. */
5083 bfd_default_set_arch_mach (abfd, bfd_arch_k1om, bfd_mach_k1om);
5087 #undef TARGET_LITTLE_SYM
5088 #define TARGET_LITTLE_SYM bfd_elf64_k1om_vec
5089 #undef TARGET_LITTLE_NAME
5090 #define TARGET_LITTLE_NAME "elf64-k1om"
5092 #define ELF_ARCH bfd_arch_k1om
5094 #undef ELF_MACHINE_CODE
5095 #define ELF_MACHINE_CODE EM_K1OM
5100 #define elf64_bed elf64_k1om_bed
5102 #undef elf_backend_object_p
5103 #define elf_backend_object_p elf64_k1om_elf_object_p
5105 #undef elf_backend_static_tls_alignment
5107 #undef elf_backend_want_plt_sym
5108 #define elf_backend_want_plt_sym 0
5110 #include "elf64-target.h"
5112 /* FreeBSD K1OM support. */
5114 #undef TARGET_LITTLE_SYM
5115 #define TARGET_LITTLE_SYM bfd_elf64_k1om_freebsd_vec
5116 #undef TARGET_LITTLE_NAME
5117 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
5120 #define ELF_OSABI ELFOSABI_FREEBSD
5123 #define elf64_bed elf64_k1om_fbsd_bed
5125 #include "elf64-target.h"
5127 /* 32bit x86-64 support. */
5130 elf32_x86_64_elf_object_p (bfd *abfd)
5132 /* Set the right machine number for an x86-64 elf32 file. */
5133 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32);
5137 #undef TARGET_LITTLE_SYM
5138 #define TARGET_LITTLE_SYM bfd_elf32_x86_64_vec
5139 #undef TARGET_LITTLE_NAME
5140 #define TARGET_LITTLE_NAME "elf32-x86-64"
5143 #define ELF_ARCH bfd_arch_i386
5145 #undef ELF_MACHINE_CODE
5146 #define ELF_MACHINE_CODE EM_X86_64
5148 #define bfd_elf32_bfd_link_hash_table_create \
5149 elf_x86_64_link_hash_table_create
5150 #define bfd_elf32_bfd_link_hash_table_free \
5151 elf_x86_64_link_hash_table_free
5152 #define bfd_elf32_bfd_reloc_type_lookup \
5153 elf_x86_64_reloc_type_lookup
5154 #define bfd_elf32_bfd_reloc_name_lookup \
5155 elf_x86_64_reloc_name_lookup
5156 #define bfd_elf32_mkobject \
5161 #undef elf_backend_object_p
5162 #define elf_backend_object_p \
5163 elf32_x86_64_elf_object_p
5165 #undef elf_backend_bfd_from_remote_memory
5166 #define elf_backend_bfd_from_remote_memory \
5167 _bfd_elf32_bfd_from_remote_memory
5169 #undef elf_backend_size_info
5170 #define elf_backend_size_info \
5171 _bfd_elf32_size_info
5173 #include "elf32-target.h"