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,
168 /* We have a gap in the reloc numbers here.
169 R_X86_64_standard counts the number up to this point, and
170 R_X86_64_vt_offset is the value to subtract from a reloc type of
171 R_X86_64_GNU_VT* to form an index into this table. */
172 #define R_X86_64_standard (R_X86_64_IRELATIVE + 1)
173 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
175 /* GNU extension to record C++ vtable hierarchy. */
176 HOWTO (R_X86_64_GNU_VTINHERIT, 0, 4, 0, FALSE, 0, complain_overflow_dont,
177 NULL, "R_X86_64_GNU_VTINHERIT", FALSE, 0, 0, FALSE),
179 /* GNU extension to record C++ vtable member usage. */
180 HOWTO (R_X86_64_GNU_VTENTRY, 0, 4, 0, FALSE, 0, complain_overflow_dont,
181 _bfd_elf_rel_vtable_reloc_fn, "R_X86_64_GNU_VTENTRY", FALSE, 0, 0,
184 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
185 HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
186 bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
190 #define IS_X86_64_PCREL_TYPE(TYPE) \
191 ( ((TYPE) == R_X86_64_PC8) \
192 || ((TYPE) == R_X86_64_PC16) \
193 || ((TYPE) == R_X86_64_PC32) \
194 || ((TYPE) == R_X86_64_PC64))
196 /* Map BFD relocs to the x86_64 elf relocs. */
199 bfd_reloc_code_real_type bfd_reloc_val;
200 unsigned char elf_reloc_val;
203 static const struct elf_reloc_map x86_64_reloc_map[] =
205 { BFD_RELOC_NONE, R_X86_64_NONE, },
206 { BFD_RELOC_64, R_X86_64_64, },
207 { BFD_RELOC_32_PCREL, R_X86_64_PC32, },
208 { BFD_RELOC_X86_64_GOT32, R_X86_64_GOT32,},
209 { BFD_RELOC_X86_64_PLT32, R_X86_64_PLT32,},
210 { BFD_RELOC_X86_64_COPY, R_X86_64_COPY, },
211 { BFD_RELOC_X86_64_GLOB_DAT, R_X86_64_GLOB_DAT, },
212 { BFD_RELOC_X86_64_JUMP_SLOT, R_X86_64_JUMP_SLOT, },
213 { BFD_RELOC_X86_64_RELATIVE, R_X86_64_RELATIVE, },
214 { BFD_RELOC_X86_64_GOTPCREL, R_X86_64_GOTPCREL, },
215 { BFD_RELOC_32, R_X86_64_32, },
216 { BFD_RELOC_X86_64_32S, R_X86_64_32S, },
217 { BFD_RELOC_16, R_X86_64_16, },
218 { BFD_RELOC_16_PCREL, R_X86_64_PC16, },
219 { BFD_RELOC_8, R_X86_64_8, },
220 { BFD_RELOC_8_PCREL, R_X86_64_PC8, },
221 { BFD_RELOC_X86_64_DTPMOD64, R_X86_64_DTPMOD64, },
222 { BFD_RELOC_X86_64_DTPOFF64, R_X86_64_DTPOFF64, },
223 { BFD_RELOC_X86_64_TPOFF64, R_X86_64_TPOFF64, },
224 { BFD_RELOC_X86_64_TLSGD, R_X86_64_TLSGD, },
225 { BFD_RELOC_X86_64_TLSLD, R_X86_64_TLSLD, },
226 { BFD_RELOC_X86_64_DTPOFF32, R_X86_64_DTPOFF32, },
227 { BFD_RELOC_X86_64_GOTTPOFF, R_X86_64_GOTTPOFF, },
228 { BFD_RELOC_X86_64_TPOFF32, R_X86_64_TPOFF32, },
229 { BFD_RELOC_64_PCREL, R_X86_64_PC64, },
230 { BFD_RELOC_X86_64_GOTOFF64, R_X86_64_GOTOFF64, },
231 { BFD_RELOC_X86_64_GOTPC32, R_X86_64_GOTPC32, },
232 { BFD_RELOC_X86_64_GOT64, R_X86_64_GOT64, },
233 { BFD_RELOC_X86_64_GOTPCREL64,R_X86_64_GOTPCREL64, },
234 { BFD_RELOC_X86_64_GOTPC64, R_X86_64_GOTPC64, },
235 { BFD_RELOC_X86_64_GOTPLT64, R_X86_64_GOTPLT64, },
236 { BFD_RELOC_X86_64_PLTOFF64, R_X86_64_PLTOFF64, },
237 { BFD_RELOC_X86_64_GOTPC32_TLSDESC, R_X86_64_GOTPC32_TLSDESC, },
238 { BFD_RELOC_X86_64_TLSDESC_CALL, R_X86_64_TLSDESC_CALL, },
239 { BFD_RELOC_X86_64_TLSDESC, R_X86_64_TLSDESC, },
240 { BFD_RELOC_X86_64_IRELATIVE, R_X86_64_IRELATIVE, },
241 { BFD_RELOC_VTABLE_INHERIT, R_X86_64_GNU_VTINHERIT, },
242 { BFD_RELOC_VTABLE_ENTRY, R_X86_64_GNU_VTENTRY, },
245 static reloc_howto_type *
246 elf_x86_64_rtype_to_howto (bfd *abfd, unsigned r_type)
250 if (r_type == (unsigned int) R_X86_64_32)
255 i = ARRAY_SIZE (x86_64_elf_howto_table) - 1;
257 else if (r_type < (unsigned int) R_X86_64_GNU_VTINHERIT
258 || r_type >= (unsigned int) R_X86_64_max)
260 if (r_type >= (unsigned int) R_X86_64_standard)
262 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
264 r_type = R_X86_64_NONE;
269 i = r_type - (unsigned int) R_X86_64_vt_offset;
270 BFD_ASSERT (x86_64_elf_howto_table[i].type == r_type);
271 return &x86_64_elf_howto_table[i];
274 /* Given a BFD reloc type, return a HOWTO structure. */
275 static reloc_howto_type *
276 elf_x86_64_reloc_type_lookup (bfd *abfd,
277 bfd_reloc_code_real_type code)
281 for (i = 0; i < sizeof (x86_64_reloc_map) / sizeof (struct elf_reloc_map);
284 if (x86_64_reloc_map[i].bfd_reloc_val == code)
285 return elf_x86_64_rtype_to_howto (abfd,
286 x86_64_reloc_map[i].elf_reloc_val);
291 static reloc_howto_type *
292 elf_x86_64_reloc_name_lookup (bfd *abfd,
297 if (!ABI_64_P (abfd) && strcasecmp (r_name, "R_X86_64_32") == 0)
299 /* Get x32 R_X86_64_32. */
300 reloc_howto_type *reloc
301 = &x86_64_elf_howto_table[ARRAY_SIZE (x86_64_elf_howto_table) - 1];
302 BFD_ASSERT (reloc->type == (unsigned int) R_X86_64_32);
306 for (i = 0; i < ARRAY_SIZE (x86_64_elf_howto_table); i++)
307 if (x86_64_elf_howto_table[i].name != NULL
308 && strcasecmp (x86_64_elf_howto_table[i].name, r_name) == 0)
309 return &x86_64_elf_howto_table[i];
314 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
317 elf_x86_64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
318 Elf_Internal_Rela *dst)
322 r_type = ELF32_R_TYPE (dst->r_info);
323 cache_ptr->howto = elf_x86_64_rtype_to_howto (abfd, r_type);
324 BFD_ASSERT (r_type == cache_ptr->howto->type);
327 /* Support for core dump NOTE sections. */
329 elf_x86_64_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
334 switch (note->descsz)
339 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
341 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
344 elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24);
352 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
354 elf_tdata (abfd)->core_signal
355 = bfd_get_16 (abfd, note->descdata + 12);
358 elf_tdata (abfd)->core_lwpid
359 = bfd_get_32 (abfd, note->descdata + 32);
368 /* Make a ".reg/999" section. */
369 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
370 size, note->descpos + offset);
374 elf_x86_64_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
376 switch (note->descsz)
381 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
382 elf_tdata (abfd)->core_pid
383 = bfd_get_32 (abfd, note->descdata + 12);
384 elf_tdata (abfd)->core_program
385 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
386 elf_tdata (abfd)->core_command
387 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
390 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
391 elf_tdata (abfd)->core_pid
392 = bfd_get_32 (abfd, note->descdata + 24);
393 elf_tdata (abfd)->core_program
394 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
395 elf_tdata (abfd)->core_command
396 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
399 /* Note that for some reason, a spurious space is tacked
400 onto the end of the args in some (at least one anyway)
401 implementations, so strip it off if it exists. */
404 char *command = elf_tdata (abfd)->core_command;
405 int n = strlen (command);
407 if (0 < n && command[n - 1] == ' ')
408 command[n - 1] = '\0';
416 elf_x86_64_write_core_note (bfd *abfd, char *buf, int *bufsiz,
419 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
423 const char *fname, *psargs;
434 va_start (ap, note_type);
435 fname = va_arg (ap, const char *);
436 psargs = va_arg (ap, const char *);
439 if (bed->s->elfclass == ELFCLASS32)
442 memset (&data, 0, sizeof (data));
443 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
444 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
445 p = (const void *) &data;
446 size = sizeof (data);
451 memset (&data, 0, sizeof (data));
452 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
453 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
454 p = (const void *) &data;
455 size = sizeof (data);
460 va_start (ap, note_type);
461 pid = va_arg (ap, long);
462 cursig = va_arg (ap, int);
463 gregs = va_arg (ap, const void *);
466 if (bed->s->elfclass == ELFCLASS32)
468 if (bed->elf_machine_code == EM_X86_64)
470 prstatusx32_t prstat;
471 memset (&prstat, 0, sizeof (prstat));
473 prstat.pr_cursig = cursig;
474 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
475 p = (const void *) &prstat;
476 size = sizeof (prstat);
481 memset (&prstat, 0, sizeof (prstat));
483 prstat.pr_cursig = cursig;
484 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
485 p = (const void *) &prstat;
486 size = sizeof (prstat);
492 memset (&prstat, 0, sizeof (prstat));
494 prstat.pr_cursig = cursig;
495 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
496 p = (const void *) &prstat;
497 size = sizeof (prstat);
502 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type, p,
507 /* Functions for the x86-64 ELF linker. */
509 /* The name of the dynamic interpreter. This is put in the .interp
512 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
513 #define ELF32_DYNAMIC_INTERPRETER "/lib/ld32.so.1"
515 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
516 copying dynamic variables from a shared lib into an app's dynbss
517 section, and instead use a dynamic relocation to point into the
519 #define ELIMINATE_COPY_RELOCS 1
521 /* The size in bytes of an entry in the global offset table. */
523 #define GOT_ENTRY_SIZE 8
525 /* The size in bytes of an entry in the procedure linkage table. */
527 #define PLT_ENTRY_SIZE 16
529 /* The first entry in a procedure linkage table looks like this. See the
530 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
532 static const bfd_byte elf_x86_64_plt0_entry[PLT_ENTRY_SIZE] =
534 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
535 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
536 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
539 /* Subsequent entries in a procedure linkage table look like this. */
541 static const bfd_byte elf_x86_64_plt_entry[PLT_ENTRY_SIZE] =
543 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
544 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
545 0x68, /* pushq immediate */
546 0, 0, 0, 0, /* replaced with index into relocation table. */
547 0xe9, /* jmp relative */
548 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
551 /* .eh_frame covering the .plt section. */
553 static const bfd_byte elf_x86_64_eh_frame_plt[] =
555 #define PLT_CIE_LENGTH 20
556 #define PLT_FDE_LENGTH 36
557 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
558 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
559 PLT_CIE_LENGTH, 0, 0, 0, /* CIE length */
560 0, 0, 0, 0, /* CIE ID */
562 'z', 'R', 0, /* Augmentation string */
563 1, /* Code alignment factor */
564 0x78, /* Data alignment factor */
565 16, /* Return address column */
566 1, /* Augmentation size */
567 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
568 DW_CFA_def_cfa, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
569 DW_CFA_offset + 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
570 DW_CFA_nop, DW_CFA_nop,
572 PLT_FDE_LENGTH, 0, 0, 0, /* FDE length */
573 PLT_CIE_LENGTH + 8, 0, 0, 0, /* CIE pointer */
574 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
575 0, 0, 0, 0, /* .plt size goes here */
576 0, /* Augmentation size */
577 DW_CFA_def_cfa_offset, 16, /* DW_CFA_def_cfa_offset: 16 */
578 DW_CFA_advance_loc + 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
579 DW_CFA_def_cfa_offset, 24, /* DW_CFA_def_cfa_offset: 24 */
580 DW_CFA_advance_loc + 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
581 DW_CFA_def_cfa_expression, /* DW_CFA_def_cfa_expression */
582 11, /* Block length */
583 DW_OP_breg7, 8, /* DW_OP_breg7 (rsp): 8 */
584 DW_OP_breg16, 0, /* DW_OP_breg16 (rip): 0 */
585 DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
586 DW_OP_lit3, DW_OP_shl, DW_OP_plus,
587 DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
590 /* x86-64 ELF linker hash entry. */
592 struct elf_x86_64_link_hash_entry
594 struct elf_link_hash_entry elf;
596 /* Track dynamic relocs copied for this symbol. */
597 struct elf_dyn_relocs *dyn_relocs;
599 #define GOT_UNKNOWN 0
603 #define GOT_TLS_GDESC 4
604 #define GOT_TLS_GD_BOTH_P(type) \
605 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
606 #define GOT_TLS_GD_P(type) \
607 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
608 #define GOT_TLS_GDESC_P(type) \
609 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
610 #define GOT_TLS_GD_ANY_P(type) \
611 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
612 unsigned char tls_type;
614 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
615 starting at the end of the jump table. */
619 #define elf_x86_64_hash_entry(ent) \
620 ((struct elf_x86_64_link_hash_entry *)(ent))
622 struct elf_x86_64_obj_tdata
624 struct elf_obj_tdata root;
626 /* tls_type for each local got entry. */
627 char *local_got_tls_type;
629 /* GOTPLT entries for TLS descriptors. */
630 bfd_vma *local_tlsdesc_gotent;
633 #define elf_x86_64_tdata(abfd) \
634 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
636 #define elf_x86_64_local_got_tls_type(abfd) \
637 (elf_x86_64_tdata (abfd)->local_got_tls_type)
639 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
640 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
642 #define is_x86_64_elf(bfd) \
643 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
644 && elf_tdata (bfd) != NULL \
645 && elf_object_id (bfd) == X86_64_ELF_DATA)
648 elf_x86_64_mkobject (bfd *abfd)
650 return bfd_elf_allocate_object (abfd, sizeof (struct elf_x86_64_obj_tdata),
654 /* x86-64 ELF linker hash table. */
656 struct elf_x86_64_link_hash_table
658 struct elf_link_hash_table elf;
660 /* Short-cuts to get to dynamic linker sections. */
663 asection *plt_eh_frame;
667 bfd_signed_vma refcount;
671 /* The amount of space used by the jump slots in the GOT. */
672 bfd_vma sgotplt_jump_table_size;
674 /* Small local sym cache. */
675 struct sym_cache sym_cache;
677 bfd_vma (*r_info) (bfd_vma, bfd_vma);
678 bfd_vma (*r_sym) (bfd_vma);
679 unsigned int pointer_r_type;
680 const char *dynamic_interpreter;
681 int dynamic_interpreter_size;
683 /* _TLS_MODULE_BASE_ symbol. */
684 struct bfd_link_hash_entry *tls_module_base;
686 /* Used by local STT_GNU_IFUNC symbols. */
687 htab_t loc_hash_table;
688 void * loc_hash_memory;
690 /* The offset into splt of the PLT entry for the TLS descriptor
691 resolver. Special values are 0, if not necessary (or not found
692 to be necessary yet), and -1 if needed but not determined
695 /* The offset into sgot of the GOT entry used by the PLT entry
700 /* Get the x86-64 ELF linker hash table from a link_info structure. */
702 #define elf_x86_64_hash_table(p) \
703 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
704 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
706 #define elf_x86_64_compute_jump_table_size(htab) \
707 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
709 /* Create an entry in an x86-64 ELF linker hash table. */
711 static struct bfd_hash_entry *
712 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry *entry,
713 struct bfd_hash_table *table,
716 /* Allocate the structure if it has not already been allocated by a
720 entry = (struct bfd_hash_entry *)
721 bfd_hash_allocate (table,
722 sizeof (struct elf_x86_64_link_hash_entry));
727 /* Call the allocation method of the superclass. */
728 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
731 struct elf_x86_64_link_hash_entry *eh;
733 eh = (struct elf_x86_64_link_hash_entry *) entry;
734 eh->dyn_relocs = NULL;
735 eh->tls_type = GOT_UNKNOWN;
736 eh->tlsdesc_got = (bfd_vma) -1;
742 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
743 for local symbol so that we can handle local STT_GNU_IFUNC symbols
744 as global symbol. We reuse indx and dynstr_index for local symbol
745 hash since they aren't used by global symbols in this backend. */
748 elf_x86_64_local_htab_hash (const void *ptr)
750 struct elf_link_hash_entry *h
751 = (struct elf_link_hash_entry *) ptr;
752 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
755 /* Compare local hash entries. */
758 elf_x86_64_local_htab_eq (const void *ptr1, const void *ptr2)
760 struct elf_link_hash_entry *h1
761 = (struct elf_link_hash_entry *) ptr1;
762 struct elf_link_hash_entry *h2
763 = (struct elf_link_hash_entry *) ptr2;
765 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
768 /* Find and/or create a hash entry for local symbol. */
770 static struct elf_link_hash_entry *
771 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table *htab,
772 bfd *abfd, const Elf_Internal_Rela *rel,
775 struct elf_x86_64_link_hash_entry e, *ret;
776 asection *sec = abfd->sections;
777 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
778 htab->r_sym (rel->r_info));
781 e.elf.indx = sec->id;
782 e.elf.dynstr_index = htab->r_sym (rel->r_info);
783 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
784 create ? INSERT : NO_INSERT);
791 ret = (struct elf_x86_64_link_hash_entry *) *slot;
795 ret = (struct elf_x86_64_link_hash_entry *)
796 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
797 sizeof (struct elf_x86_64_link_hash_entry));
800 memset (ret, 0, sizeof (*ret));
801 ret->elf.indx = sec->id;
802 ret->elf.dynstr_index = htab->r_sym (rel->r_info);
803 ret->elf.dynindx = -1;
809 /* Create an X86-64 ELF linker hash table. */
811 static struct bfd_link_hash_table *
812 elf_x86_64_link_hash_table_create (bfd *abfd)
814 struct elf_x86_64_link_hash_table *ret;
815 bfd_size_type amt = sizeof (struct elf_x86_64_link_hash_table);
817 ret = (struct elf_x86_64_link_hash_table *) bfd_malloc (amt);
821 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
822 elf_x86_64_link_hash_newfunc,
823 sizeof (struct elf_x86_64_link_hash_entry),
832 ret->plt_eh_frame = NULL;
833 ret->sym_cache.abfd = NULL;
834 ret->tlsdesc_plt = 0;
835 ret->tlsdesc_got = 0;
836 ret->tls_ld_got.refcount = 0;
837 ret->sgotplt_jump_table_size = 0;
838 ret->tls_module_base = NULL;
842 ret->r_info = elf64_r_info;
843 ret->r_sym = elf64_r_sym;
844 ret->pointer_r_type = R_X86_64_64;
845 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
846 ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
850 ret->r_info = elf32_r_info;
851 ret->r_sym = elf32_r_sym;
852 ret->pointer_r_type = R_X86_64_32;
853 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
854 ret->dynamic_interpreter_size = sizeof ELF32_DYNAMIC_INTERPRETER;
857 ret->loc_hash_table = htab_try_create (1024,
858 elf_x86_64_local_htab_hash,
859 elf_x86_64_local_htab_eq,
861 ret->loc_hash_memory = objalloc_create ();
862 if (!ret->loc_hash_table || !ret->loc_hash_memory)
868 return &ret->elf.root;
871 /* Destroy an X86-64 ELF linker hash table. */
874 elf_x86_64_link_hash_table_free (struct bfd_link_hash_table *hash)
876 struct elf_x86_64_link_hash_table *htab
877 = (struct elf_x86_64_link_hash_table *) hash;
879 if (htab->loc_hash_table)
880 htab_delete (htab->loc_hash_table);
881 if (htab->loc_hash_memory)
882 objalloc_free ((struct objalloc *) htab->loc_hash_memory);
883 _bfd_generic_link_hash_table_free (hash);
886 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
887 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
891 elf_x86_64_create_dynamic_sections (bfd *dynobj,
892 struct bfd_link_info *info)
894 struct elf_x86_64_link_hash_table *htab;
896 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
899 htab = elf_x86_64_hash_table (info);
903 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
905 htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
908 || (!info->shared && !htab->srelbss))
911 if (!info->no_ld_generated_unwind_info
912 && bfd_get_section_by_name (dynobj, ".eh_frame") == NULL
913 && htab->elf.splt != NULL)
915 flagword flags = get_elf_backend_data (dynobj)->dynamic_sec_flags;
917 = bfd_make_section_with_flags (dynobj, ".eh_frame",
918 flags | SEC_READONLY);
919 if (htab->plt_eh_frame == NULL
920 || !bfd_set_section_alignment (dynobj, htab->plt_eh_frame, 3))
923 htab->plt_eh_frame->size = sizeof (elf_x86_64_eh_frame_plt);
924 htab->plt_eh_frame->contents
925 = bfd_alloc (dynobj, htab->plt_eh_frame->size);
926 memcpy (htab->plt_eh_frame->contents, elf_x86_64_eh_frame_plt,
927 sizeof (elf_x86_64_eh_frame_plt));
932 /* Copy the extra info we tack onto an elf_link_hash_entry. */
935 elf_x86_64_copy_indirect_symbol (struct bfd_link_info *info,
936 struct elf_link_hash_entry *dir,
937 struct elf_link_hash_entry *ind)
939 struct elf_x86_64_link_hash_entry *edir, *eind;
941 edir = (struct elf_x86_64_link_hash_entry *) dir;
942 eind = (struct elf_x86_64_link_hash_entry *) ind;
944 if (eind->dyn_relocs != NULL)
946 if (edir->dyn_relocs != NULL)
948 struct elf_dyn_relocs **pp;
949 struct elf_dyn_relocs *p;
951 /* Add reloc counts against the indirect sym to the direct sym
952 list. Merge any entries against the same section. */
953 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
955 struct elf_dyn_relocs *q;
957 for (q = edir->dyn_relocs; q != NULL; q = q->next)
958 if (q->sec == p->sec)
960 q->pc_count += p->pc_count;
961 q->count += p->count;
968 *pp = edir->dyn_relocs;
971 edir->dyn_relocs = eind->dyn_relocs;
972 eind->dyn_relocs = NULL;
975 if (ind->root.type == bfd_link_hash_indirect
976 && dir->got.refcount <= 0)
978 edir->tls_type = eind->tls_type;
979 eind->tls_type = GOT_UNKNOWN;
982 if (ELIMINATE_COPY_RELOCS
983 && ind->root.type != bfd_link_hash_indirect
984 && dir->dynamic_adjusted)
986 /* If called to transfer flags for a weakdef during processing
987 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
988 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
989 dir->ref_dynamic |= ind->ref_dynamic;
990 dir->ref_regular |= ind->ref_regular;
991 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
992 dir->needs_plt |= ind->needs_plt;
993 dir->pointer_equality_needed |= ind->pointer_equality_needed;
996 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1000 elf64_x86_64_elf_object_p (bfd *abfd)
1002 /* Set the right machine number for an x86-64 elf64 file. */
1003 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64);
1021 /* Return TRUE if the TLS access code sequence support transition
1025 elf_x86_64_check_tls_transition (bfd *abfd,
1026 struct bfd_link_info *info,
1029 Elf_Internal_Shdr *symtab_hdr,
1030 struct elf_link_hash_entry **sym_hashes,
1031 unsigned int r_type,
1032 const Elf_Internal_Rela *rel,
1033 const Elf_Internal_Rela *relend)
1036 unsigned long r_symndx;
1037 struct elf_link_hash_entry *h;
1039 struct elf_x86_64_link_hash_table *htab;
1041 /* Get the section contents. */
1042 if (contents == NULL)
1044 if (elf_section_data (sec)->this_hdr.contents != NULL)
1045 contents = elf_section_data (sec)->this_hdr.contents;
1048 /* FIXME: How to better handle error condition? */
1049 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1052 /* Cache the section contents for elf_link_input_bfd. */
1053 elf_section_data (sec)->this_hdr.contents = contents;
1057 htab = elf_x86_64_hash_table (info);
1058 offset = rel->r_offset;
1061 case R_X86_64_TLSGD:
1062 case R_X86_64_TLSLD:
1063 if ((rel + 1) >= relend)
1066 if (r_type == R_X86_64_TLSGD)
1068 /* Check transition from GD access model. For 64bit, only
1069 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1070 .word 0x6666; rex64; call __tls_get_addr
1071 can transit to different access model. For 32bit, only
1072 leaq foo@tlsgd(%rip), %rdi
1073 .word 0x6666; rex64; call __tls_get_addr
1074 can transit to different access model. */
1076 static x86_64_opcode32 call = { { 0x66, 0x66, 0x48, 0xe8 } };
1077 if ((offset + 12) > sec->size
1078 || bfd_get_32 (abfd, contents + offset + 4) != call.i)
1081 if (ABI_64_P (abfd))
1083 static x86_64_opcode32 leaq = { { 0x66, 0x48, 0x8d, 0x3d } };
1085 || bfd_get_32 (abfd, contents + offset - 4) != leaq.i)
1090 static x86_64_opcode16 lea = { { 0x8d, 0x3d } };
1092 || bfd_get_8 (abfd, contents + offset - 3) != 0x48
1093 || bfd_get_16 (abfd, contents + offset - 2) != lea.i)
1099 /* Check transition from LD access model. Only
1100 leaq foo@tlsld(%rip), %rdi;
1102 can transit to different access model. */
1104 static x86_64_opcode32 ld = { { 0x48, 0x8d, 0x3d, 0xe8 } };
1107 if (offset < 3 || (offset + 9) > sec->size)
1110 op.i = bfd_get_32 (abfd, contents + offset - 3);
1111 op.c[3] = bfd_get_8 (abfd, contents + offset + 4);
1116 r_symndx = htab->r_sym (rel[1].r_info);
1117 if (r_symndx < symtab_hdr->sh_info)
1120 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1121 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1122 may be versioned. */
1124 && h->root.root.string != NULL
1125 && (ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PC32
1126 || ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PLT32)
1127 && (strncmp (h->root.root.string,
1128 "__tls_get_addr", 14) == 0));
1130 case R_X86_64_GOTTPOFF:
1131 /* Check transition from IE access model:
1132 mov foo@gottpoff(%rip), %reg
1133 add foo@gottpoff(%rip), %reg
1136 /* Check REX prefix first. */
1137 if (offset >= 3 && (offset + 4) <= sec->size)
1139 val = bfd_get_8 (abfd, contents + offset - 3);
1140 if (val != 0x48 && val != 0x4c)
1142 /* X32 may have 0x44 REX prefix or no REX prefix. */
1143 if (ABI_64_P (abfd))
1149 /* X32 may not have any REX prefix. */
1150 if (ABI_64_P (abfd))
1152 if (offset < 2 || (offset + 3) > sec->size)
1156 val = bfd_get_8 (abfd, contents + offset - 2);
1157 if (val != 0x8b && val != 0x03)
1160 val = bfd_get_8 (abfd, contents + offset - 1);
1161 return (val & 0xc7) == 5;
1163 case R_X86_64_GOTPC32_TLSDESC:
1164 /* Check transition from GDesc access model:
1165 leaq x@tlsdesc(%rip), %rax
1167 Make sure it's a leaq adding rip to a 32-bit offset
1168 into any register, although it's probably almost always
1171 if (offset < 3 || (offset + 4) > sec->size)
1174 val = bfd_get_8 (abfd, contents + offset - 3);
1175 if ((val & 0xfb) != 0x48)
1178 if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1181 val = bfd_get_8 (abfd, contents + offset - 1);
1182 return (val & 0xc7) == 0x05;
1184 case R_X86_64_TLSDESC_CALL:
1185 /* Check transition from GDesc access model:
1186 call *x@tlsdesc(%rax)
1188 if (offset + 2 <= sec->size)
1190 /* Make sure that it's a call *x@tlsdesc(%rax). */
1191 static x86_64_opcode16 call = { { 0xff, 0x10 } };
1192 return bfd_get_16 (abfd, contents + offset) == call.i;
1202 /* Return TRUE if the TLS access transition is OK or no transition
1203 will be performed. Update R_TYPE if there is a transition. */
1206 elf_x86_64_tls_transition (struct bfd_link_info *info, bfd *abfd,
1207 asection *sec, bfd_byte *contents,
1208 Elf_Internal_Shdr *symtab_hdr,
1209 struct elf_link_hash_entry **sym_hashes,
1210 unsigned int *r_type, int tls_type,
1211 const Elf_Internal_Rela *rel,
1212 const Elf_Internal_Rela *relend,
1213 struct elf_link_hash_entry *h,
1214 unsigned long r_symndx)
1216 unsigned int from_type = *r_type;
1217 unsigned int to_type = from_type;
1218 bfd_boolean check = TRUE;
1220 /* Skip TLS transition for functions. */
1222 && (h->type == STT_FUNC
1223 || h->type == STT_GNU_IFUNC))
1228 case R_X86_64_TLSGD:
1229 case R_X86_64_GOTPC32_TLSDESC:
1230 case R_X86_64_TLSDESC_CALL:
1231 case R_X86_64_GOTTPOFF:
1232 if (info->executable)
1235 to_type = R_X86_64_TPOFF32;
1237 to_type = R_X86_64_GOTTPOFF;
1240 /* When we are called from elf_x86_64_relocate_section,
1241 CONTENTS isn't NULL and there may be additional transitions
1242 based on TLS_TYPE. */
1243 if (contents != NULL)
1245 unsigned int new_to_type = to_type;
1247 if (info->executable
1250 && tls_type == GOT_TLS_IE)
1251 new_to_type = R_X86_64_TPOFF32;
1253 if (to_type == R_X86_64_TLSGD
1254 || to_type == R_X86_64_GOTPC32_TLSDESC
1255 || to_type == R_X86_64_TLSDESC_CALL)
1257 if (tls_type == GOT_TLS_IE)
1258 new_to_type = R_X86_64_GOTTPOFF;
1261 /* We checked the transition before when we were called from
1262 elf_x86_64_check_relocs. We only want to check the new
1263 transition which hasn't been checked before. */
1264 check = new_to_type != to_type && from_type == to_type;
1265 to_type = new_to_type;
1270 case R_X86_64_TLSLD:
1271 if (info->executable)
1272 to_type = R_X86_64_TPOFF32;
1279 /* Return TRUE if there is no transition. */
1280 if (from_type == to_type)
1283 /* Check if the transition can be performed. */
1285 && ! elf_x86_64_check_tls_transition (abfd, info, sec, contents,
1286 symtab_hdr, sym_hashes,
1287 from_type, rel, relend))
1289 reloc_howto_type *from, *to;
1292 from = elf_x86_64_rtype_to_howto (abfd, from_type);
1293 to = elf_x86_64_rtype_to_howto (abfd, to_type);
1296 name = h->root.root.string;
1299 struct elf_x86_64_link_hash_table *htab;
1301 htab = elf_x86_64_hash_table (info);
1306 Elf_Internal_Sym *isym;
1308 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1310 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1314 (*_bfd_error_handler)
1315 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1316 "in section `%A' failed"),
1317 abfd, sec, from->name, to->name, name,
1318 (unsigned long) rel->r_offset);
1319 bfd_set_error (bfd_error_bad_value);
1327 /* Look through the relocs for a section during the first phase, and
1328 calculate needed space in the global offset table, procedure
1329 linkage table, and dynamic reloc sections. */
1332 elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info,
1334 const Elf_Internal_Rela *relocs)
1336 struct elf_x86_64_link_hash_table *htab;
1337 Elf_Internal_Shdr *symtab_hdr;
1338 struct elf_link_hash_entry **sym_hashes;
1339 const Elf_Internal_Rela *rel;
1340 const Elf_Internal_Rela *rel_end;
1343 if (info->relocatable)
1346 BFD_ASSERT (is_x86_64_elf (abfd));
1348 htab = elf_x86_64_hash_table (info);
1352 symtab_hdr = &elf_symtab_hdr (abfd);
1353 sym_hashes = elf_sym_hashes (abfd);
1357 rel_end = relocs + sec->reloc_count;
1358 for (rel = relocs; rel < rel_end; rel++)
1360 unsigned int r_type;
1361 unsigned long r_symndx;
1362 struct elf_link_hash_entry *h;
1363 Elf_Internal_Sym *isym;
1366 r_symndx = htab->r_sym (rel->r_info);
1367 r_type = ELF32_R_TYPE (rel->r_info);
1369 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1371 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1376 if (r_symndx < symtab_hdr->sh_info)
1378 /* A local symbol. */
1379 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1384 /* Check relocation against local STT_GNU_IFUNC symbol. */
1385 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1387 h = elf_x86_64_get_local_sym_hash (htab, abfd, rel,
1392 /* Fake a STT_GNU_IFUNC symbol. */
1393 h->type = STT_GNU_IFUNC;
1396 h->forced_local = 1;
1397 h->root.type = bfd_link_hash_defined;
1405 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1406 while (h->root.type == bfd_link_hash_indirect
1407 || h->root.type == bfd_link_hash_warning)
1408 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1411 /* Check invalid x32 relocations. */
1412 if (!ABI_64_P (abfd))
1418 case R_X86_64_DTPOFF64:
1419 case R_X86_64_TPOFF64:
1421 case R_X86_64_GOTOFF64:
1422 case R_X86_64_GOT64:
1423 case R_X86_64_GOTPCREL64:
1424 case R_X86_64_GOTPC64:
1425 case R_X86_64_GOTPLT64:
1426 case R_X86_64_PLTOFF64:
1429 name = h->root.root.string;
1431 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1433 (*_bfd_error_handler)
1434 (_("%B: relocation %s against symbol `%s' isn't "
1435 "supported in x32 mode"), abfd,
1436 x86_64_elf_howto_table[r_type].name, name);
1437 bfd_set_error (bfd_error_bad_value);
1445 /* Create the ifunc sections for static executables. If we
1446 never see an indirect function symbol nor we are building
1447 a static executable, those sections will be empty and
1448 won't appear in output. */
1459 case R_X86_64_PLT32:
1460 case R_X86_64_GOTPCREL:
1461 case R_X86_64_GOTPCREL64:
1462 if (htab->elf.dynobj == NULL)
1463 htab->elf.dynobj = abfd;
1464 if (!_bfd_elf_create_ifunc_sections (htab->elf.dynobj, info))
1469 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
1470 it here if it is defined in a non-shared object. */
1471 if (h->type == STT_GNU_IFUNC
1474 /* It is referenced by a non-shared object. */
1478 /* STT_GNU_IFUNC symbol must go through PLT. */
1479 h->plt.refcount += 1;
1481 /* STT_GNU_IFUNC needs dynamic sections. */
1482 if (htab->elf.dynobj == NULL)
1483 htab->elf.dynobj = abfd;
1488 if (h->root.root.string)
1489 name = h->root.root.string;
1491 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1493 (*_bfd_error_handler)
1494 (_("%B: relocation %s against STT_GNU_IFUNC "
1495 "symbol `%s' isn't handled by %s"), abfd,
1496 x86_64_elf_howto_table[r_type].name,
1497 name, __FUNCTION__);
1498 bfd_set_error (bfd_error_bad_value);
1502 if (ABI_64_P (abfd))
1506 h->pointer_equality_needed = 1;
1509 /* We must copy these reloc types into the output
1510 file. Create a reloc section in dynobj and
1511 make room for this reloc. */
1512 sreloc = _bfd_elf_create_ifunc_dyn_reloc
1513 (abfd, info, sec, sreloc,
1514 &((struct elf_x86_64_link_hash_entry *) h)->dyn_relocs);
1525 if (r_type != R_X86_64_PC32
1526 && r_type != R_X86_64_PC64)
1527 h->pointer_equality_needed = 1;
1530 case R_X86_64_PLT32:
1533 case R_X86_64_GOTPCREL:
1534 case R_X86_64_GOTPCREL64:
1535 h->got.refcount += 1;
1536 if (htab->elf.sgot == NULL
1537 && !_bfd_elf_create_got_section (htab->elf.dynobj,
1547 if (! elf_x86_64_tls_transition (info, abfd, sec, NULL,
1548 symtab_hdr, sym_hashes,
1549 &r_type, GOT_UNKNOWN,
1550 rel, rel_end, h, r_symndx))
1555 case R_X86_64_TLSLD:
1556 htab->tls_ld_got.refcount += 1;
1559 case R_X86_64_TPOFF32:
1560 if (!info->executable && ABI_64_P (abfd))
1563 name = h->root.root.string;
1565 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1567 (*_bfd_error_handler)
1568 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1570 x86_64_elf_howto_table[r_type].name, name);
1571 bfd_set_error (bfd_error_bad_value);
1576 case R_X86_64_GOTTPOFF:
1577 if (!info->executable)
1578 info->flags |= DF_STATIC_TLS;
1581 case R_X86_64_GOT32:
1582 case R_X86_64_GOTPCREL:
1583 case R_X86_64_TLSGD:
1584 case R_X86_64_GOT64:
1585 case R_X86_64_GOTPCREL64:
1586 case R_X86_64_GOTPLT64:
1587 case R_X86_64_GOTPC32_TLSDESC:
1588 case R_X86_64_TLSDESC_CALL:
1589 /* This symbol requires a global offset table entry. */
1591 int tls_type, old_tls_type;
1595 default: tls_type = GOT_NORMAL; break;
1596 case R_X86_64_TLSGD: tls_type = GOT_TLS_GD; break;
1597 case R_X86_64_GOTTPOFF: tls_type = GOT_TLS_IE; break;
1598 case R_X86_64_GOTPC32_TLSDESC:
1599 case R_X86_64_TLSDESC_CALL:
1600 tls_type = GOT_TLS_GDESC; break;
1605 if (r_type == R_X86_64_GOTPLT64)
1607 /* This relocation indicates that we also need
1608 a PLT entry, as this is a function. We don't need
1609 a PLT entry for local symbols. */
1611 h->plt.refcount += 1;
1613 h->got.refcount += 1;
1614 old_tls_type = elf_x86_64_hash_entry (h)->tls_type;
1618 bfd_signed_vma *local_got_refcounts;
1620 /* This is a global offset table entry for a local symbol. */
1621 local_got_refcounts = elf_local_got_refcounts (abfd);
1622 if (local_got_refcounts == NULL)
1626 size = symtab_hdr->sh_info;
1627 size *= sizeof (bfd_signed_vma)
1628 + sizeof (bfd_vma) + sizeof (char);
1629 local_got_refcounts = ((bfd_signed_vma *)
1630 bfd_zalloc (abfd, size));
1631 if (local_got_refcounts == NULL)
1633 elf_local_got_refcounts (abfd) = local_got_refcounts;
1634 elf_x86_64_local_tlsdesc_gotent (abfd)
1635 = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
1636 elf_x86_64_local_got_tls_type (abfd)
1637 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
1639 local_got_refcounts[r_symndx] += 1;
1641 = elf_x86_64_local_got_tls_type (abfd) [r_symndx];
1644 /* If a TLS symbol is accessed using IE at least once,
1645 there is no point to use dynamic model for it. */
1646 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1647 && (! GOT_TLS_GD_ANY_P (old_tls_type)
1648 || tls_type != GOT_TLS_IE))
1650 if (old_tls_type == GOT_TLS_IE && GOT_TLS_GD_ANY_P (tls_type))
1651 tls_type = old_tls_type;
1652 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1653 && GOT_TLS_GD_ANY_P (tls_type))
1654 tls_type |= old_tls_type;
1658 name = h->root.root.string;
1660 name = bfd_elf_sym_name (abfd, symtab_hdr,
1662 (*_bfd_error_handler)
1663 (_("%B: '%s' accessed both as normal and thread local symbol"),
1669 if (old_tls_type != tls_type)
1672 elf_x86_64_hash_entry (h)->tls_type = tls_type;
1674 elf_x86_64_local_got_tls_type (abfd) [r_symndx] = tls_type;
1679 case R_X86_64_GOTOFF64:
1680 case R_X86_64_GOTPC32:
1681 case R_X86_64_GOTPC64:
1683 if (htab->elf.sgot == NULL)
1685 if (htab->elf.dynobj == NULL)
1686 htab->elf.dynobj = abfd;
1687 if (!_bfd_elf_create_got_section (htab->elf.dynobj,
1693 case R_X86_64_PLT32:
1694 /* This symbol requires a procedure linkage table entry. We
1695 actually build the entry in adjust_dynamic_symbol,
1696 because this might be a case of linking PIC code which is
1697 never referenced by a dynamic object, in which case we
1698 don't need to generate a procedure linkage table entry
1701 /* If this is a local symbol, we resolve it directly without
1702 creating a procedure linkage table entry. */
1707 h->plt.refcount += 1;
1710 case R_X86_64_PLTOFF64:
1711 /* This tries to form the 'address' of a function relative
1712 to GOT. For global symbols we need a PLT entry. */
1716 h->plt.refcount += 1;
1721 if (!ABI_64_P (abfd))
1726 /* Let's help debug shared library creation. These relocs
1727 cannot be used in shared libs. Don't error out for
1728 sections we don't care about, such as debug sections or
1729 non-constant sections. */
1731 && (sec->flags & SEC_ALLOC) != 0
1732 && (sec->flags & SEC_READONLY) != 0)
1735 name = h->root.root.string;
1737 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1738 (*_bfd_error_handler)
1739 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1740 abfd, x86_64_elf_howto_table[r_type].name, name);
1741 bfd_set_error (bfd_error_bad_value);
1752 if (h != NULL && info->executable)
1754 /* If this reloc is in a read-only section, we might
1755 need a copy reloc. We can't check reliably at this
1756 stage whether the section is read-only, as input
1757 sections have not yet been mapped to output sections.
1758 Tentatively set the flag for now, and correct in
1759 adjust_dynamic_symbol. */
1762 /* We may need a .plt entry if the function this reloc
1763 refers to is in a shared lib. */
1764 h->plt.refcount += 1;
1765 if (r_type != R_X86_64_PC32 && r_type != R_X86_64_PC64)
1766 h->pointer_equality_needed = 1;
1769 /* If we are creating a shared library, and this is a reloc
1770 against a global symbol, or a non PC relative reloc
1771 against a local symbol, then we need to copy the reloc
1772 into the shared library. However, if we are linking with
1773 -Bsymbolic, we do not need to copy a reloc against a
1774 global symbol which is defined in an object we are
1775 including in the link (i.e., DEF_REGULAR is set). At
1776 this point we have not seen all the input files, so it is
1777 possible that DEF_REGULAR is not set now but will be set
1778 later (it is never cleared). In case of a weak definition,
1779 DEF_REGULAR may be cleared later by a strong definition in
1780 a shared library. We account for that possibility below by
1781 storing information in the relocs_copied field of the hash
1782 table entry. A similar situation occurs when creating
1783 shared libraries and symbol visibility changes render the
1786 If on the other hand, we are creating an executable, we
1787 may need to keep relocations for symbols satisfied by a
1788 dynamic library if we manage to avoid copy relocs for the
1791 && (sec->flags & SEC_ALLOC) != 0
1792 && (! IS_X86_64_PCREL_TYPE (r_type)
1794 && (! SYMBOLIC_BIND (info, h)
1795 || h->root.type == bfd_link_hash_defweak
1796 || !h->def_regular))))
1797 || (ELIMINATE_COPY_RELOCS
1799 && (sec->flags & SEC_ALLOC) != 0
1801 && (h->root.type == bfd_link_hash_defweak
1802 || !h->def_regular)))
1804 struct elf_dyn_relocs *p;
1805 struct elf_dyn_relocs **head;
1807 /* We must copy these reloc types into the output file.
1808 Create a reloc section in dynobj and make room for
1812 if (htab->elf.dynobj == NULL)
1813 htab->elf.dynobj = abfd;
1815 sreloc = _bfd_elf_make_dynamic_reloc_section
1816 (sec, htab->elf.dynobj, ABI_64_P (abfd) ? 3 : 2,
1817 abfd, /*rela?*/ TRUE);
1823 /* If this is a global symbol, we count the number of
1824 relocations we need for this symbol. */
1827 head = &((struct elf_x86_64_link_hash_entry *) h)->dyn_relocs;
1831 /* Track dynamic relocs needed for local syms too.
1832 We really need local syms available to do this
1837 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1842 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1846 /* Beware of type punned pointers vs strict aliasing
1848 vpp = &(elf_section_data (s)->local_dynrel);
1849 head = (struct elf_dyn_relocs **)vpp;
1853 if (p == NULL || p->sec != sec)
1855 bfd_size_type amt = sizeof *p;
1857 p = ((struct elf_dyn_relocs *)
1858 bfd_alloc (htab->elf.dynobj, amt));
1869 if (IS_X86_64_PCREL_TYPE (r_type))
1874 /* This relocation describes the C++ object vtable hierarchy.
1875 Reconstruct it for later use during GC. */
1876 case R_X86_64_GNU_VTINHERIT:
1877 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1881 /* This relocation describes which C++ vtable entries are actually
1882 used. Record for later use during GC. */
1883 case R_X86_64_GNU_VTENTRY:
1884 BFD_ASSERT (h != NULL);
1886 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1898 /* Return the section that should be marked against GC for a given
1902 elf_x86_64_gc_mark_hook (asection *sec,
1903 struct bfd_link_info *info,
1904 Elf_Internal_Rela *rel,
1905 struct elf_link_hash_entry *h,
1906 Elf_Internal_Sym *sym)
1909 switch (ELF32_R_TYPE (rel->r_info))
1911 case R_X86_64_GNU_VTINHERIT:
1912 case R_X86_64_GNU_VTENTRY:
1916 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1919 /* Update the got entry reference counts for the section being removed. */
1922 elf_x86_64_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1924 const Elf_Internal_Rela *relocs)
1926 struct elf_x86_64_link_hash_table *htab;
1927 Elf_Internal_Shdr *symtab_hdr;
1928 struct elf_link_hash_entry **sym_hashes;
1929 bfd_signed_vma *local_got_refcounts;
1930 const Elf_Internal_Rela *rel, *relend;
1932 if (info->relocatable)
1935 htab = elf_x86_64_hash_table (info);
1939 elf_section_data (sec)->local_dynrel = NULL;
1941 symtab_hdr = &elf_symtab_hdr (abfd);
1942 sym_hashes = elf_sym_hashes (abfd);
1943 local_got_refcounts = elf_local_got_refcounts (abfd);
1945 htab = elf_x86_64_hash_table (info);
1946 relend = relocs + sec->reloc_count;
1947 for (rel = relocs; rel < relend; rel++)
1949 unsigned long r_symndx;
1950 unsigned int r_type;
1951 struct elf_link_hash_entry *h = NULL;
1953 r_symndx = htab->r_sym (rel->r_info);
1954 if (r_symndx >= symtab_hdr->sh_info)
1956 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1957 while (h->root.type == bfd_link_hash_indirect
1958 || h->root.type == bfd_link_hash_warning)
1959 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1963 /* A local symbol. */
1964 Elf_Internal_Sym *isym;
1966 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1969 /* Check relocation against local STT_GNU_IFUNC symbol. */
1971 && ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1973 h = elf_x86_64_get_local_sym_hash (htab, abfd, rel, FALSE);
1981 struct elf_x86_64_link_hash_entry *eh;
1982 struct elf_dyn_relocs **pp;
1983 struct elf_dyn_relocs *p;
1985 eh = (struct elf_x86_64_link_hash_entry *) h;
1987 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1990 /* Everything must go for SEC. */
1996 r_type = ELF32_R_TYPE (rel->r_info);
1997 if (! elf_x86_64_tls_transition (info, abfd, sec, NULL,
1998 symtab_hdr, sym_hashes,
1999 &r_type, GOT_UNKNOWN,
2000 rel, relend, h, r_symndx))
2005 case R_X86_64_TLSLD:
2006 if (htab->tls_ld_got.refcount > 0)
2007 htab->tls_ld_got.refcount -= 1;
2010 case R_X86_64_TLSGD:
2011 case R_X86_64_GOTPC32_TLSDESC:
2012 case R_X86_64_TLSDESC_CALL:
2013 case R_X86_64_GOTTPOFF:
2014 case R_X86_64_GOT32:
2015 case R_X86_64_GOTPCREL:
2016 case R_X86_64_GOT64:
2017 case R_X86_64_GOTPCREL64:
2018 case R_X86_64_GOTPLT64:
2021 if (r_type == R_X86_64_GOTPLT64 && h->plt.refcount > 0)
2022 h->plt.refcount -= 1;
2023 if (h->got.refcount > 0)
2024 h->got.refcount -= 1;
2025 if (h->type == STT_GNU_IFUNC)
2027 if (h->plt.refcount > 0)
2028 h->plt.refcount -= 1;
2031 else if (local_got_refcounts != NULL)
2033 if (local_got_refcounts[r_symndx] > 0)
2034 local_got_refcounts[r_symndx] -= 1;
2048 && (h == NULL || h->type != STT_GNU_IFUNC))
2052 case R_X86_64_PLT32:
2053 case R_X86_64_PLTOFF64:
2056 if (h->plt.refcount > 0)
2057 h->plt.refcount -= 1;
2069 /* Adjust a symbol defined by a dynamic object and referenced by a
2070 regular object. The current definition is in some section of the
2071 dynamic object, but we're not including those sections. We have to
2072 change the definition to something the rest of the link can
2076 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info *info,
2077 struct elf_link_hash_entry *h)
2079 struct elf_x86_64_link_hash_table *htab;
2082 /* STT_GNU_IFUNC symbol must go through PLT. */
2083 if (h->type == STT_GNU_IFUNC)
2085 if (h->plt.refcount <= 0)
2087 h->plt.offset = (bfd_vma) -1;
2093 /* If this is a function, put it in the procedure linkage table. We
2094 will fill in the contents of the procedure linkage table later,
2095 when we know the address of the .got section. */
2096 if (h->type == STT_FUNC
2099 if (h->plt.refcount <= 0
2100 || SYMBOL_CALLS_LOCAL (info, h)
2101 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2102 && h->root.type == bfd_link_hash_undefweak))
2104 /* This case can occur if we saw a PLT32 reloc in an input
2105 file, but the symbol was never referred to by a dynamic
2106 object, or if all references were garbage collected. In
2107 such a case, we don't actually need to build a procedure
2108 linkage table, and we can just do a PC32 reloc instead. */
2109 h->plt.offset = (bfd_vma) -1;
2116 /* It's possible that we incorrectly decided a .plt reloc was
2117 needed for an R_X86_64_PC32 reloc to a non-function sym in
2118 check_relocs. We can't decide accurately between function and
2119 non-function syms in check-relocs; Objects loaded later in
2120 the link may change h->type. So fix it now. */
2121 h->plt.offset = (bfd_vma) -1;
2123 /* If this is a weak symbol, and there is a real definition, the
2124 processor independent code will have arranged for us to see the
2125 real definition first, and we can just use the same value. */
2126 if (h->u.weakdef != NULL)
2128 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2129 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2130 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2131 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2132 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
2133 h->non_got_ref = h->u.weakdef->non_got_ref;
2137 /* This is a reference to a symbol defined by a dynamic object which
2138 is not a function. */
2140 /* If we are creating a shared library, we must presume that the
2141 only references to the symbol are via the global offset table.
2142 For such cases we need not do anything here; the relocations will
2143 be handled correctly by relocate_section. */
2147 /* If there are no references to this symbol that do not use the
2148 GOT, we don't need to generate a copy reloc. */
2149 if (!h->non_got_ref)
2152 /* If -z nocopyreloc was given, we won't generate them either. */
2153 if (info->nocopyreloc)
2159 if (ELIMINATE_COPY_RELOCS)
2161 struct elf_x86_64_link_hash_entry * eh;
2162 struct elf_dyn_relocs *p;
2164 eh = (struct elf_x86_64_link_hash_entry *) h;
2165 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2167 s = p->sec->output_section;
2168 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2172 /* If we didn't find any dynamic relocs in read-only sections, then
2173 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2183 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
2184 h->root.root.string);
2188 /* We must allocate the symbol in our .dynbss section, which will
2189 become part of the .bss section of the executable. There will be
2190 an entry for this symbol in the .dynsym section. The dynamic
2191 object will contain position independent code, so all references
2192 from the dynamic object to this symbol will go through the global
2193 offset table. The dynamic linker will use the .dynsym entry to
2194 determine the address it must put in the global offset table, so
2195 both the dynamic object and the regular object will refer to the
2196 same memory location for the variable. */
2198 htab = elf_x86_64_hash_table (info);
2202 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2203 to copy the initial value out of the dynamic object and into the
2204 runtime process image. */
2205 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2207 const struct elf_backend_data *bed;
2208 bed = get_elf_backend_data (info->output_bfd);
2209 htab->srelbss->size += bed->s->sizeof_rela;
2215 return _bfd_elf_adjust_dynamic_copy (h, s);
2218 /* Allocate space in .plt, .got and associated reloc sections for
2222 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2224 struct bfd_link_info *info;
2225 struct elf_x86_64_link_hash_table *htab;
2226 struct elf_x86_64_link_hash_entry *eh;
2227 struct elf_dyn_relocs *p;
2228 const struct elf_backend_data *bed;
2230 if (h->root.type == bfd_link_hash_indirect)
2233 eh = (struct elf_x86_64_link_hash_entry *) h;
2235 info = (struct bfd_link_info *) inf;
2236 htab = elf_x86_64_hash_table (info);
2239 bed = get_elf_backend_data (info->output_bfd);
2241 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2242 here if it is defined and referenced in a non-shared object. */
2243 if (h->type == STT_GNU_IFUNC
2245 return _bfd_elf_allocate_ifunc_dyn_relocs (info, h,
2249 else if (htab->elf.dynamic_sections_created
2250 && h->plt.refcount > 0)
2252 /* Make sure this symbol is output as a dynamic symbol.
2253 Undefined weak syms won't yet be marked as dynamic. */
2254 if (h->dynindx == -1
2255 && !h->forced_local)
2257 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2262 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2264 asection *s = htab->elf.splt;
2266 /* If this is the first .plt entry, make room for the special
2269 s->size += PLT_ENTRY_SIZE;
2271 h->plt.offset = s->size;
2273 /* If this symbol is not defined in a regular file, and we are
2274 not generating a shared library, then set the symbol to this
2275 location in the .plt. This is required to make function
2276 pointers compare as equal between the normal executable and
2277 the shared library. */
2281 h->root.u.def.section = s;
2282 h->root.u.def.value = h->plt.offset;
2285 /* Make room for this entry. */
2286 s->size += PLT_ENTRY_SIZE;
2288 /* We also need to make an entry in the .got.plt section, which
2289 will be placed in the .got section by the linker script. */
2290 htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
2292 /* We also need to make an entry in the .rela.plt section. */
2293 htab->elf.srelplt->size += bed->s->sizeof_rela;
2294 htab->elf.srelplt->reloc_count++;
2298 h->plt.offset = (bfd_vma) -1;
2304 h->plt.offset = (bfd_vma) -1;
2308 eh->tlsdesc_got = (bfd_vma) -1;
2310 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2311 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2312 if (h->got.refcount > 0
2315 && elf_x86_64_hash_entry (h)->tls_type == GOT_TLS_IE)
2317 h->got.offset = (bfd_vma) -1;
2319 else if (h->got.refcount > 0)
2323 int tls_type = elf_x86_64_hash_entry (h)->tls_type;
2325 /* Make sure this symbol is output as a dynamic symbol.
2326 Undefined weak syms won't yet be marked as dynamic. */
2327 if (h->dynindx == -1
2328 && !h->forced_local)
2330 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2334 if (GOT_TLS_GDESC_P (tls_type))
2336 eh->tlsdesc_got = htab->elf.sgotplt->size
2337 - elf_x86_64_compute_jump_table_size (htab);
2338 htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
2339 h->got.offset = (bfd_vma) -2;
2341 if (! GOT_TLS_GDESC_P (tls_type)
2342 || GOT_TLS_GD_P (tls_type))
2345 h->got.offset = s->size;
2346 s->size += GOT_ENTRY_SIZE;
2347 if (GOT_TLS_GD_P (tls_type))
2348 s->size += GOT_ENTRY_SIZE;
2350 dyn = htab->elf.dynamic_sections_created;
2351 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2353 R_X86_64_GOTTPOFF needs one dynamic relocation. */
2354 if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
2355 || tls_type == GOT_TLS_IE)
2356 htab->elf.srelgot->size += bed->s->sizeof_rela;
2357 else if (GOT_TLS_GD_P (tls_type))
2358 htab->elf.srelgot->size += 2 * bed->s->sizeof_rela;
2359 else if (! GOT_TLS_GDESC_P (tls_type)
2360 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2361 || h->root.type != bfd_link_hash_undefweak)
2363 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
2364 htab->elf.srelgot->size += bed->s->sizeof_rela;
2365 if (GOT_TLS_GDESC_P (tls_type))
2367 htab->elf.srelplt->size += bed->s->sizeof_rela;
2368 htab->tlsdesc_plt = (bfd_vma) -1;
2372 h->got.offset = (bfd_vma) -1;
2374 if (eh->dyn_relocs == NULL)
2377 /* In the shared -Bsymbolic case, discard space allocated for
2378 dynamic pc-relative relocs against symbols which turn out to be
2379 defined in regular objects. For the normal shared case, discard
2380 space for pc-relative relocs that have become local due to symbol
2381 visibility changes. */
2385 /* Relocs that use pc_count are those that appear on a call
2386 insn, or certain REL relocs that can generated via assembly.
2387 We want calls to protected symbols to resolve directly to the
2388 function rather than going via the plt. If people want
2389 function pointer comparisons to work as expected then they
2390 should avoid writing weird assembly. */
2391 if (SYMBOL_CALLS_LOCAL (info, h))
2393 struct elf_dyn_relocs **pp;
2395 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2397 p->count -= p->pc_count;
2406 /* Also discard relocs on undefined weak syms with non-default
2408 if (eh->dyn_relocs != NULL
2409 && h->root.type == bfd_link_hash_undefweak)
2411 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2412 eh->dyn_relocs = NULL;
2414 /* Make sure undefined weak symbols are output as a dynamic
2416 else if (h->dynindx == -1
2417 && ! h->forced_local
2418 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2423 else if (ELIMINATE_COPY_RELOCS)
2425 /* For the non-shared case, discard space for relocs against
2426 symbols which turn out to need copy relocs or are not
2432 || (htab->elf.dynamic_sections_created
2433 && (h->root.type == bfd_link_hash_undefweak
2434 || h->root.type == bfd_link_hash_undefined))))
2436 /* Make sure this symbol is output as a dynamic symbol.
2437 Undefined weak syms won't yet be marked as dynamic. */
2438 if (h->dynindx == -1
2439 && ! h->forced_local
2440 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2443 /* If that succeeded, we know we'll be keeping all the
2445 if (h->dynindx != -1)
2449 eh->dyn_relocs = NULL;
2454 /* Finally, allocate space. */
2455 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2459 sreloc = elf_section_data (p->sec)->sreloc;
2461 BFD_ASSERT (sreloc != NULL);
2463 sreloc->size += p->count * bed->s->sizeof_rela;
2469 /* Allocate space in .plt, .got and associated reloc sections for
2470 local dynamic relocs. */
2473 elf_x86_64_allocate_local_dynrelocs (void **slot, void *inf)
2475 struct elf_link_hash_entry *h
2476 = (struct elf_link_hash_entry *) *slot;
2478 if (h->type != STT_GNU_IFUNC
2482 || h->root.type != bfd_link_hash_defined)
2485 return elf_x86_64_allocate_dynrelocs (h, inf);
2488 /* Find any dynamic relocs that apply to read-only sections. */
2491 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry *h,
2494 struct elf_x86_64_link_hash_entry *eh;
2495 struct elf_dyn_relocs *p;
2497 /* Skip local IFUNC symbols. */
2498 if (h->forced_local && h->type == STT_GNU_IFUNC)
2501 eh = (struct elf_x86_64_link_hash_entry *) h;
2502 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2504 asection *s = p->sec->output_section;
2506 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2508 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2510 info->flags |= DF_TEXTREL;
2512 if (info->warn_shared_textrel && info->shared)
2513 info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2514 p->sec->owner, h->root.root.string,
2517 /* Not an error, just cut short the traversal. */
2524 /* Set the sizes of the dynamic sections. */
2527 elf_x86_64_size_dynamic_sections (bfd *output_bfd,
2528 struct bfd_link_info *info)
2530 struct elf_x86_64_link_hash_table *htab;
2535 const struct elf_backend_data *bed;
2537 htab = elf_x86_64_hash_table (info);
2540 bed = get_elf_backend_data (output_bfd);
2542 dynobj = htab->elf.dynobj;
2546 if (htab->elf.dynamic_sections_created)
2548 /* Set the contents of the .interp section to the interpreter. */
2549 if (info->executable)
2551 s = bfd_get_section_by_name (dynobj, ".interp");
2554 s->size = htab->dynamic_interpreter_size;
2555 s->contents = (unsigned char *) htab->dynamic_interpreter;
2559 /* Set up .got offsets for local syms, and space for local dynamic
2561 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2563 bfd_signed_vma *local_got;
2564 bfd_signed_vma *end_local_got;
2565 char *local_tls_type;
2566 bfd_vma *local_tlsdesc_gotent;
2567 bfd_size_type locsymcount;
2568 Elf_Internal_Shdr *symtab_hdr;
2571 if (! is_x86_64_elf (ibfd))
2574 for (s = ibfd->sections; s != NULL; s = s->next)
2576 struct elf_dyn_relocs *p;
2578 for (p = (struct elf_dyn_relocs *)
2579 (elf_section_data (s)->local_dynrel);
2583 if (!bfd_is_abs_section (p->sec)
2584 && bfd_is_abs_section (p->sec->output_section))
2586 /* Input section has been discarded, either because
2587 it is a copy of a linkonce section or due to
2588 linker script /DISCARD/, so we'll be discarding
2591 else if (p->count != 0)
2593 srel = elf_section_data (p->sec)->sreloc;
2594 srel->size += p->count * bed->s->sizeof_rela;
2595 if ((p->sec->output_section->flags & SEC_READONLY) != 0
2596 && (info->flags & DF_TEXTREL) == 0)
2598 info->flags |= DF_TEXTREL;
2599 if (info->warn_shared_textrel && info->shared)
2600 info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
2601 p->sec->owner, p->sec);
2607 local_got = elf_local_got_refcounts (ibfd);
2611 symtab_hdr = &elf_symtab_hdr (ibfd);
2612 locsymcount = symtab_hdr->sh_info;
2613 end_local_got = local_got + locsymcount;
2614 local_tls_type = elf_x86_64_local_got_tls_type (ibfd);
2615 local_tlsdesc_gotent = elf_x86_64_local_tlsdesc_gotent (ibfd);
2617 srel = htab->elf.srelgot;
2618 for (; local_got < end_local_got;
2619 ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
2621 *local_tlsdesc_gotent = (bfd_vma) -1;
2624 if (GOT_TLS_GDESC_P (*local_tls_type))
2626 *local_tlsdesc_gotent = htab->elf.sgotplt->size
2627 - elf_x86_64_compute_jump_table_size (htab);
2628 htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
2629 *local_got = (bfd_vma) -2;
2631 if (! GOT_TLS_GDESC_P (*local_tls_type)
2632 || GOT_TLS_GD_P (*local_tls_type))
2634 *local_got = s->size;
2635 s->size += GOT_ENTRY_SIZE;
2636 if (GOT_TLS_GD_P (*local_tls_type))
2637 s->size += GOT_ENTRY_SIZE;
2640 || GOT_TLS_GD_ANY_P (*local_tls_type)
2641 || *local_tls_type == GOT_TLS_IE)
2643 if (GOT_TLS_GDESC_P (*local_tls_type))
2645 htab->elf.srelplt->size
2646 += bed->s->sizeof_rela;
2647 htab->tlsdesc_plt = (bfd_vma) -1;
2649 if (! GOT_TLS_GDESC_P (*local_tls_type)
2650 || GOT_TLS_GD_P (*local_tls_type))
2651 srel->size += bed->s->sizeof_rela;
2655 *local_got = (bfd_vma) -1;
2659 if (htab->tls_ld_got.refcount > 0)
2661 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
2663 htab->tls_ld_got.offset = htab->elf.sgot->size;
2664 htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
2665 htab->elf.srelgot->size += bed->s->sizeof_rela;
2668 htab->tls_ld_got.offset = -1;
2670 /* Allocate global sym .plt and .got entries, and space for global
2671 sym dynamic relocs. */
2672 elf_link_hash_traverse (&htab->elf, elf_x86_64_allocate_dynrelocs,
2675 /* Allocate .plt and .got entries, and space for local symbols. */
2676 htab_traverse (htab->loc_hash_table,
2677 elf_x86_64_allocate_local_dynrelocs,
2680 /* For every jump slot reserved in the sgotplt, reloc_count is
2681 incremented. However, when we reserve space for TLS descriptors,
2682 it's not incremented, so in order to compute the space reserved
2683 for them, it suffices to multiply the reloc count by the jump
2685 if (htab->elf.srelplt)
2686 htab->sgotplt_jump_table_size
2687 = elf_x86_64_compute_jump_table_size (htab);
2689 if (htab->tlsdesc_plt)
2691 /* If we're not using lazy TLS relocations, don't generate the
2692 PLT and GOT entries they require. */
2693 if ((info->flags & DF_BIND_NOW))
2694 htab->tlsdesc_plt = 0;
2697 htab->tlsdesc_got = htab->elf.sgot->size;
2698 htab->elf.sgot->size += GOT_ENTRY_SIZE;
2699 /* Reserve room for the initial entry.
2700 FIXME: we could probably do away with it in this case. */
2701 if (htab->elf.splt->size == 0)
2702 htab->elf.splt->size += PLT_ENTRY_SIZE;
2703 htab->tlsdesc_plt = htab->elf.splt->size;
2704 htab->elf.splt->size += PLT_ENTRY_SIZE;
2708 if (htab->elf.sgotplt)
2710 struct elf_link_hash_entry *got;
2711 got = elf_link_hash_lookup (elf_hash_table (info),
2712 "_GLOBAL_OFFSET_TABLE_",
2713 FALSE, FALSE, FALSE);
2715 /* Don't allocate .got.plt section if there are no GOT nor PLT
2716 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
2718 || !got->ref_regular_nonweak)
2719 && (htab->elf.sgotplt->size
2720 == get_elf_backend_data (output_bfd)->got_header_size)
2721 && (htab->elf.splt == NULL
2722 || htab->elf.splt->size == 0)
2723 && (htab->elf.sgot == NULL
2724 || htab->elf.sgot->size == 0)
2725 && (htab->elf.iplt == NULL
2726 || htab->elf.iplt->size == 0)
2727 && (htab->elf.igotplt == NULL
2728 || htab->elf.igotplt->size == 0))
2729 htab->elf.sgotplt->size = 0;
2732 /* We now have determined the sizes of the various dynamic sections.
2733 Allocate memory for them. */
2735 for (s = dynobj->sections; s != NULL; s = s->next)
2737 if ((s->flags & SEC_LINKER_CREATED) == 0)
2740 if (s == htab->elf.splt
2741 || s == htab->elf.sgot
2742 || s == htab->elf.sgotplt
2743 || s == htab->elf.iplt
2744 || s == htab->elf.igotplt
2745 || s == htab->sdynbss)
2747 /* Strip this section if we don't need it; see the
2750 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2752 if (s->size != 0 && s != htab->elf.srelplt)
2755 /* We use the reloc_count field as a counter if we need
2756 to copy relocs into the output file. */
2757 if (s != htab->elf.srelplt)
2762 /* It's not one of our sections, so don't allocate space. */
2768 /* If we don't need this section, strip it from the
2769 output file. This is mostly to handle .rela.bss and
2770 .rela.plt. We must create both sections in
2771 create_dynamic_sections, because they must be created
2772 before the linker maps input sections to output
2773 sections. The linker does that before
2774 adjust_dynamic_symbol is called, and it is that
2775 function which decides whether anything needs to go
2776 into these sections. */
2778 s->flags |= SEC_EXCLUDE;
2782 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2785 /* Allocate memory for the section contents. We use bfd_zalloc
2786 here in case unused entries are not reclaimed before the
2787 section's contents are written out. This should not happen,
2788 but this way if it does, we get a R_X86_64_NONE reloc instead
2790 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2791 if (s->contents == NULL)
2795 if (htab->plt_eh_frame != NULL
2796 && htab->elf.splt != NULL
2797 && htab->elf.splt->size != 0
2798 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0)
2799 bfd_put_32 (dynobj, htab->elf.splt->size,
2800 htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
2802 if (htab->elf.dynamic_sections_created)
2804 /* Add some entries to the .dynamic section. We fill in the
2805 values later, in elf_x86_64_finish_dynamic_sections, but we
2806 must add the entries now so that we get the correct size for
2807 the .dynamic section. The DT_DEBUG entry is filled in by the
2808 dynamic linker and used by the debugger. */
2809 #define add_dynamic_entry(TAG, VAL) \
2810 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2812 if (info->executable)
2814 if (!add_dynamic_entry (DT_DEBUG, 0))
2818 if (htab->elf.splt->size != 0)
2820 if (!add_dynamic_entry (DT_PLTGOT, 0)
2821 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2822 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2823 || !add_dynamic_entry (DT_JMPREL, 0))
2826 if (htab->tlsdesc_plt
2827 && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
2828 || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
2834 if (!add_dynamic_entry (DT_RELA, 0)
2835 || !add_dynamic_entry (DT_RELASZ, 0)
2836 || !add_dynamic_entry (DT_RELAENT, bed->s->sizeof_rela))
2839 /* If any dynamic relocs apply to a read-only section,
2840 then we need a DT_TEXTREL entry. */
2841 if ((info->flags & DF_TEXTREL) == 0)
2842 elf_link_hash_traverse (&htab->elf,
2843 elf_x86_64_readonly_dynrelocs,
2846 if ((info->flags & DF_TEXTREL) != 0)
2848 if (!add_dynamic_entry (DT_TEXTREL, 0))
2853 #undef add_dynamic_entry
2859 elf_x86_64_always_size_sections (bfd *output_bfd,
2860 struct bfd_link_info *info)
2862 asection *tls_sec = elf_hash_table (info)->tls_sec;
2866 struct elf_link_hash_entry *tlsbase;
2868 tlsbase = elf_link_hash_lookup (elf_hash_table (info),
2869 "_TLS_MODULE_BASE_",
2870 FALSE, FALSE, FALSE);
2872 if (tlsbase && tlsbase->type == STT_TLS)
2874 struct elf_x86_64_link_hash_table *htab;
2875 struct bfd_link_hash_entry *bh = NULL;
2876 const struct elf_backend_data *bed
2877 = get_elf_backend_data (output_bfd);
2879 htab = elf_x86_64_hash_table (info);
2883 if (!(_bfd_generic_link_add_one_symbol
2884 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
2885 tls_sec, 0, NULL, FALSE,
2886 bed->collect, &bh)))
2889 htab->tls_module_base = bh;
2891 tlsbase = (struct elf_link_hash_entry *)bh;
2892 tlsbase->def_regular = 1;
2893 tlsbase->other = STV_HIDDEN;
2894 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
2901 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
2902 executables. Rather than setting it to the beginning of the TLS
2903 section, we have to set it to the end. This function may be called
2904 multiple times, it is idempotent. */
2907 elf_x86_64_set_tls_module_base (struct bfd_link_info *info)
2909 struct elf_x86_64_link_hash_table *htab;
2910 struct bfd_link_hash_entry *base;
2912 if (!info->executable)
2915 htab = elf_x86_64_hash_table (info);
2919 base = htab->tls_module_base;
2923 base->u.def.value = htab->elf.tls_size;
2926 /* Return the base VMA address which should be subtracted from real addresses
2927 when resolving @dtpoff relocation.
2928 This is PT_TLS segment p_vaddr. */
2931 elf_x86_64_dtpoff_base (struct bfd_link_info *info)
2933 /* If tls_sec is NULL, we should have signalled an error already. */
2934 if (elf_hash_table (info)->tls_sec == NULL)
2936 return elf_hash_table (info)->tls_sec->vma;
2939 /* Return the relocation value for @tpoff relocation
2940 if STT_TLS virtual address is ADDRESS. */
2943 elf_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address)
2945 struct elf_link_hash_table *htab = elf_hash_table (info);
2946 const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
2947 bfd_vma static_tls_size;
2949 /* If tls_segment is NULL, we should have signalled an error already. */
2950 if (htab->tls_sec == NULL)
2953 /* Consider special static TLS alignment requirements. */
2954 static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
2955 return address - static_tls_size - htab->tls_sec->vma;
2958 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
2962 is_32bit_relative_branch (bfd_byte *contents, bfd_vma offset)
2964 /* Opcode Instruction
2967 0x0f 0x8x conditional jump */
2969 && (contents [offset - 1] == 0xe8
2970 || contents [offset - 1] == 0xe9))
2972 && contents [offset - 2] == 0x0f
2973 && (contents [offset - 1] & 0xf0) == 0x80));
2976 /* Relocate an x86_64 ELF section. */
2979 elf_x86_64_relocate_section (bfd *output_bfd,
2980 struct bfd_link_info *info,
2982 asection *input_section,
2984 Elf_Internal_Rela *relocs,
2985 Elf_Internal_Sym *local_syms,
2986 asection **local_sections)
2988 struct elf_x86_64_link_hash_table *htab;
2989 Elf_Internal_Shdr *symtab_hdr;
2990 struct elf_link_hash_entry **sym_hashes;
2991 bfd_vma *local_got_offsets;
2992 bfd_vma *local_tlsdesc_gotents;
2993 Elf_Internal_Rela *rel;
2994 Elf_Internal_Rela *relend;
2996 BFD_ASSERT (is_x86_64_elf (input_bfd));
2998 htab = elf_x86_64_hash_table (info);
3001 symtab_hdr = &elf_symtab_hdr (input_bfd);
3002 sym_hashes = elf_sym_hashes (input_bfd);
3003 local_got_offsets = elf_local_got_offsets (input_bfd);
3004 local_tlsdesc_gotents = elf_x86_64_local_tlsdesc_gotent (input_bfd);
3006 elf_x86_64_set_tls_module_base (info);
3009 relend = relocs + input_section->reloc_count;
3010 for (; rel < relend; rel++)
3012 unsigned int r_type;
3013 reloc_howto_type *howto;
3014 unsigned long r_symndx;
3015 struct elf_link_hash_entry *h;
3016 Elf_Internal_Sym *sym;
3018 bfd_vma off, offplt;
3020 bfd_boolean unresolved_reloc;
3021 bfd_reloc_status_type r;
3025 r_type = ELF32_R_TYPE (rel->r_info);
3026 if (r_type == (int) R_X86_64_GNU_VTINHERIT
3027 || r_type == (int) R_X86_64_GNU_VTENTRY)
3030 if (r_type >= R_X86_64_max)
3032 bfd_set_error (bfd_error_bad_value);
3036 if (r_type != (int) R_X86_64_32
3037 || ABI_64_P (output_bfd))
3038 howto = x86_64_elf_howto_table + r_type;
3040 howto = (x86_64_elf_howto_table
3041 + ARRAY_SIZE (x86_64_elf_howto_table) - 1);
3042 r_symndx = htab->r_sym (rel->r_info);
3046 unresolved_reloc = FALSE;
3047 if (r_symndx < symtab_hdr->sh_info)
3049 sym = local_syms + r_symndx;
3050 sec = local_sections[r_symndx];
3052 relocation = _bfd_elf_rela_local_sym (output_bfd, sym,
3055 /* Relocate against local STT_GNU_IFUNC symbol. */
3056 if (!info->relocatable
3057 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3059 h = elf_x86_64_get_local_sym_hash (htab, input_bfd,
3064 /* Set STT_GNU_IFUNC symbol value. */
3065 h->root.u.def.value = sym->st_value;
3066 h->root.u.def.section = sec;
3071 bfd_boolean warned ATTRIBUTE_UNUSED;
3073 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3074 r_symndx, symtab_hdr, sym_hashes,
3076 unresolved_reloc, warned);
3079 if (sec != NULL && elf_discarded_section (sec))
3080 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3081 rel, relend, howto, contents);
3083 if (info->relocatable)
3086 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3087 it here if it is defined in a non-shared object. */
3089 && h->type == STT_GNU_IFUNC
3096 if ((input_section->flags & SEC_ALLOC) == 0
3097 || h->plt.offset == (bfd_vma) -1)
3100 /* STT_GNU_IFUNC symbol must go through PLT. */
3101 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
3102 relocation = (plt->output_section->vma
3103 + plt->output_offset + h->plt.offset);
3108 if (h->root.root.string)
3109 name = h->root.root.string;
3111 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3113 (*_bfd_error_handler)
3114 (_("%B: relocation %s against STT_GNU_IFUNC "
3115 "symbol `%s' isn't handled by %s"), input_bfd,
3116 x86_64_elf_howto_table[r_type].name,
3117 name, __FUNCTION__);
3118 bfd_set_error (bfd_error_bad_value);
3127 if (ABI_64_P (output_bfd))
3131 if (rel->r_addend != 0)
3133 if (h->root.root.string)
3134 name = h->root.root.string;
3136 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
3138 (*_bfd_error_handler)
3139 (_("%B: relocation %s against STT_GNU_IFUNC "
3140 "symbol `%s' has non-zero addend: %d"),
3141 input_bfd, x86_64_elf_howto_table[r_type].name,
3142 name, rel->r_addend);
3143 bfd_set_error (bfd_error_bad_value);
3147 /* Generate dynamic relcoation only when there is a
3148 non-GOF reference in a shared object. */
3149 if (info->shared && h->non_got_ref)
3151 Elf_Internal_Rela outrel;
3154 /* Need a dynamic relocation to get the real function
3156 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
3160 if (outrel.r_offset == (bfd_vma) -1
3161 || outrel.r_offset == (bfd_vma) -2)
3164 outrel.r_offset += (input_section->output_section->vma
3165 + input_section->output_offset);
3167 if (h->dynindx == -1
3169 || info->executable)
3171 /* This symbol is resolved locally. */
3172 outrel.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
3173 outrel.r_addend = (h->root.u.def.value
3174 + h->root.u.def.section->output_section->vma
3175 + h->root.u.def.section->output_offset);
3179 outrel.r_info = htab->r_info (h->dynindx, r_type);
3180 outrel.r_addend = 0;
3183 sreloc = htab->elf.irelifunc;
3184 elf_append_rela (output_bfd, sreloc, &outrel);
3186 /* If this reloc is against an external symbol, we
3187 do not want to fiddle with the addend. Otherwise,
3188 we need to include the symbol value so that it
3189 becomes an addend for the dynamic reloc. For an
3190 internal symbol, we have updated addend. */
3196 case R_X86_64_PLT32:
3199 case R_X86_64_GOTPCREL:
3200 case R_X86_64_GOTPCREL64:
3201 base_got = htab->elf.sgot;
3202 off = h->got.offset;
3204 if (base_got == NULL)
3207 if (off == (bfd_vma) -1)
3209 /* We can't use h->got.offset here to save state, or
3210 even just remember the offset, as finish_dynamic_symbol
3211 would use that as offset into .got. */
3213 if (htab->elf.splt != NULL)
3215 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3216 off = (plt_index + 3) * GOT_ENTRY_SIZE;
3217 base_got = htab->elf.sgotplt;
3221 plt_index = h->plt.offset / PLT_ENTRY_SIZE;
3222 off = plt_index * GOT_ENTRY_SIZE;
3223 base_got = htab->elf.igotplt;
3226 if (h->dynindx == -1
3230 /* This references the local defitionion. We must
3231 initialize this entry in the global offset table.
3232 Since the offset must always be a multiple of 8,
3233 we use the least significant bit to record
3234 whether we have initialized it already.
3236 When doing a dynamic link, we create a .rela.got
3237 relocation entry to initialize the value. This
3238 is done in the finish_dynamic_symbol routine. */
3243 bfd_put_64 (output_bfd, relocation,
3244 base_got->contents + off);
3245 /* Note that this is harmless for the GOTPLT64
3246 case, as -1 | 1 still is -1. */
3252 relocation = (base_got->output_section->vma
3253 + base_got->output_offset + off);
3259 /* When generating a shared object, the relocations handled here are
3260 copied into the output file to be resolved at run time. */
3263 case R_X86_64_GOT32:
3264 case R_X86_64_GOT64:
3265 /* Relocation is to the entry for this symbol in the global
3267 case R_X86_64_GOTPCREL:
3268 case R_X86_64_GOTPCREL64:
3269 /* Use global offset table entry as symbol value. */
3270 case R_X86_64_GOTPLT64:
3271 /* This is the same as GOT64 for relocation purposes, but
3272 indicates the existence of a PLT entry. The difficulty is,
3273 that we must calculate the GOT slot offset from the PLT
3274 offset, if this symbol got a PLT entry (it was global).
3275 Additionally if it's computed from the PLT entry, then that
3276 GOT offset is relative to .got.plt, not to .got. */
3277 base_got = htab->elf.sgot;
3279 if (htab->elf.sgot == NULL)
3286 off = h->got.offset;
3288 && h->plt.offset != (bfd_vma)-1
3289 && off == (bfd_vma)-1)
3291 /* We can't use h->got.offset here to save
3292 state, or even just remember the offset, as
3293 finish_dynamic_symbol would use that as offset into
3295 bfd_vma plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3296 off = (plt_index + 3) * GOT_ENTRY_SIZE;
3297 base_got = htab->elf.sgotplt;
3300 dyn = htab->elf.dynamic_sections_created;
3302 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3304 && SYMBOL_REFERENCES_LOCAL (info, h))
3305 || (ELF_ST_VISIBILITY (h->other)
3306 && h->root.type == bfd_link_hash_undefweak))
3308 /* This is actually a static link, or it is a -Bsymbolic
3309 link and the symbol is defined locally, or the symbol
3310 was forced to be local because of a version file. We
3311 must initialize this entry in the global offset table.
3312 Since the offset must always be a multiple of 8, we
3313 use the least significant bit to record whether we
3314 have initialized it already.
3316 When doing a dynamic link, we create a .rela.got
3317 relocation entry to initialize the value. This is
3318 done in the finish_dynamic_symbol routine. */
3323 bfd_put_64 (output_bfd, relocation,
3324 base_got->contents + off);
3325 /* Note that this is harmless for the GOTPLT64 case,
3326 as -1 | 1 still is -1. */
3331 unresolved_reloc = FALSE;
3335 if (local_got_offsets == NULL)
3338 off = local_got_offsets[r_symndx];
3340 /* The offset must always be a multiple of 8. We use
3341 the least significant bit to record whether we have
3342 already generated the necessary reloc. */
3347 bfd_put_64 (output_bfd, relocation,
3348 base_got->contents + off);
3353 Elf_Internal_Rela outrel;
3355 /* We need to generate a R_X86_64_RELATIVE reloc
3356 for the dynamic linker. */
3357 s = htab->elf.srelgot;
3361 outrel.r_offset = (base_got->output_section->vma
3362 + base_got->output_offset
3364 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
3365 outrel.r_addend = relocation;
3366 elf_append_rela (output_bfd, s, &outrel);
3369 local_got_offsets[r_symndx] |= 1;
3373 if (off >= (bfd_vma) -2)
3376 relocation = base_got->output_section->vma
3377 + base_got->output_offset + off;
3378 if (r_type != R_X86_64_GOTPCREL && r_type != R_X86_64_GOTPCREL64)
3379 relocation -= htab->elf.sgotplt->output_section->vma
3380 - htab->elf.sgotplt->output_offset;
3384 case R_X86_64_GOTOFF64:
3385 /* Relocation is relative to the start of the global offset
3388 /* Check to make sure it isn't a protected function symbol
3389 for shared library since it may not be local when used
3390 as function address. */
3394 && h->type == STT_FUNC
3395 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
3397 (*_bfd_error_handler)
3398 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
3399 input_bfd, h->root.root.string);
3400 bfd_set_error (bfd_error_bad_value);
3404 /* Note that sgot is not involved in this
3405 calculation. We always want the start of .got.plt. If we
3406 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3407 permitted by the ABI, we might have to change this
3409 relocation -= htab->elf.sgotplt->output_section->vma
3410 + htab->elf.sgotplt->output_offset;
3413 case R_X86_64_GOTPC32:
3414 case R_X86_64_GOTPC64:
3415 /* Use global offset table as symbol value. */
3416 relocation = htab->elf.sgotplt->output_section->vma
3417 + htab->elf.sgotplt->output_offset;
3418 unresolved_reloc = FALSE;
3421 case R_X86_64_PLTOFF64:
3422 /* Relocation is PLT entry relative to GOT. For local
3423 symbols it's the symbol itself relative to GOT. */
3425 /* See PLT32 handling. */
3426 && h->plt.offset != (bfd_vma) -1
3427 && htab->elf.splt != NULL)
3429 relocation = (htab->elf.splt->output_section->vma
3430 + htab->elf.splt->output_offset
3432 unresolved_reloc = FALSE;
3435 relocation -= htab->elf.sgotplt->output_section->vma
3436 + htab->elf.sgotplt->output_offset;
3439 case R_X86_64_PLT32:
3440 /* Relocation is to the entry for this symbol in the
3441 procedure linkage table. */
3443 /* Resolve a PLT32 reloc against a local symbol directly,
3444 without using the procedure linkage table. */
3448 if (h->plt.offset == (bfd_vma) -1
3449 || htab->elf.splt == NULL)
3451 /* We didn't make a PLT entry for this symbol. This
3452 happens when statically linking PIC code, or when
3453 using -Bsymbolic. */
3457 relocation = (htab->elf.splt->output_section->vma
3458 + htab->elf.splt->output_offset
3460 unresolved_reloc = FALSE;
3467 && ABI_64_P (output_bfd)
3468 && (input_section->flags & SEC_ALLOC) != 0
3469 && (input_section->flags & SEC_READONLY) != 0
3472 bfd_boolean fail = FALSE;
3474 = (r_type == R_X86_64_PC32
3475 && is_32bit_relative_branch (contents, rel->r_offset));
3477 if (SYMBOL_REFERENCES_LOCAL (info, h))
3479 /* Symbol is referenced locally. Make sure it is
3480 defined locally or for a branch. */
3481 fail = !h->def_regular && !branch;
3485 /* Symbol isn't referenced locally. We only allow
3486 branch to symbol with non-default visibility. */
3488 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT);
3495 const char *pic = "";
3497 switch (ELF_ST_VISIBILITY (h->other))
3500 v = _("hidden symbol");
3503 v = _("internal symbol");
3506 v = _("protected symbol");
3510 pic = _("; recompile with -fPIC");
3515 fmt = _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
3517 fmt = _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
3519 (*_bfd_error_handler) (fmt, input_bfd,
3520 x86_64_elf_howto_table[r_type].name,
3521 v, h->root.root.string, pic);
3522 bfd_set_error (bfd_error_bad_value);
3533 /* FIXME: The ABI says the linker should make sure the value is
3534 the same when it's zeroextended to 64 bit. */
3536 if ((input_section->flags & SEC_ALLOC) == 0)
3541 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3542 || h->root.type != bfd_link_hash_undefweak)
3543 && (! IS_X86_64_PCREL_TYPE (r_type)
3544 || ! SYMBOL_CALLS_LOCAL (info, h)))
3545 || (ELIMINATE_COPY_RELOCS
3552 || h->root.type == bfd_link_hash_undefweak
3553 || h->root.type == bfd_link_hash_undefined)))
3555 Elf_Internal_Rela outrel;
3556 bfd_boolean skip, relocate;
3559 /* When generating a shared object, these relocations
3560 are copied into the output file to be resolved at run
3566 _bfd_elf_section_offset (output_bfd, info, input_section,
3568 if (outrel.r_offset == (bfd_vma) -1)
3570 else if (outrel.r_offset == (bfd_vma) -2)
3571 skip = TRUE, relocate = TRUE;
3573 outrel.r_offset += (input_section->output_section->vma
3574 + input_section->output_offset);
3577 memset (&outrel, 0, sizeof outrel);
3579 /* h->dynindx may be -1 if this symbol was marked to
3583 && (IS_X86_64_PCREL_TYPE (r_type)
3585 || ! SYMBOLIC_BIND (info, h)
3586 || ! h->def_regular))
3588 outrel.r_info = htab->r_info (h->dynindx, r_type);
3589 outrel.r_addend = rel->r_addend;
3593 /* This symbol is local, or marked to become local. */
3594 if (r_type == htab->pointer_r_type)
3597 outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
3598 outrel.r_addend = relocation + rel->r_addend;
3604 if (bfd_is_abs_section (sec))
3606 else if (sec == NULL || sec->owner == NULL)
3608 bfd_set_error (bfd_error_bad_value);
3615 /* We are turning this relocation into one
3616 against a section symbol. It would be
3617 proper to subtract the symbol's value,
3618 osec->vma, from the emitted reloc addend,
3619 but ld.so expects buggy relocs. */
3620 osec = sec->output_section;
3621 sindx = elf_section_data (osec)->dynindx;
3624 asection *oi = htab->elf.text_index_section;
3625 sindx = elf_section_data (oi)->dynindx;
3627 BFD_ASSERT (sindx != 0);
3630 outrel.r_info = htab->r_info (sindx, r_type);
3631 outrel.r_addend = relocation + rel->r_addend;
3635 sreloc = elf_section_data (input_section)->sreloc;
3637 if (sreloc == NULL || sreloc->contents == NULL)
3639 r = bfd_reloc_notsupported;
3640 goto check_relocation_error;
3643 elf_append_rela (output_bfd, sreloc, &outrel);
3645 /* If this reloc is against an external symbol, we do
3646 not want to fiddle with the addend. Otherwise, we
3647 need to include the symbol value so that it becomes
3648 an addend for the dynamic reloc. */
3655 case R_X86_64_TLSGD:
3656 case R_X86_64_GOTPC32_TLSDESC:
3657 case R_X86_64_TLSDESC_CALL:
3658 case R_X86_64_GOTTPOFF:
3659 tls_type = GOT_UNKNOWN;
3660 if (h == NULL && local_got_offsets)
3661 tls_type = elf_x86_64_local_got_tls_type (input_bfd) [r_symndx];
3663 tls_type = elf_x86_64_hash_entry (h)->tls_type;
3665 if (! elf_x86_64_tls_transition (info, input_bfd,
3666 input_section, contents,
3667 symtab_hdr, sym_hashes,
3668 &r_type, tls_type, rel,
3669 relend, h, r_symndx))
3672 if (r_type == R_X86_64_TPOFF32)
3674 bfd_vma roff = rel->r_offset;
3676 BFD_ASSERT (! unresolved_reloc);
3678 if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
3680 /* GD->LE transition. For 64bit, change
3681 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3682 .word 0x6666; rex64; call __tls_get_addr
3685 leaq foo@tpoff(%rax), %rax
3687 leaq foo@tlsgd(%rip), %rdi
3688 .word 0x6666; rex64; call __tls_get_addr
3691 leaq foo@tpoff(%rax), %rax */
3692 if (ABI_64_P (output_bfd))
3693 memcpy (contents + roff - 4,
3694 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3697 memcpy (contents + roff - 3,
3698 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3700 bfd_put_32 (output_bfd,
3701 elf_x86_64_tpoff (info, relocation),
3702 contents + roff + 8);
3703 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
3707 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
3709 /* GDesc -> LE transition.
3710 It's originally something like:
3711 leaq x@tlsdesc(%rip), %rax
3714 movl $x@tpoff, %rax. */
3716 unsigned int val, type;
3718 type = bfd_get_8 (input_bfd, contents + roff - 3);
3719 val = bfd_get_8 (input_bfd, contents + roff - 1);
3720 bfd_put_8 (output_bfd, 0x48 | ((type >> 2) & 1),
3721 contents + roff - 3);
3722 bfd_put_8 (output_bfd, 0xc7, contents + roff - 2);
3723 bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3724 contents + roff - 1);
3725 bfd_put_32 (output_bfd,
3726 elf_x86_64_tpoff (info, relocation),
3730 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
3732 /* GDesc -> LE transition.
3737 bfd_put_8 (output_bfd, 0x66, contents + roff);
3738 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3741 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTTPOFF)
3743 /* IE->LE transition:
3744 Originally it can be one of:
3745 movq foo@gottpoff(%rip), %reg
3746 addq foo@gottpoff(%rip), %reg
3749 leaq foo(%reg), %reg
3752 unsigned int val, type, reg;
3754 val = bfd_get_8 (input_bfd, contents + roff - 3);
3755 type = bfd_get_8 (input_bfd, contents + roff - 2);
3756 reg = bfd_get_8 (input_bfd, contents + roff - 1);
3762 bfd_put_8 (output_bfd, 0x49,
3763 contents + roff - 3);
3764 else if (!ABI_64_P (output_bfd) && val == 0x44)
3765 bfd_put_8 (output_bfd, 0x41,
3766 contents + roff - 3);
3767 bfd_put_8 (output_bfd, 0xc7,
3768 contents + roff - 2);
3769 bfd_put_8 (output_bfd, 0xc0 | reg,
3770 contents + roff - 1);
3774 /* addq -> addq - addressing with %rsp/%r12 is
3777 bfd_put_8 (output_bfd, 0x49,
3778 contents + roff - 3);
3779 else if (!ABI_64_P (output_bfd) && val == 0x44)
3780 bfd_put_8 (output_bfd, 0x41,
3781 contents + roff - 3);
3782 bfd_put_8 (output_bfd, 0x81,
3783 contents + roff - 2);
3784 bfd_put_8 (output_bfd, 0xc0 | reg,
3785 contents + roff - 1);
3791 bfd_put_8 (output_bfd, 0x4d,
3792 contents + roff - 3);
3793 else if (!ABI_64_P (output_bfd) && val == 0x44)
3794 bfd_put_8 (output_bfd, 0x45,
3795 contents + roff - 3);
3796 bfd_put_8 (output_bfd, 0x8d,
3797 contents + roff - 2);
3798 bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
3799 contents + roff - 1);
3801 bfd_put_32 (output_bfd,
3802 elf_x86_64_tpoff (info, relocation),
3810 if (htab->elf.sgot == NULL)
3815 off = h->got.offset;
3816 offplt = elf_x86_64_hash_entry (h)->tlsdesc_got;
3820 if (local_got_offsets == NULL)
3823 off = local_got_offsets[r_symndx];
3824 offplt = local_tlsdesc_gotents[r_symndx];
3831 Elf_Internal_Rela outrel;
3835 if (htab->elf.srelgot == NULL)
3838 indx = h && h->dynindx != -1 ? h->dynindx : 0;
3840 if (GOT_TLS_GDESC_P (tls_type))
3842 outrel.r_info = htab->r_info (indx, R_X86_64_TLSDESC);
3843 BFD_ASSERT (htab->sgotplt_jump_table_size + offplt
3844 + 2 * GOT_ENTRY_SIZE <= htab->elf.sgotplt->size);
3845 outrel.r_offset = (htab->elf.sgotplt->output_section->vma
3846 + htab->elf.sgotplt->output_offset
3848 + htab->sgotplt_jump_table_size);
3849 sreloc = htab->elf.srelplt;
3851 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
3853 outrel.r_addend = 0;
3854 elf_append_rela (output_bfd, sreloc, &outrel);
3857 sreloc = htab->elf.srelgot;
3859 outrel.r_offset = (htab->elf.sgot->output_section->vma
3860 + htab->elf.sgot->output_offset + off);
3862 if (GOT_TLS_GD_P (tls_type))
3863 dr_type = R_X86_64_DTPMOD64;
3864 else if (GOT_TLS_GDESC_P (tls_type))
3867 dr_type = R_X86_64_TPOFF64;
3869 bfd_put_64 (output_bfd, 0, htab->elf.sgot->contents + off);
3870 outrel.r_addend = 0;
3871 if ((dr_type == R_X86_64_TPOFF64
3872 || dr_type == R_X86_64_TLSDESC) && indx == 0)
3873 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
3874 outrel.r_info = htab->r_info (indx, dr_type);
3876 elf_append_rela (output_bfd, sreloc, &outrel);
3878 if (GOT_TLS_GD_P (tls_type))
3882 BFD_ASSERT (! unresolved_reloc);
3883 bfd_put_64 (output_bfd,
3884 relocation - elf_x86_64_dtpoff_base (info),
3885 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3889 bfd_put_64 (output_bfd, 0,
3890 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3891 outrel.r_info = htab->r_info (indx,
3893 outrel.r_offset += GOT_ENTRY_SIZE;
3894 elf_append_rela (output_bfd, sreloc,
3903 local_got_offsets[r_symndx] |= 1;
3906 if (off >= (bfd_vma) -2
3907 && ! GOT_TLS_GDESC_P (tls_type))
3909 if (r_type == ELF32_R_TYPE (rel->r_info))
3911 if (r_type == R_X86_64_GOTPC32_TLSDESC
3912 || r_type == R_X86_64_TLSDESC_CALL)
3913 relocation = htab->elf.sgotplt->output_section->vma
3914 + htab->elf.sgotplt->output_offset
3915 + offplt + htab->sgotplt_jump_table_size;
3917 relocation = htab->elf.sgot->output_section->vma
3918 + htab->elf.sgot->output_offset + off;
3919 unresolved_reloc = FALSE;
3923 bfd_vma roff = rel->r_offset;
3925 if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
3927 /* GD->IE transition. For 64bit, change
3928 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3929 .word 0x6666; rex64; call __tls_get_addr@plt
3932 addq foo@gottpoff(%rip), %rax
3934 leaq foo@tlsgd(%rip), %rdi
3935 .word 0x6666; rex64; call __tls_get_addr@plt
3938 addq foo@gottpoff(%rip), %rax */
3939 if (ABI_64_P (output_bfd))
3940 memcpy (contents + roff - 4,
3941 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
3944 memcpy (contents + roff - 3,
3945 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
3948 relocation = (htab->elf.sgot->output_section->vma
3949 + htab->elf.sgot->output_offset + off
3951 - input_section->output_section->vma
3952 - input_section->output_offset
3954 bfd_put_32 (output_bfd, relocation,
3955 contents + roff + 8);
3956 /* Skip R_X86_64_PLT32. */
3960 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
3962 /* GDesc -> IE transition.
3963 It's originally something like:
3964 leaq x@tlsdesc(%rip), %rax
3967 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
3969 /* Now modify the instruction as appropriate. To
3970 turn a leaq into a movq in the form we use it, it
3971 suffices to change the second byte from 0x8d to
3973 bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
3975 bfd_put_32 (output_bfd,
3976 htab->elf.sgot->output_section->vma
3977 + htab->elf.sgot->output_offset + off
3979 - input_section->output_section->vma
3980 - input_section->output_offset
3985 else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
3987 /* GDesc -> IE transition.
3994 bfd_put_8 (output_bfd, 0x66, contents + roff);
3995 bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4003 case R_X86_64_TLSLD:
4004 if (! elf_x86_64_tls_transition (info, input_bfd,
4005 input_section, contents,
4006 symtab_hdr, sym_hashes,
4007 &r_type, GOT_UNKNOWN,
4008 rel, relend, h, r_symndx))
4011 if (r_type != R_X86_64_TLSLD)
4013 /* LD->LE transition:
4014 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
4015 For 64bit, we change it into:
4016 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
4017 For 32bit, we change it into:
4018 nopl 0x0(%rax); movl %fs:0, %eax. */
4020 BFD_ASSERT (r_type == R_X86_64_TPOFF32);
4021 if (ABI_64_P (output_bfd))
4022 memcpy (contents + rel->r_offset - 3,
4023 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
4025 memcpy (contents + rel->r_offset - 3,
4026 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
4027 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
4032 if (htab->elf.sgot == NULL)
4035 off = htab->tls_ld_got.offset;
4040 Elf_Internal_Rela outrel;
4042 if (htab->elf.srelgot == NULL)
4045 outrel.r_offset = (htab->elf.sgot->output_section->vma
4046 + htab->elf.sgot->output_offset + off);
4048 bfd_put_64 (output_bfd, 0,
4049 htab->elf.sgot->contents + off);
4050 bfd_put_64 (output_bfd, 0,
4051 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4052 outrel.r_info = htab->r_info (0, R_X86_64_DTPMOD64);
4053 outrel.r_addend = 0;
4054 elf_append_rela (output_bfd, htab->elf.srelgot,
4056 htab->tls_ld_got.offset |= 1;
4058 relocation = htab->elf.sgot->output_section->vma
4059 + htab->elf.sgot->output_offset + off;
4060 unresolved_reloc = FALSE;
4063 case R_X86_64_DTPOFF32:
4064 if (!info->executable|| (input_section->flags & SEC_CODE) == 0)
4065 relocation -= elf_x86_64_dtpoff_base (info);
4067 relocation = elf_x86_64_tpoff (info, relocation);
4070 case R_X86_64_TPOFF32:
4071 case R_X86_64_TPOFF64:
4072 BFD_ASSERT (info->executable);
4073 relocation = elf_x86_64_tpoff (info, relocation);
4080 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4081 because such sections are not SEC_ALLOC and thus ld.so will
4082 not process them. */
4083 if (unresolved_reloc
4084 && !((input_section->flags & SEC_DEBUGGING) != 0
4086 (*_bfd_error_handler)
4087 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4090 (long) rel->r_offset,
4092 h->root.root.string);
4095 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4096 contents, rel->r_offset,
4097 relocation, rel->r_addend);
4099 check_relocation_error:
4100 if (r != bfd_reloc_ok)
4105 name = h->root.root.string;
4108 name = bfd_elf_string_from_elf_section (input_bfd,
4109 symtab_hdr->sh_link,
4114 name = bfd_section_name (input_bfd, sec);
4117 if (r == bfd_reloc_overflow)
4119 if (! ((*info->callbacks->reloc_overflow)
4120 (info, (h ? &h->root : NULL), name, howto->name,
4121 (bfd_vma) 0, input_bfd, input_section,
4127 (*_bfd_error_handler)
4128 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4129 input_bfd, input_section,
4130 (long) rel->r_offset, name, (int) r);
4139 /* Finish up dynamic symbol handling. We set the contents of various
4140 dynamic sections here. */
4143 elf_x86_64_finish_dynamic_symbol (bfd *output_bfd,
4144 struct bfd_link_info *info,
4145 struct elf_link_hash_entry *h,
4146 Elf_Internal_Sym *sym)
4148 struct elf_x86_64_link_hash_table *htab;
4150 htab = elf_x86_64_hash_table (info);
4154 if (h->plt.offset != (bfd_vma) -1)
4158 Elf_Internal_Rela rela;
4160 asection *plt, *gotplt, *relplt;
4161 const struct elf_backend_data *bed;
4163 /* When building a static executable, use .iplt, .igot.plt and
4164 .rela.iplt sections for STT_GNU_IFUNC symbols. */
4165 if (htab->elf.splt != NULL)
4167 plt = htab->elf.splt;
4168 gotplt = htab->elf.sgotplt;
4169 relplt = htab->elf.srelplt;
4173 plt = htab->elf.iplt;
4174 gotplt = htab->elf.igotplt;
4175 relplt = htab->elf.irelplt;
4178 /* This symbol has an entry in the procedure linkage table. Set
4180 if ((h->dynindx == -1
4181 && !((h->forced_local || info->executable)
4183 && h->type == STT_GNU_IFUNC))
4189 /* Get the index in the procedure linkage table which
4190 corresponds to this symbol. This is the index of this symbol
4191 in all the symbols for which we are making plt entries. The
4192 first entry in the procedure linkage table is reserved.
4194 Get the offset into the .got table of the entry that
4195 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
4196 bytes. The first three are reserved for the dynamic linker.
4198 For static executables, we don't reserve anything. */
4200 if (plt == htab->elf.splt)
4202 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
4203 got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
4207 plt_index = h->plt.offset / PLT_ENTRY_SIZE;
4208 got_offset = plt_index * GOT_ENTRY_SIZE;
4211 /* Fill in the entry in the procedure linkage table. */
4212 memcpy (plt->contents + h->plt.offset, elf_x86_64_plt_entry,
4215 /* Insert the relocation positions of the plt section. The magic
4216 numbers at the end of the statements are the positions of the
4217 relocations in the plt section. */
4218 /* Put offset for jmp *name@GOTPCREL(%rip), since the
4219 instruction uses 6 bytes, subtract this value. */
4220 bfd_put_32 (output_bfd,
4221 (gotplt->output_section->vma
4222 + gotplt->output_offset
4224 - plt->output_section->vma
4225 - plt->output_offset
4228 plt->contents + h->plt.offset + 2);
4230 /* Don't fill PLT entry for static executables. */
4231 if (plt == htab->elf.splt)
4233 /* Put relocation index. */
4234 bfd_put_32 (output_bfd, plt_index,
4235 plt->contents + h->plt.offset + 7);
4236 /* Put offset for jmp .PLT0. */
4237 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
4238 plt->contents + h->plt.offset + 12);
4241 /* Fill in the entry in the global offset table, initially this
4242 points to the pushq instruction in the PLT which is at offset 6. */
4243 bfd_put_64 (output_bfd, (plt->output_section->vma
4244 + plt->output_offset
4245 + h->plt.offset + 6),
4246 gotplt->contents + got_offset);
4248 /* Fill in the entry in the .rela.plt section. */
4249 rela.r_offset = (gotplt->output_section->vma
4250 + gotplt->output_offset
4252 if (h->dynindx == -1
4253 || ((info->executable
4254 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4256 && h->type == STT_GNU_IFUNC))
4258 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4259 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
4260 rela.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
4261 rela.r_addend = (h->root.u.def.value
4262 + h->root.u.def.section->output_section->vma
4263 + h->root.u.def.section->output_offset);
4267 rela.r_info = htab->r_info (h->dynindx, R_X86_64_JUMP_SLOT);
4271 bed = get_elf_backend_data (output_bfd);
4272 loc = relplt->contents + plt_index * bed->s->sizeof_rela;
4273 bed->s->swap_reloca_out (output_bfd, &rela, loc);
4275 if (!h->def_regular)
4277 /* Mark the symbol as undefined, rather than as defined in
4278 the .plt section. Leave the value if there were any
4279 relocations where pointer equality matters (this is a clue
4280 for the dynamic linker, to make function pointer
4281 comparisons work between an application and shared
4282 library), otherwise set it to zero. If a function is only
4283 called from a binary, there is no need to slow down
4284 shared libraries because of that. */
4285 sym->st_shndx = SHN_UNDEF;
4286 if (!h->pointer_equality_needed)
4291 if (h->got.offset != (bfd_vma) -1
4292 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h)->tls_type)
4293 && elf_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE)
4295 Elf_Internal_Rela rela;
4297 /* This symbol has an entry in the global offset table. Set it
4299 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
4302 rela.r_offset = (htab->elf.sgot->output_section->vma
4303 + htab->elf.sgot->output_offset
4304 + (h->got.offset &~ (bfd_vma) 1));
4306 /* If this is a static link, or it is a -Bsymbolic link and the
4307 symbol is defined locally or was forced to be local because
4308 of a version file, we just want to emit a RELATIVE reloc.
4309 The entry in the global offset table will already have been
4310 initialized in the relocate_section function. */
4312 && h->type == STT_GNU_IFUNC)
4316 /* Generate R_X86_64_GLOB_DAT. */
4323 if (!h->pointer_equality_needed)
4326 /* For non-shared object, we can't use .got.plt, which
4327 contains the real function addres if we need pointer
4328 equality. We load the GOT entry with the PLT entry. */
4329 plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4330 bfd_put_64 (output_bfd, (plt->output_section->vma
4331 + plt->output_offset
4333 htab->elf.sgot->contents + h->got.offset);
4337 else if (info->shared
4338 && SYMBOL_REFERENCES_LOCAL (info, h))
4340 if (!h->def_regular)
4342 BFD_ASSERT((h->got.offset & 1) != 0);
4343 rela.r_info = htab->r_info (0, R_X86_64_RELATIVE);
4344 rela.r_addend = (h->root.u.def.value
4345 + h->root.u.def.section->output_section->vma
4346 + h->root.u.def.section->output_offset);
4350 BFD_ASSERT((h->got.offset & 1) == 0);
4352 bfd_put_64 (output_bfd, (bfd_vma) 0,
4353 htab->elf.sgot->contents + h->got.offset);
4354 rela.r_info = htab->r_info (h->dynindx, R_X86_64_GLOB_DAT);
4358 elf_append_rela (output_bfd, htab->elf.srelgot, &rela);
4363 Elf_Internal_Rela rela;
4365 /* This symbol needs a copy reloc. Set it up. */
4367 if (h->dynindx == -1
4368 || (h->root.type != bfd_link_hash_defined
4369 && h->root.type != bfd_link_hash_defweak)
4370 || htab->srelbss == NULL)
4373 rela.r_offset = (h->root.u.def.value
4374 + h->root.u.def.section->output_section->vma
4375 + h->root.u.def.section->output_offset);
4376 rela.r_info = htab->r_info (h->dynindx, R_X86_64_COPY);
4378 elf_append_rela (output_bfd, htab->srelbss, &rela);
4381 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. SYM may
4382 be NULL for local symbols. */
4384 && (strcmp (h->root.root.string, "_DYNAMIC") == 0
4385 || h == htab->elf.hgot))
4386 sym->st_shndx = SHN_ABS;
4391 /* Finish up local dynamic symbol handling. We set the contents of
4392 various dynamic sections here. */
4395 elf_x86_64_finish_local_dynamic_symbol (void **slot, void *inf)
4397 struct elf_link_hash_entry *h
4398 = (struct elf_link_hash_entry *) *slot;
4399 struct bfd_link_info *info
4400 = (struct bfd_link_info *) inf;
4402 return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
4406 /* Used to decide how to sort relocs in an optimal manner for the
4407 dynamic linker, before writing them out. */
4409 static enum elf_reloc_type_class
4410 elf_x86_64_reloc_type_class (const Elf_Internal_Rela *rela)
4412 switch ((int) ELF32_R_TYPE (rela->r_info))
4414 case R_X86_64_RELATIVE:
4415 return reloc_class_relative;
4416 case R_X86_64_JUMP_SLOT:
4417 return reloc_class_plt;
4419 return reloc_class_copy;
4421 return reloc_class_normal;
4425 /* Finish up the dynamic sections. */
4428 elf_x86_64_finish_dynamic_sections (bfd *output_bfd,
4429 struct bfd_link_info *info)
4431 struct elf_x86_64_link_hash_table *htab;
4435 htab = elf_x86_64_hash_table (info);
4439 dynobj = htab->elf.dynobj;
4440 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4442 if (htab->elf.dynamic_sections_created)
4444 bfd_byte *dyncon, *dynconend;
4445 const struct elf_backend_data *bed;
4446 bfd_size_type sizeof_dyn;
4448 if (sdyn == NULL || htab->elf.sgot == NULL)
4451 bed = get_elf_backend_data (dynobj);
4452 sizeof_dyn = bed->s->sizeof_dyn;
4453 dyncon = sdyn->contents;
4454 dynconend = sdyn->contents + sdyn->size;
4455 for (; dyncon < dynconend; dyncon += sizeof_dyn)
4457 Elf_Internal_Dyn dyn;
4460 (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
4468 s = htab->elf.sgotplt;
4469 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4473 dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
4477 s = htab->elf.srelplt->output_section;
4478 dyn.d_un.d_val = s->size;
4482 /* The procedure linkage table relocs (DT_JMPREL) should
4483 not be included in the overall relocs (DT_RELA).
4484 Therefore, we override the DT_RELASZ entry here to
4485 make it not include the JMPREL relocs. Since the
4486 linker script arranges for .rela.plt to follow all
4487 other relocation sections, we don't have to worry
4488 about changing the DT_RELA entry. */
4489 if (htab->elf.srelplt != NULL)
4491 s = htab->elf.srelplt->output_section;
4492 dyn.d_un.d_val -= s->size;
4496 case DT_TLSDESC_PLT:
4498 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
4499 + htab->tlsdesc_plt;
4502 case DT_TLSDESC_GOT:
4504 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
4505 + htab->tlsdesc_got;
4509 (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
4512 /* Fill in the special first entry in the procedure linkage table. */
4513 if (htab->elf.splt && htab->elf.splt->size > 0)
4515 /* Fill in the first entry in the procedure linkage table. */
4516 memcpy (htab->elf.splt->contents, elf_x86_64_plt0_entry,
4518 /* Add offset for pushq GOT+8(%rip), since the instruction
4519 uses 6 bytes subtract this value. */
4520 bfd_put_32 (output_bfd,
4521 (htab->elf.sgotplt->output_section->vma
4522 + htab->elf.sgotplt->output_offset
4524 - htab->elf.splt->output_section->vma
4525 - htab->elf.splt->output_offset
4527 htab->elf.splt->contents + 2);
4528 /* Add offset for jmp *GOT+16(%rip). The 12 is the offset to
4529 the end of the instruction. */
4530 bfd_put_32 (output_bfd,
4531 (htab->elf.sgotplt->output_section->vma
4532 + htab->elf.sgotplt->output_offset
4534 - htab->elf.splt->output_section->vma
4535 - htab->elf.splt->output_offset
4537 htab->elf.splt->contents + 8);
4539 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize =
4542 if (htab->tlsdesc_plt)
4544 bfd_put_64 (output_bfd, (bfd_vma) 0,
4545 htab->elf.sgot->contents + htab->tlsdesc_got);
4547 memcpy (htab->elf.splt->contents + htab->tlsdesc_plt,
4548 elf_x86_64_plt0_entry,
4551 /* Add offset for pushq GOT+8(%rip), since the
4552 instruction uses 6 bytes subtract this value. */
4553 bfd_put_32 (output_bfd,
4554 (htab->elf.sgotplt->output_section->vma
4555 + htab->elf.sgotplt->output_offset
4557 - htab->elf.splt->output_section->vma
4558 - htab->elf.splt->output_offset
4561 htab->elf.splt->contents + htab->tlsdesc_plt + 2);
4562 /* Add offset for jmp *GOT+TDG(%rip), where TGD stands for
4563 htab->tlsdesc_got. The 12 is the offset to the end of
4565 bfd_put_32 (output_bfd,
4566 (htab->elf.sgot->output_section->vma
4567 + htab->elf.sgot->output_offset
4569 - htab->elf.splt->output_section->vma
4570 - htab->elf.splt->output_offset
4573 htab->elf.splt->contents + htab->tlsdesc_plt + 8);
4578 if (htab->elf.sgotplt)
4580 if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
4582 (*_bfd_error_handler)
4583 (_("discarded output section: `%A'"), htab->elf.sgotplt);
4587 /* Fill in the first three entries in the global offset table. */
4588 if (htab->elf.sgotplt->size > 0)
4590 /* Set the first entry in the global offset table to the address of
4591 the dynamic section. */
4593 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents);
4595 bfd_put_64 (output_bfd,
4596 sdyn->output_section->vma + sdyn->output_offset,
4597 htab->elf.sgotplt->contents);
4598 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
4599 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
4600 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE*2);
4603 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize =
4607 /* Adjust .eh_frame for .plt section. */
4608 if (htab->plt_eh_frame != NULL)
4610 if (htab->elf.splt != NULL
4611 && htab->elf.splt->size != 0
4612 && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
4613 && htab->elf.splt->output_section != NULL
4614 && htab->plt_eh_frame->output_section != NULL)
4616 bfd_vma plt_start = htab->elf.splt->output_section->vma;
4617 bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
4618 + htab->plt_eh_frame->output_offset
4619 + PLT_FDE_START_OFFSET;
4620 bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
4621 htab->plt_eh_frame->contents
4622 + PLT_FDE_START_OFFSET);
4624 if (htab->plt_eh_frame->sec_info_type
4625 == ELF_INFO_TYPE_EH_FRAME)
4627 if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
4629 htab->plt_eh_frame->contents))
4634 if (htab->elf.sgot && htab->elf.sgot->size > 0)
4635 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
4638 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4639 htab_traverse (htab->loc_hash_table,
4640 elf_x86_64_finish_local_dynamic_symbol,
4646 /* Return address for Ith PLT stub in section PLT, for relocation REL
4647 or (bfd_vma) -1 if it should not be included. */
4650 elf_x86_64_plt_sym_val (bfd_vma i, const asection *plt,
4651 const arelent *rel ATTRIBUTE_UNUSED)
4653 return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
4656 /* Handle an x86-64 specific section when reading an object file. This
4657 is called when elfcode.h finds a section with an unknown type. */
4660 elf_x86_64_section_from_shdr (bfd *abfd,
4661 Elf_Internal_Shdr *hdr,
4665 if (hdr->sh_type != SHT_X86_64_UNWIND)
4668 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
4674 /* Hook called by the linker routine which adds symbols from an object
4675 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
4679 elf_x86_64_add_symbol_hook (bfd *abfd,
4680 struct bfd_link_info *info,
4681 Elf_Internal_Sym *sym,
4682 const char **namep ATTRIBUTE_UNUSED,
4683 flagword *flagsp ATTRIBUTE_UNUSED,
4689 switch (sym->st_shndx)
4691 case SHN_X86_64_LCOMMON:
4692 lcomm = bfd_get_section_by_name (abfd, "LARGE_COMMON");
4695 lcomm = bfd_make_section_with_flags (abfd,
4699 | SEC_LINKER_CREATED));
4702 elf_section_flags (lcomm) |= SHF_X86_64_LARGE;
4705 *valp = sym->st_size;
4709 if ((abfd->flags & DYNAMIC) == 0
4710 && (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
4711 || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE))
4712 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4718 /* Given a BFD section, try to locate the corresponding ELF section
4722 elf_x86_64_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
4723 asection *sec, int *index_return)
4725 if (sec == &_bfd_elf_large_com_section)
4727 *index_return = SHN_X86_64_LCOMMON;
4733 /* Process a symbol. */
4736 elf_x86_64_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
4739 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
4741 switch (elfsym->internal_elf_sym.st_shndx)
4743 case SHN_X86_64_LCOMMON:
4744 asym->section = &_bfd_elf_large_com_section;
4745 asym->value = elfsym->internal_elf_sym.st_size;
4746 /* Common symbol doesn't set BSF_GLOBAL. */
4747 asym->flags &= ~BSF_GLOBAL;
4753 elf_x86_64_common_definition (Elf_Internal_Sym *sym)
4755 return (sym->st_shndx == SHN_COMMON
4756 || sym->st_shndx == SHN_X86_64_LCOMMON);
4760 elf_x86_64_common_section_index (asection *sec)
4762 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
4765 return SHN_X86_64_LCOMMON;
4769 elf_x86_64_common_section (asection *sec)
4771 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
4772 return bfd_com_section_ptr;
4774 return &_bfd_elf_large_com_section;
4778 elf_x86_64_merge_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
4779 struct elf_link_hash_entry **sym_hash ATTRIBUTE_UNUSED,
4780 struct elf_link_hash_entry *h,
4781 Elf_Internal_Sym *sym,
4783 bfd_vma *pvalue ATTRIBUTE_UNUSED,
4784 unsigned int *pold_alignment ATTRIBUTE_UNUSED,
4785 bfd_boolean *skip ATTRIBUTE_UNUSED,
4786 bfd_boolean *override ATTRIBUTE_UNUSED,
4787 bfd_boolean *type_change_ok ATTRIBUTE_UNUSED,
4788 bfd_boolean *size_change_ok ATTRIBUTE_UNUSED,
4789 bfd_boolean *newdyn ATTRIBUTE_UNUSED,
4790 bfd_boolean *newdef,
4791 bfd_boolean *newdyncommon ATTRIBUTE_UNUSED,
4792 bfd_boolean *newweak ATTRIBUTE_UNUSED,
4793 bfd *abfd ATTRIBUTE_UNUSED,
4795 bfd_boolean *olddyn ATTRIBUTE_UNUSED,
4796 bfd_boolean *olddef,
4797 bfd_boolean *olddyncommon ATTRIBUTE_UNUSED,
4798 bfd_boolean *oldweak ATTRIBUTE_UNUSED,
4802 /* A normal common symbol and a large common symbol result in a
4803 normal common symbol. We turn the large common symbol into a
4806 && h->root.type == bfd_link_hash_common
4808 && bfd_is_com_section (*sec)
4811 if (sym->st_shndx == SHN_COMMON
4812 && (elf_section_flags (*oldsec) & SHF_X86_64_LARGE) != 0)
4814 h->root.u.c.p->section
4815 = bfd_make_section_old_way (oldbfd, "COMMON");
4816 h->root.u.c.p->section->flags = SEC_ALLOC;
4818 else if (sym->st_shndx == SHN_X86_64_LCOMMON
4819 && (elf_section_flags (*oldsec) & SHF_X86_64_LARGE) == 0)
4820 *psec = *sec = bfd_com_section_ptr;
4827 elf_x86_64_additional_program_headers (bfd *abfd,
4828 struct bfd_link_info *info ATTRIBUTE_UNUSED)
4833 /* Check to see if we need a large readonly segment. */
4834 s = bfd_get_section_by_name (abfd, ".lrodata");
4835 if (s && (s->flags & SEC_LOAD))
4838 /* Check to see if we need a large data segment. Since .lbss sections
4839 is placed right after the .bss section, there should be no need for
4840 a large data segment just because of .lbss. */
4841 s = bfd_get_section_by_name (abfd, ".ldata");
4842 if (s && (s->flags & SEC_LOAD))
4848 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
4851 elf_x86_64_hash_symbol (struct elf_link_hash_entry *h)
4853 if (h->plt.offset != (bfd_vma) -1
4855 && !h->pointer_equality_needed)
4858 return _bfd_elf_hash_symbol (h);
4861 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
4864 elf_x86_64_relocs_compatible (const bfd_target *input,
4865 const bfd_target *output)
4867 return ((xvec_get_elf_backend_data (input)->s->elfclass
4868 == xvec_get_elf_backend_data (output)->s->elfclass)
4869 && _bfd_elf_relocs_compatible (input, output));
4872 static const struct bfd_elf_special_section
4873 elf_x86_64_special_sections[]=
4875 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
4876 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
4877 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR + SHF_X86_64_LARGE},
4878 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
4879 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
4880 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
4881 { NULL, 0, 0, 0, 0 }
4884 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_vec
4885 #define TARGET_LITTLE_NAME "elf64-x86-64"
4886 #define ELF_ARCH bfd_arch_i386
4887 #define ELF_TARGET_ID X86_64_ELF_DATA
4888 #define ELF_MACHINE_CODE EM_X86_64
4889 #define ELF_MAXPAGESIZE 0x200000
4890 #define ELF_MINPAGESIZE 0x1000
4891 #define ELF_COMMONPAGESIZE 0x1000
4893 #define elf_backend_can_gc_sections 1
4894 #define elf_backend_can_refcount 1
4895 #define elf_backend_want_got_plt 1
4896 #define elf_backend_plt_readonly 1
4897 #define elf_backend_want_plt_sym 0
4898 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
4899 #define elf_backend_rela_normal 1
4900 #define elf_backend_plt_alignment 4
4902 #define elf_info_to_howto elf_x86_64_info_to_howto
4904 #define bfd_elf64_bfd_link_hash_table_create \
4905 elf_x86_64_link_hash_table_create
4906 #define bfd_elf64_bfd_link_hash_table_free \
4907 elf_x86_64_link_hash_table_free
4908 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
4909 #define bfd_elf64_bfd_reloc_name_lookup \
4910 elf_x86_64_reloc_name_lookup
4912 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
4913 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
4914 #define elf_backend_check_relocs elf_x86_64_check_relocs
4915 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
4916 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
4917 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
4918 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
4919 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
4920 #define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
4921 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
4922 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
4924 #define elf_backend_write_core_note elf_x86_64_write_core_note
4926 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
4927 #define elf_backend_relocate_section elf_x86_64_relocate_section
4928 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
4929 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
4930 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
4931 #define elf_backend_plt_sym_val elf_x86_64_plt_sym_val
4932 #define elf_backend_object_p elf64_x86_64_elf_object_p
4933 #define bfd_elf64_mkobject elf_x86_64_mkobject
4935 #define elf_backend_section_from_shdr \
4936 elf_x86_64_section_from_shdr
4938 #define elf_backend_section_from_bfd_section \
4939 elf_x86_64_elf_section_from_bfd_section
4940 #define elf_backend_add_symbol_hook \
4941 elf_x86_64_add_symbol_hook
4942 #define elf_backend_symbol_processing \
4943 elf_x86_64_symbol_processing
4944 #define elf_backend_common_section_index \
4945 elf_x86_64_common_section_index
4946 #define elf_backend_common_section \
4947 elf_x86_64_common_section
4948 #define elf_backend_common_definition \
4949 elf_x86_64_common_definition
4950 #define elf_backend_merge_symbol \
4951 elf_x86_64_merge_symbol
4952 #define elf_backend_special_sections \
4953 elf_x86_64_special_sections
4954 #define elf_backend_additional_program_headers \
4955 elf_x86_64_additional_program_headers
4956 #define elf_backend_hash_symbol \
4957 elf_x86_64_hash_symbol
4959 #define elf_backend_post_process_headers _bfd_elf_set_osabi
4961 #include "elf64-target.h"
4963 /* FreeBSD support. */
4965 #undef TARGET_LITTLE_SYM
4966 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_freebsd_vec
4967 #undef TARGET_LITTLE_NAME
4968 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
4971 #define ELF_OSABI ELFOSABI_FREEBSD
4974 #define elf64_bed elf64_x86_64_fbsd_bed
4976 #include "elf64-target.h"
4978 /* Solaris 2 support. */
4980 #undef TARGET_LITTLE_SYM
4981 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_sol2_vec
4982 #undef TARGET_LITTLE_NAME
4983 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
4985 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
4986 objects won't be recognized. */
4990 #define elf64_bed elf64_x86_64_sol2_bed
4992 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
4994 #undef elf_backend_static_tls_alignment
4995 #define elf_backend_static_tls_alignment 16
4997 /* The Solaris 2 ABI requires a plt symbol on all platforms.
4999 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5001 #undef elf_backend_want_plt_sym
5002 #define elf_backend_want_plt_sym 1
5004 #include "elf64-target.h"
5006 /* Intel L1OM support. */
5009 elf64_l1om_elf_object_p (bfd *abfd)
5011 /* Set the right machine number for an L1OM elf64 file. */
5012 bfd_default_set_arch_mach (abfd, bfd_arch_l1om, bfd_mach_l1om);
5016 #undef TARGET_LITTLE_SYM
5017 #define TARGET_LITTLE_SYM bfd_elf64_l1om_vec
5018 #undef TARGET_LITTLE_NAME
5019 #define TARGET_LITTLE_NAME "elf64-l1om"
5021 #define ELF_ARCH bfd_arch_l1om
5023 #undef ELF_MACHINE_CODE
5024 #define ELF_MACHINE_CODE EM_L1OM
5029 #define elf64_bed elf64_l1om_bed
5031 #undef elf_backend_object_p
5032 #define elf_backend_object_p elf64_l1om_elf_object_p
5034 #undef elf_backend_static_tls_alignment
5036 #undef elf_backend_want_plt_sym
5037 #define elf_backend_want_plt_sym 0
5039 #include "elf64-target.h"
5041 /* FreeBSD L1OM support. */
5043 #undef TARGET_LITTLE_SYM
5044 #define TARGET_LITTLE_SYM bfd_elf64_l1om_freebsd_vec
5045 #undef TARGET_LITTLE_NAME
5046 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
5049 #define ELF_OSABI ELFOSABI_FREEBSD
5052 #define elf64_bed elf64_l1om_fbsd_bed
5054 #include "elf64-target.h"
5056 /* Intel K1OM support. */
5059 elf64_k1om_elf_object_p (bfd *abfd)
5061 /* Set the right machine number for an K1OM elf64 file. */
5062 bfd_default_set_arch_mach (abfd, bfd_arch_k1om, bfd_mach_k1om);
5066 #undef TARGET_LITTLE_SYM
5067 #define TARGET_LITTLE_SYM bfd_elf64_k1om_vec
5068 #undef TARGET_LITTLE_NAME
5069 #define TARGET_LITTLE_NAME "elf64-k1om"
5071 #define ELF_ARCH bfd_arch_k1om
5073 #undef ELF_MACHINE_CODE
5074 #define ELF_MACHINE_CODE EM_K1OM
5079 #define elf64_bed elf64_k1om_bed
5081 #undef elf_backend_object_p
5082 #define elf_backend_object_p elf64_k1om_elf_object_p
5084 #undef elf_backend_static_tls_alignment
5086 #undef elf_backend_want_plt_sym
5087 #define elf_backend_want_plt_sym 0
5089 #include "elf64-target.h"
5091 /* FreeBSD K1OM support. */
5093 #undef TARGET_LITTLE_SYM
5094 #define TARGET_LITTLE_SYM bfd_elf64_k1om_freebsd_vec
5095 #undef TARGET_LITTLE_NAME
5096 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
5099 #define ELF_OSABI ELFOSABI_FREEBSD
5102 #define elf64_bed elf64_k1om_fbsd_bed
5104 #include "elf64-target.h"
5106 /* 32bit x86-64 support. */
5109 elf32_x86_64_elf_object_p (bfd *abfd)
5111 /* Set the right machine number for an x86-64 elf32 file. */
5112 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32);
5116 #undef TARGET_LITTLE_SYM
5117 #define TARGET_LITTLE_SYM bfd_elf32_x86_64_vec
5118 #undef TARGET_LITTLE_NAME
5119 #define TARGET_LITTLE_NAME "elf32-x86-64"
5122 #define ELF_ARCH bfd_arch_i386
5124 #undef ELF_MACHINE_CODE
5125 #define ELF_MACHINE_CODE EM_X86_64
5127 #define bfd_elf32_bfd_link_hash_table_create \
5128 elf_x86_64_link_hash_table_create
5129 #define bfd_elf32_bfd_link_hash_table_free \
5130 elf_x86_64_link_hash_table_free
5131 #define bfd_elf32_bfd_reloc_type_lookup \
5132 elf_x86_64_reloc_type_lookup
5133 #define bfd_elf32_bfd_reloc_name_lookup \
5134 elf_x86_64_reloc_name_lookup
5135 #define bfd_elf32_mkobject \
5140 #undef elf_backend_object_p
5141 #define elf_backend_object_p \
5142 elf32_x86_64_elf_object_p
5144 #undef elf_backend_bfd_from_remote_memory
5145 #define elf_backend_bfd_from_remote_memory \
5146 _bfd_elf32_bfd_from_remote_memory
5148 #undef elf_backend_size_info
5149 #define elf_backend_size_info \
5150 _bfd_elf32_size_info
5152 #include "elf32-target.h"