]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - bfd/elf64-x86-64.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* hppa.h: Update copyright dates.
[thirdparty/binutils-gdb.git] / bfd / elf64-x86-64.c
CommitLineData
8d88c4ca 1/* X86-64 specific support for 64-bit ELF
3eb128b2
AM		 2 Copyright 2000, 2001, 2002, 2003, 2004, 2005
3 Free Software Foundation, Inc.
8d88c4ca
NC		 4 Contributed by Jan Hubicka <jh@suse.cz>.
5
ae9a127f 6 This file is part of BFD, the Binary File Descriptor library.
8d88c4ca 7
ae9a127f
NC		 8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
8d88c4ca 12
ae9a127f
NC		 13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
8d88c4ca 17
ae9a127f
NC		 18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
3e110533 20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
8d88c4ca
NC		 21
22#include "bfd.h"
23#include "sysdep.h"
c434dee6 24#include "bfdlink.h"
8d88c4ca
NC		 25#include "libbfd.h"
26#include "elf-bfd.h"
27
28#include "elf/x86-64.h"
29
8d88c4ca
NC		 30/* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
31#define MINUS_ONE (~ (bfd_vma) 0)
32
33/* The relocation "howto" table. Order of fields:
407443a3
AJ		 34 type, size, bitsize, pc_relative, complain_on_overflow,
35 special_function, name, partial_inplace, src_mask, dst_pack, pcrel_offset. */
70256ad8
AJ		 36static reloc_howto_type x86_64_elf_howto_table[] =
37{
b34976b6
AM		 38 HOWTO(R_X86_64_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
39 bfd_elf_generic_reloc, "R_X86_64_NONE", FALSE, 0x00000000, 0x00000000,
40 FALSE),
41 HOWTO(R_X86_64_64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
42 bfd_elf_generic_reloc, "R_X86_64_64", FALSE, MINUS_ONE, MINUS_ONE,
43 FALSE),
44 HOWTO(R_X86_64_PC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
45 bfd_elf_generic_reloc, "R_X86_64_PC32", FALSE, 0xffffffff, 0xffffffff,
46 TRUE),
47 HOWTO(R_X86_64_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
48 bfd_elf_generic_reloc, "R_X86_64_GOT32", FALSE, 0xffffffff, 0xffffffff,
49 FALSE),
50 HOWTO(R_X86_64_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
51 bfd_elf_generic_reloc, "R_X86_64_PLT32", FALSE, 0xffffffff, 0xffffffff,
52 TRUE),
53 HOWTO(R_X86_64_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
54 bfd_elf_generic_reloc, "R_X86_64_COPY", FALSE, 0xffffffff, 0xffffffff,
55 FALSE),
56 HOWTO(R_X86_64_GLOB_DAT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
57 bfd_elf_generic_reloc, "R_X86_64_GLOB_DAT", FALSE, MINUS_ONE,
58 MINUS_ONE, FALSE),
59 HOWTO(R_X86_64_JUMP_SLOT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
60 bfd_elf_generic_reloc, "R_X86_64_JUMP_SLOT", FALSE, MINUS_ONE,
61 MINUS_ONE, FALSE),
62 HOWTO(R_X86_64_RELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
63 bfd_elf_generic_reloc, "R_X86_64_RELATIVE", FALSE, MINUS_ONE,
64 MINUS_ONE, FALSE),
65 HOWTO(R_X86_64_GOTPCREL, 0, 2, 32, TRUE, 0, complain_overflow_signed,
66 bfd_elf_generic_reloc, "R_X86_64_GOTPCREL", FALSE, 0xffffffff,
67 0xffffffff, TRUE),
68 HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
69 bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
70 FALSE),
71 HOWTO(R_X86_64_32S, 0, 2, 32, FALSE, 0, complain_overflow_signed,
72 bfd_elf_generic_reloc, "R_X86_64_32S", FALSE, 0xffffffff, 0xffffffff,
73 FALSE),
74 HOWTO(R_X86_64_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
75 bfd_elf_generic_reloc, "R_X86_64_16", FALSE, 0xffff, 0xffff, FALSE),
ac2aa337 76 HOWTO(R_X86_64_PC16,0, 1, 16, TRUE, 0, complain_overflow_signed,
b34976b6 77 bfd_elf_generic_reloc, "R_X86_64_PC16", FALSE, 0xffff, 0xffff, TRUE),
ac2aa337 78 HOWTO(R_X86_64_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
b34976b6
AM		 79 bfd_elf_generic_reloc, "R_X86_64_8", FALSE, 0xff, 0xff, FALSE),
80 HOWTO(R_X86_64_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
81 bfd_elf_generic_reloc, "R_X86_64_PC8", FALSE, 0xff, 0xff, TRUE),
82 HOWTO(R_X86_64_DTPMOD64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
83 bfd_elf_generic_reloc, "R_X86_64_DTPMOD64", FALSE, MINUS_ONE,
84 MINUS_ONE, FALSE),
85 HOWTO(R_X86_64_DTPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
86 bfd_elf_generic_reloc, "R_X86_64_DTPOFF64", FALSE, MINUS_ONE,
87 MINUS_ONE, FALSE),
88 HOWTO(R_X86_64_TPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
89 bfd_elf_generic_reloc, "R_X86_64_TPOFF64", FALSE, MINUS_ONE,
90 MINUS_ONE, FALSE),
91 HOWTO(R_X86_64_TLSGD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
92 bfd_elf_generic_reloc, "R_X86_64_TLSGD", FALSE, 0xffffffff,
93 0xffffffff, TRUE),
94 HOWTO(R_X86_64_TLSLD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
95 bfd_elf_generic_reloc, "R_X86_64_TLSLD", FALSE, 0xffffffff,
96 0xffffffff, TRUE),
ac2aa337 97 HOWTO(R_X86_64_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
b34976b6
AM		 98 bfd_elf_generic_reloc, "R_X86_64_DTPOFF32", FALSE, 0xffffffff,
99 0xffffffff, FALSE),
100 HOWTO(R_X86_64_GOTTPOFF, 0, 2, 32, TRUE, 0, complain_overflow_signed,
101 bfd_elf_generic_reloc, "R_X86_64_GOTTPOFF", FALSE, 0xffffffff,
102 0xffffffff, TRUE),
103 HOWTO(R_X86_64_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
104 bfd_elf_generic_reloc, "R_X86_64_TPOFF32", FALSE, 0xffffffff,
105 0xffffffff, FALSE),
d6ab8113
JB		 106 HOWTO(R_X86_64_PC64, 0, 4, 64, TRUE, 0, complain_overflow_bitfield,
107 bfd_elf_generic_reloc, "R_X86_64_PC64", FALSE, MINUS_ONE, MINUS_ONE,
108 TRUE),
109 HOWTO(R_X86_64_GOTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
110 bfd_elf_generic_reloc, "R_X86_64_GOTOFF64",
111 FALSE, MINUS_ONE, MINUS_ONE, FALSE),
112 HOWTO(R_X86_64_GOTPC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
113 bfd_elf_generic_reloc, "R_X86_64_GOTPC32",
114 FALSE, 0xffffffff, 0xffffffff, TRUE),
fe4770f4 115
a33d77bc
JB		 116 /* We have a gap in the reloc numbers here.
117 R_X86_64_standard counts the number up to this point, and
118 R_X86_64_vt_offset is the value to subtract from a reloc type of
119 R_X86_64_GNU_VT* to form an index into this table. */
120#define R_X86_64_standard (R_X86_64_GOTPC32 + 1)
121#define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
122
fe4770f4 123/* GNU extension to record C++ vtable hierarchy. */
b34976b6
AM		 124 HOWTO (R_X86_64_GNU_VTINHERIT, 0, 4, 0, FALSE, 0, complain_overflow_dont,
125 NULL, "R_X86_64_GNU_VTINHERIT", FALSE, 0, 0, FALSE),
fe4770f4
AJ		 126
127/* GNU extension to record C++ vtable member usage. */
b34976b6
AM		 128 HOWTO (R_X86_64_GNU_VTENTRY, 0, 4, 0, FALSE, 0, complain_overflow_dont,
129 _bfd_elf_rel_vtable_reloc_fn, "R_X86_64_GNU_VTENTRY", FALSE, 0, 0,
130 FALSE)
8d88c4ca
NC		 131};
132
133/* Map BFD relocs to the x86_64 elf relocs. */
70256ad8
AJ		 134struct elf_reloc_map
135{
8d88c4ca
NC		 136 bfd_reloc_code_real_type bfd_reloc_val;
137 unsigned char elf_reloc_val;
138};
139
dc810e39 140static const struct elf_reloc_map x86_64_reloc_map[] =
8d88c4ca 141{
70256ad8
AJ		 142 { BFD_RELOC_NONE, R_X86_64_NONE, },
143 { BFD_RELOC_64, R_X86_64_64, },
144 { BFD_RELOC_32_PCREL, R_X86_64_PC32, },
145 { BFD_RELOC_X86_64_GOT32, R_X86_64_GOT32,},
146 { BFD_RELOC_X86_64_PLT32, R_X86_64_PLT32,},
147 { BFD_RELOC_X86_64_COPY, R_X86_64_COPY, },
148 { BFD_RELOC_X86_64_GLOB_DAT, R_X86_64_GLOB_DAT, },
149 { BFD_RELOC_X86_64_JUMP_SLOT, R_X86_64_JUMP_SLOT, },
150 { BFD_RELOC_X86_64_RELATIVE, R_X86_64_RELATIVE, },
151 { BFD_RELOC_X86_64_GOTPCREL, R_X86_64_GOTPCREL, },
152 { BFD_RELOC_32, R_X86_64_32, },
153 { BFD_RELOC_X86_64_32S, R_X86_64_32S, },
154 { BFD_RELOC_16, R_X86_64_16, },
155 { BFD_RELOC_16_PCREL, R_X86_64_PC16, },
156 { BFD_RELOC_8, R_X86_64_8, },
157 { BFD_RELOC_8_PCREL, R_X86_64_PC8, },
bffbf940
JJ		 158 { BFD_RELOC_X86_64_DTPMOD64, R_X86_64_DTPMOD64, },
159 { BFD_RELOC_X86_64_DTPOFF64, R_X86_64_DTPOFF64, },
160 { BFD_RELOC_X86_64_TPOFF64, R_X86_64_TPOFF64, },
161 { BFD_RELOC_X86_64_TLSGD, R_X86_64_TLSGD, },
162 { BFD_RELOC_X86_64_TLSLD, R_X86_64_TLSLD, },
163 { BFD_RELOC_X86_64_DTPOFF32, R_X86_64_DTPOFF32, },
164 { BFD_RELOC_X86_64_GOTTPOFF, R_X86_64_GOTTPOFF, },
165 { BFD_RELOC_X86_64_TPOFF32, R_X86_64_TPOFF32, },
d6ab8113
JB		 166 { BFD_RELOC_64_PCREL, R_X86_64_PC64, },
167 { BFD_RELOC_X86_64_GOTOFF64, R_X86_64_GOTOFF64, },
168 { BFD_RELOC_X86_64_GOTPC32, R_X86_64_GOTPC32, },
fe4770f4
AJ		 169 { BFD_RELOC_VTABLE_INHERIT, R_X86_64_GNU_VTINHERIT, },
170 { BFD_RELOC_VTABLE_ENTRY, R_X86_64_GNU_VTENTRY, },
8d88c4ca
NC		 171};
172
8d88c4ca
NC		 173
174/* Given a BFD reloc type, return a HOWTO structure. */
175static reloc_howto_type *
27482721
AJ		 176elf64_x86_64_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
177 bfd_reloc_code_real_type code)
8d88c4ca
NC		 178{
179 unsigned int i;
27482721 180
8d88c4ca
NC		 181 for (i = 0; i < sizeof (x86_64_reloc_map) / sizeof (struct elf_reloc_map);
182 i++)
183 {
184 if (x86_64_reloc_map[i].bfd_reloc_val == code)
ffaef159 185 return &x86_64_elf_howto_table[i];
8d88c4ca
NC		 186 }
187 return 0;
188}
189
8d88c4ca 190/* Given an x86_64 ELF reloc type, fill in an arelent structure. */
8da6118f 191
8d88c4ca 192static void
27482721
AJ		 193elf64_x86_64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
194 Elf_Internal_Rela *dst)
8d88c4ca 195{
fe4770f4 196 unsigned r_type, i;
8d88c4ca
NC		 197
198 r_type = ELF64_R_TYPE (dst->r_info);
d0fb9a8d
JJ		 199 if (r_type < (unsigned int) R_X86_64_GNU_VTINHERIT
200 || r_type >= (unsigned int) R_X86_64_max)
fe4770f4 201 {
a33d77bc 202 if (r_type >= (unsigned int) R_X86_64_standard)
d0fb9a8d
JJ		 203 {
204 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
205 abfd, (int) r_type);
206 r_type = R_X86_64_NONE;
207 }
fe4770f4
AJ		 208 i = r_type;
209 }
210 else
a33d77bc 211 i = r_type - (unsigned int) R_X86_64_vt_offset;
fe4770f4 212 cache_ptr->howto = &x86_64_elf_howto_table[i];
8d88c4ca
NC		 213 BFD_ASSERT (r_type == cache_ptr->howto->type);
214}
70256ad8 215\f
3bab7989 216/* Support for core dump NOTE sections. */
b34976b6 217static bfd_boolean
27482721 218elf64_x86_64_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3bab7989
ML		 219{
220 int offset;
eea6121a 221 size_t size;
3bab7989
ML		 222
223 switch (note->descsz)
224 {
225 default:
b34976b6 226 return FALSE;
3bab7989
ML		 227
228 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
229 /* pr_cursig */
cedb70c5 230 elf_tdata (abfd)->core_signal
3bab7989
ML		 231 = bfd_get_16 (abfd, note->descdata + 12);
232
233 /* pr_pid */
cedb70c5 234 elf_tdata (abfd)->core_pid
3bab7989
ML		 235 = bfd_get_32 (abfd, note->descdata + 32);
236
237 /* pr_reg */
238 offset = 112;
eea6121a 239 size = 216;
3bab7989
ML		 240
241 break;
242 }
243
244 /* Make a ".reg/999" section. */
245 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
eea6121a 246 size, note->descpos + offset);
3bab7989
ML		 247}
248
b34976b6 249static bfd_boolean
27482721 250elf64_x86_64_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3bab7989
ML		 251{
252 switch (note->descsz)
253 {
254 default:
b34976b6 255 return FALSE;
3bab7989
ML		 256
257 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
258 elf_tdata (abfd)->core_program
259 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
260 elf_tdata (abfd)->core_command
261 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
262 }
263
264 /* Note that for some reason, a spurious space is tacked
265 onto the end of the args in some (at least one anyway)
266 implementations, so strip it off if it exists. */
267
268 {
269 char *command = elf_tdata (abfd)->core_command;
270 int n = strlen (command);
271
272 if (0 < n && command[n - 1] == ' ')
273 command[n - 1] = '\0';
274 }
275
b34976b6 276 return TRUE;
3bab7989
ML		 277}
278\f
407443a3 279/* Functions for the x86-64 ELF linker. */
70256ad8 280
407443a3 281/* The name of the dynamic interpreter. This is put in the .interp
70256ad8
AJ		 282 section. */
283
407443a3 284#define ELF_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
70256ad8 285
d40d037c
AJ		 286/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
287 copying dynamic variables from a shared lib into an app's dynbss
288 section, and instead use a dynamic relocation to point into the
289 shared lib. */
290#define ELIMINATE_COPY_RELOCS 1
291
70256ad8
AJ		 292/* The size in bytes of an entry in the global offset table. */
293
294#define GOT_ENTRY_SIZE 8
8d88c4ca 295
70256ad8 296/* The size in bytes of an entry in the procedure linkage table. */
8d88c4ca 297
70256ad8
AJ		 298#define PLT_ENTRY_SIZE 16
299
300/* The first entry in a procedure linkage table looks like this. See the
301 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
302
303static const bfd_byte elf64_x86_64_plt0_entry[PLT_ENTRY_SIZE] =
304{
653165cc
AJ		 305 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
306 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
307 0x90, 0x90, 0x90, 0x90 /* pad out to 16 bytes with nops. */
70256ad8
AJ		 308};
309
310/* Subsequent entries in a procedure linkage table look like this. */
311
312static const bfd_byte elf64_x86_64_plt_entry[PLT_ENTRY_SIZE] =
313{
653165cc 314 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
407443a3 315 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
653165cc 316 0x68, /* pushq immediate */
70256ad8
AJ		 317 0, 0, 0, 0, /* replaced with index into relocation table. */
318 0xe9, /* jmp relative */
319 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
320};
321
322/* The x86-64 linker needs to keep track of the number of relocs that
985142a4 323 it decides to copy as dynamic relocs in check_relocs for each symbol.
c434dee6
AJ		 324 This is so that it can later discard them if they are found to be
325 unnecessary. We store the information in a field extending the
326 regular ELF linker hash table. */
70256ad8 327
c434dee6 328struct elf64_x86_64_dyn_relocs
70256ad8
AJ		 329{
330 /* Next section. */
c434dee6
AJ		 331 struct elf64_x86_64_dyn_relocs *next;
332
333 /* The input section of the reloc. */
334 asection *sec;
335
336 /* Total number of relocs copied for the input section. */
70256ad8 337 bfd_size_type count;
c434dee6
AJ		 338
339 /* Number of pc-relative relocs copied for the input section. */
340 bfd_size_type pc_count;
70256ad8
AJ		 341};
342
343/* x86-64 ELF linker hash entry. */
344
345struct elf64_x86_64_link_hash_entry
346{
c434dee6 347 struct elf_link_hash_entry elf;
70256ad8 348
c434dee6
AJ		 349 /* Track dynamic relocs copied for this symbol. */
350 struct elf64_x86_64_dyn_relocs *dyn_relocs;
bffbf940
JJ		 351
352#define GOT_UNKNOWN 0
353#define GOT_NORMAL 1
354#define GOT_TLS_GD 2
355#define GOT_TLS_IE 3
356 unsigned char tls_type;
357};
358
359#define elf64_x86_64_hash_entry(ent) \
360 ((struct elf64_x86_64_link_hash_entry *)(ent))
361
362struct elf64_x86_64_obj_tdata
363{
364 struct elf_obj_tdata root;
365
366 /* tls_type for each local got entry. */
367 char *local_got_tls_type;
70256ad8
AJ		 368};
369
bffbf940
JJ		 370#define elf64_x86_64_tdata(abfd) \
371 ((struct elf64_x86_64_obj_tdata *) (abfd)->tdata.any)
372
373#define elf64_x86_64_local_got_tls_type(abfd) \
374 (elf64_x86_64_tdata (abfd)->local_got_tls_type)
375
376
c434dee6 377/* x86-64 ELF linker hash table. */
8d88c4ca 378
407443a3
AJ		 379struct elf64_x86_64_link_hash_table
380{
c434dee6 381 struct elf_link_hash_table elf;
70256ad8 382
c434dee6
AJ		 383 /* Short-cuts to get to dynamic linker sections. */
384 asection *sgot;
385 asection *sgotplt;
386 asection *srelgot;
387 asection *splt;
388 asection *srelplt;
389 asection *sdynbss;
390 asection *srelbss;
70256ad8 391
bffbf940
JJ		 392 union {
393 bfd_signed_vma refcount;
394 bfd_vma offset;
395 } tls_ld_got;
396
c434dee6
AJ		 397 /* Small local sym to section mapping cache. */
398 struct sym_sec_cache sym_sec;
399};
70256ad8
AJ		 400
401/* Get the x86-64 ELF linker hash table from a link_info structure. */
8d88c4ca
NC		 402
403#define elf64_x86_64_hash_table(p) \
404 ((struct elf64_x86_64_link_hash_table *) ((p)->hash))
405
407443a3 406/* Create an entry in an x86-64 ELF linker hash table. */
70256ad8
AJ		 407
408static struct bfd_hash_entry *
27482721
AJ		 409link_hash_newfunc (struct bfd_hash_entry *entry, struct bfd_hash_table *table,
410 const char *string)
70256ad8 411{
70256ad8 412 /* Allocate the structure if it has not already been allocated by a
c434dee6
AJ		 413 subclass. */
414 if (entry == NULL)
415 {
416 entry = bfd_hash_allocate (table,
417 sizeof (struct elf64_x86_64_link_hash_entry));
418 if (entry == NULL)
419 return entry;
420 }
70256ad8
AJ		 421
422 /* Call the allocation method of the superclass. */
c434dee6
AJ		 423 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
424 if (entry != NULL)
70256ad8 425 {
c434dee6
AJ		 426 struct elf64_x86_64_link_hash_entry *eh;
427
428 eh = (struct elf64_x86_64_link_hash_entry *) entry;
429 eh->dyn_relocs = NULL;
bffbf940 430 eh->tls_type = GOT_UNKNOWN;
70256ad8
AJ		 431 }
432
c434dee6 433 return entry;
70256ad8
AJ		 434}
435
8d88c4ca
NC		 436/* Create an X86-64 ELF linker hash table. */
437
438static struct bfd_link_hash_table *
27482721 439elf64_x86_64_link_hash_table_create (bfd *abfd)
8d88c4ca
NC		 440{
441 struct elf64_x86_64_link_hash_table *ret;
dc810e39 442 bfd_size_type amt = sizeof (struct elf64_x86_64_link_hash_table);
8d88c4ca 443
e2d34d7d 444 ret = (struct elf64_x86_64_link_hash_table *) bfd_malloc (amt);
c434dee6 445 if (ret == NULL)
8d88c4ca
NC		 446 return NULL;
447
c434dee6 448 if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc))
8d88c4ca 449 {
e2d34d7d 450 free (ret);
8d88c4ca
NC		 451 return NULL;
452 }
453
c434dee6
AJ		 454 ret->sgot = NULL;
455 ret->sgotplt = NULL;
456 ret->srelgot = NULL;
457 ret->splt = NULL;
458 ret->srelplt = NULL;
459 ret->sdynbss = NULL;
460 ret->srelbss = NULL;
461 ret->sym_sec.abfd = NULL;
bffbf940 462 ret->tls_ld_got.refcount = 0;
c434dee6
AJ		 463
464 return &ret->elf.root;
465}
466
467/* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
468 shortcuts to them in our hash table. */
469
b34976b6 470static bfd_boolean
27482721 471create_got_section (bfd *dynobj, struct bfd_link_info *info)
c434dee6
AJ		 472{
473 struct elf64_x86_64_link_hash_table *htab;
474
475 if (! _bfd_elf_create_got_section (dynobj, info))
b34976b6 476 return FALSE;
c434dee6
AJ		 477
478 htab = elf64_x86_64_hash_table (info);
479 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
480 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
481 if (!htab->sgot || !htab->sgotplt)
482 abort ();
483
3496cb2a
L		 484 htab->srelgot = bfd_make_section_with_flags (dynobj, ".rela.got",
485 (SEC_ALLOC | SEC_LOAD
486 | SEC_HAS_CONTENTS
487 | SEC_IN_MEMORY
488 | SEC_LINKER_CREATED
489 | SEC_READONLY));
c434dee6 490 if (htab->srelgot == NULL
c434dee6 491 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 3))
b34976b6
AM		 492 return FALSE;
493 return TRUE;
c434dee6
AJ		 494}
495
496/* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
497 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
498 hash table. */
499
b34976b6 500static bfd_boolean
27482721 501elf64_x86_64_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
c434dee6
AJ		 502{
503 struct elf64_x86_64_link_hash_table *htab;
504
505 htab = elf64_x86_64_hash_table (info);
506 if (!htab->sgot && !create_got_section (dynobj, info))
b34976b6 507 return FALSE;
c434dee6
AJ		 508
509 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
b34976b6 510 return FALSE;
c434dee6
AJ		 511
512 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
513 htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
514 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
515 if (!info->shared)
516 htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
517
518 if (!htab->splt || !htab->srelplt || !htab->sdynbss
519 || (!info->shared && !htab->srelbss))
520 abort ();
521
b34976b6 522 return TRUE;
c434dee6
AJ		 523}
524
525/* Copy the extra info we tack onto an elf_link_hash_entry. */
526
527static void
9c5bfbb7 528elf64_x86_64_copy_indirect_symbol (const struct elf_backend_data *bed,
27482721
AJ		 529 struct elf_link_hash_entry *dir,
530 struct elf_link_hash_entry *ind)
c434dee6
AJ		 531{
532 struct elf64_x86_64_link_hash_entry *edir, *eind;
533
534 edir = (struct elf64_x86_64_link_hash_entry *) dir;
535 eind = (struct elf64_x86_64_link_hash_entry *) ind;
536
537 if (eind->dyn_relocs != NULL)
538 {
539 if (edir->dyn_relocs != NULL)
540 {
541 struct elf64_x86_64_dyn_relocs **pp;
542 struct elf64_x86_64_dyn_relocs *p;
543
544 if (ind->root.type == bfd_link_hash_indirect)
545 abort ();
546
547 /* Add reloc counts against the weak sym to the strong sym
548 list. Merge any entries against the same section. */
549 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
550 {
551 struct elf64_x86_64_dyn_relocs *q;
552
553 for (q = edir->dyn_relocs; q != NULL; q = q->next)
554 if (q->sec == p->sec)
555 {
556 q->pc_count += p->pc_count;
557 q->count += p->count;
558 *pp = p->next;
559 break;
560 }
561 if (q == NULL)
562 pp = &p->next;
563 }
564 *pp = edir->dyn_relocs;
565 }
566
567 edir->dyn_relocs = eind->dyn_relocs;
568 eind->dyn_relocs = NULL;
569 }
570
bffbf940
JJ		 571 if (ind->root.type == bfd_link_hash_indirect
572 && dir->got.refcount <= 0)
573 {
574 edir->tls_type = eind->tls_type;
575 eind->tls_type = GOT_UNKNOWN;
576 }
577
d40d037c
AJ		 578 if (ELIMINATE_COPY_RELOCS
579 && ind->root.type != bfd_link_hash_indirect
f5385ebf
AM		 580 && dir->dynamic_adjusted)
581 {
582 /* If called to transfer flags for a weakdef during processing
583 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
584 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
585 dir->ref_dynamic |= ind->ref_dynamic;
586 dir->ref_regular |= ind->ref_regular;
587 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
588 dir->needs_plt |= ind->needs_plt;
589 dir->pointer_equality_needed |= ind->pointer_equality_needed;
590 }
d40d037c
AJ		 591 else
592 _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
8d88c4ca
NC		 593}
594
b34976b6 595static bfd_boolean
27482721 596elf64_x86_64_mkobject (bfd *abfd)
8d88c4ca 597{
bffbf940
JJ		 598 bfd_size_type amt = sizeof (struct elf64_x86_64_obj_tdata);
599 abfd->tdata.any = bfd_zalloc (abfd, amt);
600 if (abfd->tdata.any == NULL)
b34976b6
AM		 601 return FALSE;
602 return TRUE;
bffbf940
JJ		 603}
604
b34976b6 605static bfd_boolean
27482721 606elf64_x86_64_elf_object_p (bfd *abfd)
bffbf940 607{
8d88c4ca
NC		 608 /* Set the right machine number for an x86-64 elf64 file. */
609 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64);
b34976b6 610 return TRUE;
8d88c4ca
NC		 611}
612
bffbf940 613static int
27482721 614elf64_x86_64_tls_transition (struct bfd_link_info *info, int r_type, int is_local)
bffbf940
JJ		 615{
616 if (info->shared)
617 return r_type;
618
619 switch (r_type)
620 {
621 case R_X86_64_TLSGD:
622 case R_X86_64_GOTTPOFF:
623 if (is_local)
624 return R_X86_64_TPOFF32;
625 return R_X86_64_GOTTPOFF;
626 case R_X86_64_TLSLD:
627 return R_X86_64_TPOFF32;
628 }
629
630 return r_type;
631}
632
70256ad8 633/* Look through the relocs for a section during the first phase, and
c434dee6
AJ		 634 calculate needed space in the global offset table, procedure
635 linkage table, and dynamic reloc sections. */
70256ad8 636
b34976b6 637static bfd_boolean
27482721
AJ		 638elf64_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, asection *sec,
639 const Elf_Internal_Rela *relocs)
70256ad8 640{
c434dee6 641 struct elf64_x86_64_link_hash_table *htab;
70256ad8
AJ		 642 Elf_Internal_Shdr *symtab_hdr;
643 struct elf_link_hash_entry **sym_hashes;
70256ad8
AJ		 644 const Elf_Internal_Rela *rel;
645 const Elf_Internal_Rela *rel_end;
70256ad8
AJ		 646 asection *sreloc;
647
1049f94e 648 if (info->relocatable)
b34976b6 649 return TRUE;
70256ad8 650
c434dee6 651 htab = elf64_x86_64_hash_table (info);
70256ad8
AJ		 652 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
653 sym_hashes = elf_sym_hashes (abfd);
70256ad8 654
c434dee6
AJ		 655 sreloc = NULL;
656
70256ad8
AJ		 657 rel_end = relocs + sec->reloc_count;
658 for (rel = relocs; rel < rel_end; rel++)
659 {
bffbf940 660 unsigned int r_type;
70256ad8
AJ		 661 unsigned long r_symndx;
662 struct elf_link_hash_entry *h;
663
664 r_symndx = ELF64_R_SYM (rel->r_info);
bffbf940 665 r_type = ELF64_R_TYPE (rel->r_info);
c434dee6
AJ		 666
667 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
668 {
d003868e
AM		 669 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
670 abfd, r_symndx);
b34976b6 671 return FALSE;
c434dee6
AJ		 672 }
673
70256ad8
AJ		 674 if (r_symndx < symtab_hdr->sh_info)
675 h = NULL;
676 else
71cb9464
L		 677 {
678 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
679 while (h->root.type == bfd_link_hash_indirect
680 || h->root.type == bfd_link_hash_warning)
681 h = (struct elf_link_hash_entry *) h->root.u.i.link;
682 }
70256ad8 683
bffbf940
JJ		 684 r_type = elf64_x86_64_tls_transition (info, r_type, h == NULL);
685 switch (r_type)
70256ad8 686 {
bffbf940
JJ		 687 case R_X86_64_TLSLD:
688 htab->tls_ld_got.refcount += 1;
689 goto create_got;
690
691 case R_X86_64_TPOFF32:
692 if (info->shared)
70256ad8 693 {
bffbf940 694 (*_bfd_error_handler)
d003868e
AM		 695 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
696 abfd,
6610a52d
L		 697 x86_64_elf_howto_table[r_type].name,
698 (h) ? h->root.root.string : "a local symbol");
bffbf940 699 bfd_set_error (bfd_error_bad_value);
b34976b6 700 return FALSE;
70256ad8 701 }
bffbf940 702 break;
c434dee6 703
bffbf940
JJ		 704 case R_X86_64_GOTTPOFF:
705 if (info->shared)
706 info->flags |= DF_STATIC_TLS;
707 /* Fall through */
70256ad8 708
bffbf940
JJ		 709 case R_X86_64_GOT32:
710 case R_X86_64_GOTPCREL:
711 case R_X86_64_TLSGD:
712 /* This symbol requires a global offset table entry. */
713 {
714 int tls_type, old_tls_type;
715
716 switch (r_type)
717 {
718 default: tls_type = GOT_NORMAL; break;
719 case R_X86_64_TLSGD: tls_type = GOT_TLS_GD; break;
720 case R_X86_64_GOTTPOFF: tls_type = GOT_TLS_IE; break;
721 }
722
723 if (h != NULL)
724 {
725 h->got.refcount += 1;
726 old_tls_type = elf64_x86_64_hash_entry (h)->tls_type;
727 }
728 else
729 {
730 bfd_signed_vma *local_got_refcounts;
731
732 /* This is a global offset table entry for a local symbol. */
733 local_got_refcounts = elf_local_got_refcounts (abfd);
734 if (local_got_refcounts == NULL)
735 {
736 bfd_size_type size;
737
738 size = symtab_hdr->sh_info;
739 size *= sizeof (bfd_signed_vma) + sizeof (char);
740 local_got_refcounts = ((bfd_signed_vma *)
741 bfd_zalloc (abfd, size));
742 if (local_got_refcounts == NULL)
b34976b6 743 return FALSE;
bffbf940
JJ		 744 elf_local_got_refcounts (abfd) = local_got_refcounts;
745 elf64_x86_64_local_got_tls_type (abfd)
746 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
747 }
748 local_got_refcounts[r_symndx] += 1;
749 old_tls_type
750 = elf64_x86_64_local_got_tls_type (abfd) [r_symndx];
751 }
752
753 /* If a TLS symbol is accessed using IE at least once,
754 there is no point to use dynamic model for it. */
755 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
756 && (old_tls_type != GOT_TLS_GD || tls_type != GOT_TLS_IE))
757 {
758 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
759 tls_type = old_tls_type;
760 else
761 {
762 (*_bfd_error_handler)
d003868e
AM		 763 (_("%B: %s' accessed both as normal and thread local symbol"),
764 abfd, h ? h->root.root.string : "<local>");
b34976b6 765 return FALSE;
bffbf940
JJ		 766 }
767 }
768
769 if (old_tls_type != tls_type)
770 {
771 if (h != NULL)
772 elf64_x86_64_hash_entry (h)->tls_type = tls_type;
773 else
774 elf64_x86_64_local_got_tls_type (abfd) [r_symndx] = tls_type;
775 }
776 }
c434dee6
AJ		 777 /* Fall through */
778
d6ab8113
JB		 779 case R_X86_64_GOTOFF64:
780 case R_X86_64_GOTPC32:
bffbf940 781 create_got:
c434dee6
AJ		 782 if (htab->sgot == NULL)
783 {
784 if (htab->elf.dynobj == NULL)
785 htab->elf.dynobj = abfd;
786 if (!create_got_section (htab->elf.dynobj, info))
b34976b6 787 return FALSE;
c434dee6 788 }
70256ad8
AJ		 789 break;
790
791 case R_X86_64_PLT32:
792 /* This symbol requires a procedure linkage table entry. We
407443a3
AJ		 793 actually build the entry in adjust_dynamic_symbol,
794 because this might be a case of linking PIC code which is
795 never referenced by a dynamic object, in which case we
796 don't need to generate a procedure linkage table entry
797 after all. */
70256ad8
AJ		 798
799 /* If this is a local symbol, we resolve it directly without
407443a3 800 creating a procedure linkage table entry. */
70256ad8
AJ		 801 if (h == NULL)
802 continue;
803
f5385ebf 804 h->needs_plt = 1;
51b64d56 805 h->plt.refcount += 1;
70256ad8
AJ		 806 break;
807
cc78d0af
AJ		 808 case R_X86_64_8:
809 case R_X86_64_16:
70256ad8
AJ		 810 case R_X86_64_32:
811 case R_X86_64_32S:
1b71fb54
AJ		 812 /* Let's help debug shared library creation. These relocs
813 cannot be used in shared libs. Don't error out for
814 sections we don't care about, such as debug sections or
815 non-constant sections. */
816 if (info->shared
817 && (sec->flags & SEC_ALLOC) != 0
818 && (sec->flags & SEC_READONLY) != 0)
819 {
820 (*_bfd_error_handler)
d003868e
AM		 821 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
822 abfd,
6610a52d
L		 823 x86_64_elf_howto_table[r_type].name,
824 (h) ? h->root.root.string : "a local symbol");
1b71fb54 825 bfd_set_error (bfd_error_bad_value);
b34976b6 826 return FALSE;
1b71fb54
AJ		 827 }
828 /* Fall through. */
829
c434dee6
AJ		 830 case R_X86_64_PC8:
831 case R_X86_64_PC16:
70256ad8 832 case R_X86_64_PC32:
d6ab8113 833 case R_X86_64_PC64:
1b71fb54 834 case R_X86_64_64:
c434dee6
AJ		 835 if (h != NULL && !info->shared)
836 {
837 /* If this reloc is in a read-only section, we might
838 need a copy reloc. We can't check reliably at this
839 stage whether the section is read-only, as input
840 sections have not yet been mapped to output sections.
841 Tentatively set the flag for now, and correct in
842 adjust_dynamic_symbol. */
f5385ebf 843 h->non_got_ref = 1;
c434dee6
AJ		 844
845 /* We may need a .plt entry if the function this reloc
846 refers to is in a shared lib. */
847 h->plt.refcount += 1;
d6ab8113 848 if (r_type != R_X86_64_PC32 && r_type != R_X86_64_PC64)
f5385ebf 849 h->pointer_equality_needed = 1;
c434dee6 850 }
70256ad8
AJ		 851
852 /* If we are creating a shared library, and this is a reloc
853 against a global symbol, or a non PC relative reloc
854 against a local symbol, then we need to copy the reloc
855 into the shared library. However, if we are linking with
856 -Bsymbolic, we do not need to copy a reloc against a
857 global symbol which is defined in an object we are
407443a3 858 including in the link (i.e., DEF_REGULAR is set). At
70256ad8
AJ		 859 this point we have not seen all the input files, so it is
860 possible that DEF_REGULAR is not set now but will be set
c434dee6
AJ		 861 later (it is never cleared). In case of a weak definition,
862 DEF_REGULAR may be cleared later by a strong definition in
863 a shared library. We account for that possibility below by
864 storing information in the relocs_copied field of the hash
865 table entry. A similar situation occurs when creating
866 shared libraries and symbol visibility changes render the
867 symbol local.
868
869 If on the other hand, we are creating an executable, we
870 may need to keep relocations for symbols satisfied by a
871 dynamic library if we manage to avoid copy relocs for the
872 symbol. */
873 if ((info->shared
874 && (sec->flags & SEC_ALLOC) != 0
bffbf940
JJ		 875 && (((r_type != R_X86_64_PC8)
876 && (r_type != R_X86_64_PC16)
d6ab8113
JB		 877 && (r_type != R_X86_64_PC32)
878 && (r_type != R_X86_64_PC64))
c434dee6
AJ		 879 || (h != NULL
880 && (! info->symbolic
881 || h->root.type == bfd_link_hash_defweak
f5385ebf 882 || !h->def_regular))))
d40d037c
AJ		 883 || (ELIMINATE_COPY_RELOCS
884 && !info->shared
c434dee6
AJ		 885 && (sec->flags & SEC_ALLOC) != 0
886 && h != NULL
887 && (h->root.type == bfd_link_hash_defweak
f5385ebf 888 || !h->def_regular)))
70256ad8 889 {
c434dee6
AJ		 890 struct elf64_x86_64_dyn_relocs *p;
891 struct elf64_x86_64_dyn_relocs **head;
892
893 /* We must copy these reloc types into the output file.
894 Create a reloc section in dynobj and make room for
895 this reloc. */
70256ad8
AJ		 896 if (sreloc == NULL)
897 {
898 const char *name;
c434dee6 899 bfd *dynobj;
70256ad8
AJ		 900
901 name = (bfd_elf_string_from_elf_section
902 (abfd,
903 elf_elfheader (abfd)->e_shstrndx,
904 elf_section_data (sec)->rel_hdr.sh_name));
905 if (name == NULL)
b34976b6 906 return FALSE;
70256ad8 907
c434dee6
AJ		 908 if (strncmp (name, ".rela", 5) != 0
909 || strcmp (bfd_get_section_name (abfd, sec),
910 name + 5) != 0)
911 {
912 (*_bfd_error_handler)
d003868e
AM		 913 (_("%B: bad relocation section name `%s\'"),
914 abfd, name);
c434dee6
AJ		 915 }
916
917 if (htab->elf.dynobj == NULL)
918 htab->elf.dynobj = abfd;
919
920 dynobj = htab->elf.dynobj;
70256ad8
AJ		 921
922 sreloc = bfd_get_section_by_name (dynobj, name);
923 if (sreloc == NULL)
924 {
925 flagword flags;
926
70256ad8
AJ		 927 flags = (SEC_HAS_CONTENTS | SEC_READONLY
928 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
929 if ((sec->flags & SEC_ALLOC) != 0)
930 flags |= SEC_ALLOC | SEC_LOAD;
3496cb2a
L		 931 sreloc = bfd_make_section_with_flags (dynobj,
932 name,
933 flags);
70256ad8 934 if (sreloc == NULL
cc78d0af 935 || ! bfd_set_section_alignment (dynobj, sreloc, 3))
b34976b6 936 return FALSE;
70256ad8 937 }
c434dee6 938 elf_section_data (sec)->sreloc = sreloc;
70256ad8
AJ		 939 }
940
c434dee6
AJ		 941 /* If this is a global symbol, we count the number of
942 relocations we need for this symbol. */
943 if (h != NULL)
70256ad8 944 {
c434dee6
AJ		 945 head = &((struct elf64_x86_64_link_hash_entry *) h)->dyn_relocs;
946 }
947 else
948 {
949 /* Track dynamic relocs needed for local syms too.
950 We really need local syms available to do this
951 easily. Oh well. */
952
953 asection *s;
954 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
955 sec, r_symndx);
956 if (s == NULL)
b34976b6 957 return FALSE;
70256ad8 958
c434dee6
AJ		 959 head = ((struct elf64_x86_64_dyn_relocs **)
960 &elf_section_data (s)->local_dynrel);
961 }
70256ad8 962
c434dee6
AJ		 963 p = *head;
964 if (p == NULL || p->sec != sec)
965 {
966 bfd_size_type amt = sizeof *p;
967 p = ((struct elf64_x86_64_dyn_relocs *)
968 bfd_alloc (htab->elf.dynobj, amt));
70256ad8 969 if (p == NULL)
b34976b6 970 return FALSE;
c434dee6
AJ		 971 p->next = *head;
972 *head = p;
973 p->sec = sec;
974 p->count = 0;
975 p->pc_count = 0;
70256ad8 976 }
c434dee6
AJ		 977
978 p->count += 1;
bffbf940
JJ		 979 if (r_type == R_X86_64_PC8
980 || r_type == R_X86_64_PC16
d6ab8113
JB		 981 || r_type == R_X86_64_PC32
982 || r_type == R_X86_64_PC64)
c434dee6 983 p->pc_count += 1;
70256ad8
AJ		 984 }
985 break;
fe4770f4
AJ		 986
987 /* This relocation describes the C++ object vtable hierarchy.
988 Reconstruct it for later use during GC. */
989 case R_X86_64_GNU_VTINHERIT:
c152c796 990 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
b34976b6 991 return FALSE;
fe4770f4
AJ		 992 break;
993
994 /* This relocation describes which C++ vtable entries are actually
995 used. Record for later use during GC. */
996 case R_X86_64_GNU_VTENTRY:
c152c796 997 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
b34976b6 998 return FALSE;
fe4770f4 999 break;
c434dee6
AJ		 1000
1001 default:
1002 break;
70256ad8
AJ		 1003 }
1004 }
1005
b34976b6 1006 return TRUE;
70256ad8
AJ		 1007}
1008
1009/* Return the section that should be marked against GC for a given
407443a3 1010 relocation. */
70256ad8
AJ		 1011
1012static asection *
27482721
AJ		 1013elf64_x86_64_gc_mark_hook (asection *sec,
1014 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1015 Elf_Internal_Rela *rel,
1016 struct elf_link_hash_entry *h,
1017 Elf_Internal_Sym *sym)
70256ad8
AJ		 1018{
1019 if (h != NULL)
1020 {
fe4770f4 1021 switch (ELF64_R_TYPE (rel->r_info))
70256ad8 1022 {
fe4770f4
AJ		 1023 case R_X86_64_GNU_VTINHERIT:
1024 case R_X86_64_GNU_VTENTRY:
1025 break;
70256ad8
AJ		 1026
1027 default:
fe4770f4
AJ		 1028 switch (h->root.type)
1029 {
1030 case bfd_link_hash_defined:
1031 case bfd_link_hash_defweak:
1032 return h->root.u.def.section;
1033
1034 case bfd_link_hash_common:
1035 return h->root.u.c.p->section;
1036
1037 default:
1038 break;
1039 }
70256ad8
AJ		 1040 }
1041 }
1042 else
1e2f5b6e 1043 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
70256ad8
AJ		 1044
1045 return NULL;
1046}
1047
407443a3 1048/* Update the got entry reference counts for the section being removed. */
70256ad8 1049
b34976b6 1050static bfd_boolean
27482721
AJ		 1051elf64_x86_64_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1052 asection *sec, const Elf_Internal_Rela *relocs)
70256ad8
AJ		 1053{
1054 Elf_Internal_Shdr *symtab_hdr;
1055 struct elf_link_hash_entry **sym_hashes;
1056 bfd_signed_vma *local_got_refcounts;
1057 const Elf_Internal_Rela *rel, *relend;
c434dee6
AJ		 1058
1059 elf_section_data (sec)->local_dynrel = NULL;
70256ad8
AJ		 1060
1061 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1062 sym_hashes = elf_sym_hashes (abfd);
1063 local_got_refcounts = elf_local_got_refcounts (abfd);
1064
70256ad8
AJ		 1065 relend = relocs + sec->reloc_count;
1066 for (rel = relocs; rel < relend; rel++)
26e41594
AM		 1067 {
1068 unsigned long r_symndx;
1069 unsigned int r_type;
1070 struct elf_link_hash_entry *h = NULL;
70256ad8 1071
26e41594
AM		 1072 r_symndx = ELF64_R_SYM (rel->r_info);
1073 if (r_symndx >= symtab_hdr->sh_info)
1074 {
1075 struct elf64_x86_64_link_hash_entry *eh;
1076 struct elf64_x86_64_dyn_relocs **pp;
1077 struct elf64_x86_64_dyn_relocs *p;
c434dee6 1078
26e41594 1079 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3eb128b2
AM		 1080 while (h->root.type == bfd_link_hash_indirect
1081 || h->root.type == bfd_link_hash_warning)
1082 h = (struct elf_link_hash_entry *) h->root.u.i.link;
26e41594 1083 eh = (struct elf64_x86_64_link_hash_entry *) h;
c434dee6 1084
26e41594
AM		 1085 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1086 if (p->sec == sec)
1087 {
1088 /* Everything must go for SEC. */
1089 *pp = p->next;
1090 break;
1091 }
1092 }
c434dee6 1093
26e41594
AM		 1094 r_type = ELF64_R_TYPE (rel->r_info);
1095 r_type = elf64_x86_64_tls_transition (info, r_type, h != NULL);
1096 switch (r_type)
1097 {
1098 case R_X86_64_TLSLD:
1099 if (elf64_x86_64_hash_table (info)->tls_ld_got.refcount > 0)
1100 elf64_x86_64_hash_table (info)->tls_ld_got.refcount -= 1;
1101 break;
c434dee6 1102
26e41594
AM		 1103 case R_X86_64_TLSGD:
1104 case R_X86_64_GOTTPOFF:
1105 case R_X86_64_GOT32:
1106 case R_X86_64_GOTPCREL:
1107 if (h != NULL)
1108 {
1109 if (h->got.refcount > 0)
1110 h->got.refcount -= 1;
1111 }
1112 else if (local_got_refcounts != NULL)
1113 {
1114 if (local_got_refcounts[r_symndx] > 0)
1115 local_got_refcounts[r_symndx] -= 1;
1116 }
1117 break;
c434dee6 1118
26e41594
AM		 1119 case R_X86_64_8:
1120 case R_X86_64_16:
1121 case R_X86_64_32:
1122 case R_X86_64_64:
1123 case R_X86_64_32S:
1124 case R_X86_64_PC8:
1125 case R_X86_64_PC16:
1126 case R_X86_64_PC32:
d6ab8113 1127 case R_X86_64_PC64:
26e41594
AM		 1128 if (info->shared)
1129 break;
1130 /* Fall thru */
c434dee6 1131
26e41594
AM		 1132 case R_X86_64_PLT32:
1133 if (h != NULL)
1134 {
1135 if (h->plt.refcount > 0)
1136 h->plt.refcount -= 1;
1137 }
1138 break;
70256ad8 1139
26e41594
AM		 1140 default:
1141 break;
1142 }
1143 }
70256ad8 1144
b34976b6 1145 return TRUE;
70256ad8
AJ		 1146}
1147
1148/* Adjust a symbol defined by a dynamic object and referenced by a
1149 regular object. The current definition is in some section of the
1150 dynamic object, but we're not including those sections. We have to
1151 change the definition to something the rest of the link can
407443a3 1152 understand. */
70256ad8 1153
b34976b6 1154static bfd_boolean
27482721
AJ		 1155elf64_x86_64_adjust_dynamic_symbol (struct bfd_link_info *info,
1156 struct elf_link_hash_entry *h)
70256ad8 1157{
c434dee6 1158 struct elf64_x86_64_link_hash_table *htab;
70256ad8
AJ		 1159 asection *s;
1160 unsigned int power_of_two;
1161
70256ad8
AJ		 1162 /* If this is a function, put it in the procedure linkage table. We
1163 will fill in the contents of the procedure linkage table later,
1164 when we know the address of the .got section. */
1165 if (h->type == STT_FUNC
f5385ebf 1166 || h->needs_plt)
70256ad8 1167 {
c434dee6 1168 if (h->plt.refcount <= 0
27482721
AJ		 1169 || SYMBOL_CALLS_LOCAL (info, h)
1170 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1171 && h->root.type == bfd_link_hash_undefweak))
70256ad8 1172 {
70256ad8
AJ		 1173 /* This case can occur if we saw a PLT32 reloc in an input
1174 file, but the symbol was never referred to by a dynamic
1175 object, or if all references were garbage collected. In
1176 such a case, we don't actually need to build a procedure
1177 linkage table, and we can just do a PC32 reloc instead. */
70256ad8 1178 h->plt.offset = (bfd_vma) -1;
f5385ebf 1179 h->needs_plt = 0;
70256ad8
AJ		 1180 }
1181
b34976b6 1182 return TRUE;
70256ad8 1183 }
bbd7ec4a 1184 else
c434dee6
AJ		 1185 /* It's possible that we incorrectly decided a .plt reloc was
1186 needed for an R_X86_64_PC32 reloc to a non-function sym in
1187 check_relocs. We can't decide accurately between function and
1188 non-function syms in check-relocs; Objects loaded later in
1189 the link may change h->type. So fix it now. */
bbd7ec4a 1190 h->plt.offset = (bfd_vma) -1;
70256ad8
AJ		 1191
1192 /* If this is a weak symbol, and there is a real definition, the
1193 processor independent code will have arranged for us to see the
407443a3 1194 real definition first, and we can just use the same value. */
f6e332e6 1195 if (h->u.weakdef != NULL)
70256ad8 1196 {
f6e332e6
AM		 1197 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1198 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1199 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1200 h->root.u.def.value = h->u.weakdef->root.u.def.value;
d40d037c 1201 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
f6e332e6 1202 h->non_got_ref = h->u.weakdef->non_got_ref;
b34976b6 1203 return TRUE;
70256ad8
AJ		 1204 }
1205
1206 /* This is a reference to a symbol defined by a dynamic object which
407443a3 1207 is not a function. */
70256ad8
AJ		 1208
1209 /* If we are creating a shared library, we must presume that the
1210 only references to the symbol are via the global offset table.
1211 For such cases we need not do anything here; the relocations will
407443a3 1212 be handled correctly by relocate_section. */
70256ad8 1213 if (info->shared)
b34976b6 1214 return TRUE;
70256ad8
AJ		 1215
1216 /* If there are no references to this symbol that do not use the
1217 GOT, we don't need to generate a copy reloc. */
f5385ebf 1218 if (!h->non_got_ref)
b34976b6 1219 return TRUE;
70256ad8 1220
c434dee6
AJ		 1221 /* If -z nocopyreloc was given, we won't generate them either. */
1222 if (info->nocopyreloc)
1223 {
f5385ebf 1224 h->non_got_ref = 0;
b34976b6 1225 return TRUE;
c434dee6
AJ		 1226 }
1227
d40d037c 1228 if (ELIMINATE_COPY_RELOCS)
c434dee6 1229 {
d40d037c
AJ		 1230 struct elf64_x86_64_link_hash_entry * eh;
1231 struct elf64_x86_64_dyn_relocs *p;
c434dee6 1232
d40d037c
AJ		 1233 eh = (struct elf64_x86_64_link_hash_entry *) h;
1234 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1235 {
1236 s = p->sec->output_section;
1237 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1238 break;
1239 }
1240
1241 /* If we didn't find any dynamic relocs in read-only sections, then
1242 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1243 if (p == NULL)
1244 {
f5385ebf 1245 h->non_got_ref = 0;
d40d037c
AJ		 1246 return TRUE;
1247 }
c434dee6
AJ		 1248 }
1249
70256ad8 1250 /* We must allocate the symbol in our .dynbss section, which will
407443a3 1251 become part of the .bss section of the executable. There will be
70256ad8
AJ		 1252 an entry for this symbol in the .dynsym section. The dynamic
1253 object will contain position independent code, so all references
1254 from the dynamic object to this symbol will go through the global
1255 offset table. The dynamic linker will use the .dynsym entry to
1256 determine the address it must put in the global offset table, so
1257 both the dynamic object and the regular object will refer to the
1258 same memory location for the variable. */
1259
c434dee6 1260 htab = elf64_x86_64_hash_table (info);
70256ad8
AJ		 1261
1262 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
1263 to copy the initial value out of the dynamic object and into the
cedb70c5 1264 runtime process image. */
70256ad8
AJ		 1265 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1266 {
eea6121a 1267 htab->srelbss->size += sizeof (Elf64_External_Rela);
f5385ebf 1268 h->needs_copy = 1;
70256ad8
AJ		 1269 }
1270
1271 /* We need to figure out the alignment required for this symbol. I
407443a3 1272 have no idea how ELF linkers handle this. 16-bytes is the size
70256ad8
AJ		 1273 of the largest type that requires hard alignment -- long double. */
1274 /* FIXME: This is VERY ugly. Should be fixed for all architectures using
1275 this construct. */
1276 power_of_two = bfd_log2 (h->size);
1277 if (power_of_two > 4)
1278 power_of_two = 4;
1279
1280 /* Apply the required alignment. */
c434dee6 1281 s = htab->sdynbss;
eea6121a 1282 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
c434dee6 1283 if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
70256ad8 1284 {
c434dee6 1285 if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
b34976b6 1286 return FALSE;
70256ad8
AJ		 1287 }
1288
1289 /* Define the symbol as being at this point in the section. */
1290 h->root.u.def.section = s;
eea6121a 1291 h->root.u.def.value = s->size;
70256ad8
AJ		 1292
1293 /* Increment the section size to make room for the symbol. */
eea6121a 1294 s->size += h->size;
70256ad8 1295
b34976b6 1296 return TRUE;
70256ad8
AJ		 1297}
1298
c434dee6
AJ		 1299/* Allocate space in .plt, .got and associated reloc sections for
1300 dynamic relocs. */
1301
b34976b6 1302static bfd_boolean
27482721 1303allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
c434dee6
AJ		 1304{
1305 struct bfd_link_info *info;
1306 struct elf64_x86_64_link_hash_table *htab;
1307 struct elf64_x86_64_link_hash_entry *eh;
1308 struct elf64_x86_64_dyn_relocs *p;
1309
e92d460e 1310 if (h->root.type == bfd_link_hash_indirect)
b34976b6 1311 return TRUE;
c434dee6 1312
e92d460e
AM		 1313 if (h->root.type == bfd_link_hash_warning)
1314 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1315
c434dee6
AJ		 1316 info = (struct bfd_link_info *) inf;
1317 htab = elf64_x86_64_hash_table (info);
1318
1319 if (htab->elf.dynamic_sections_created
27482721 1320 && h->plt.refcount > 0)
c434dee6
AJ		 1321 {
1322 /* Make sure this symbol is output as a dynamic symbol.
1323 Undefined weak syms won't yet be marked as dynamic. */
1324 if (h->dynindx == -1
f5385ebf 1325 && !h->forced_local)
c434dee6 1326 {
c152c796 1327 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 1328 return FALSE;
c434dee6
AJ		 1329 }
1330
27482721
AJ		 1331 if (info->shared
1332 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
c434dee6
AJ		 1333 {
1334 asection *s = htab->splt;
1335
1336 /* If this is the first .plt entry, make room for the special
1337 first entry. */
eea6121a
AM		 1338 if (s->size == 0)
1339 s->size += PLT_ENTRY_SIZE;
c434dee6 1340
eea6121a 1341 h->plt.offset = s->size;
c434dee6
AJ		 1342
1343 /* If this symbol is not defined in a regular file, and we are
1344 not generating a shared library, then set the symbol to this
1345 location in the .plt. This is required to make function
1346 pointers compare as equal between the normal executable and
1347 the shared library. */
1348 if (! info->shared
f5385ebf 1349 && !h->def_regular)
c434dee6
AJ		 1350 {
1351 h->root.u.def.section = s;
1352 h->root.u.def.value = h->plt.offset;
1353 }
1354
1355 /* Make room for this entry. */
eea6121a 1356 s->size += PLT_ENTRY_SIZE;
c434dee6
AJ		 1357
1358 /* We also need to make an entry in the .got.plt section, which
1359 will be placed in the .got section by the linker script. */
eea6121a 1360 htab->sgotplt->size += GOT_ENTRY_SIZE;
c434dee6
AJ		 1361
1362 /* We also need to make an entry in the .rela.plt section. */
eea6121a 1363 htab->srelplt->size += sizeof (Elf64_External_Rela);
c434dee6
AJ		 1364 }
1365 else
1366 {
1367 h->plt.offset = (bfd_vma) -1;
f5385ebf 1368 h->needs_plt = 0;
c434dee6
AJ		 1369 }
1370 }
1371 else
1372 {
1373 h->plt.offset = (bfd_vma) -1;
f5385ebf 1374 h->needs_plt = 0;
c434dee6
AJ		 1375 }
1376
bffbf940
JJ		 1377 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
1378 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
1379 if (h->got.refcount > 0
1380 && !info->shared
1381 && h->dynindx == -1
1382 && elf64_x86_64_hash_entry (h)->tls_type == GOT_TLS_IE)
1383 h->got.offset = (bfd_vma) -1;
1384 else if (h->got.refcount > 0)
c434dee6
AJ		 1385 {
1386 asection *s;
b34976b6 1387 bfd_boolean dyn;
bffbf940 1388 int tls_type = elf64_x86_64_hash_entry (h)->tls_type;
c434dee6
AJ		 1389
1390 /* Make sure this symbol is output as a dynamic symbol.
1391 Undefined weak syms won't yet be marked as dynamic. */
1392 if (h->dynindx == -1
f5385ebf 1393 && !h->forced_local)
c434dee6 1394 {
c152c796 1395 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 1396 return FALSE;
c434dee6
AJ		 1397 }
1398
1399 s = htab->sgot;
eea6121a
AM		 1400 h->got.offset = s->size;
1401 s->size += GOT_ENTRY_SIZE;
bffbf940
JJ		 1402 /* R_X86_64_TLSGD needs 2 consecutive GOT slots. */
1403 if (tls_type == GOT_TLS_GD)
eea6121a 1404 s->size += GOT_ENTRY_SIZE;
c434dee6 1405 dyn = htab->elf.dynamic_sections_created;
bffbf940
JJ		 1406 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
1407 and two if global.
1408 R_X86_64_GOTTPOFF needs one dynamic relocation. */
1409 if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1410 || tls_type == GOT_TLS_IE)
eea6121a 1411 htab->srelgot->size += sizeof (Elf64_External_Rela);
bffbf940 1412 else if (tls_type == GOT_TLS_GD)
eea6121a 1413 htab->srelgot->size += 2 * sizeof (Elf64_External_Rela);
4bc6e03a
AJ		 1414 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1415 || h->root.type != bfd_link_hash_undefweak)
27482721
AJ		 1416 && (info->shared
1417 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
eea6121a 1418 htab->srelgot->size += sizeof (Elf64_External_Rela);
c434dee6
AJ		 1419 }
1420 else
1421 h->got.offset = (bfd_vma) -1;
1422
1423 eh = (struct elf64_x86_64_link_hash_entry *) h;
1424 if (eh->dyn_relocs == NULL)
b34976b6 1425 return TRUE;
c434dee6
AJ		 1426
1427 /* In the shared -Bsymbolic case, discard space allocated for
1428 dynamic pc-relative relocs against symbols which turn out to be
1429 defined in regular objects. For the normal shared case, discard
1430 space for pc-relative relocs that have become local due to symbol
1431 visibility changes. */
1432
1433 if (info->shared)
1434 {
27482721
AJ		 1435 /* Relocs that use pc_count are those that appear on a call
1436 insn, or certain REL relocs that can generated via assembly.
1437 We want calls to protected symbols to resolve directly to the
1438 function rather than going via the plt. If people want
1439 function pointer comparisons to work as expected then they
1440 should avoid writing weird assembly. */
1441 if (SYMBOL_CALLS_LOCAL (info, h))
c434dee6
AJ		 1442 {
1443 struct elf64_x86_64_dyn_relocs **pp;
1444
1445 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1446 {
1447 p->count -= p->pc_count;
1448 p->pc_count = 0;
1449 if (p->count == 0)
1450 *pp = p->next;
1451 else
1452 pp = &p->next;
1453 }
1454 }
4e795f50
AM		 1455
1456 /* Also discard relocs on undefined weak syms with non-default
1457 visibility. */
1458 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1459 && h->root.type == bfd_link_hash_undefweak)
1460 eh->dyn_relocs = NULL;
c434dee6 1461 }
d40d037c 1462 else if (ELIMINATE_COPY_RELOCS)
c434dee6
AJ		 1463 {
1464 /* For the non-shared case, discard space for relocs against
1465 symbols which turn out to need copy relocs or are not
1466 dynamic. */
1467
f5385ebf
AM		 1468 if (!h->non_got_ref
1469 && ((h->def_dynamic
1470 && !h->def_regular)
c434dee6
AJ		 1471 || (htab->elf.dynamic_sections_created
1472 && (h->root.type == bfd_link_hash_undefweak
1473 || h->root.type == bfd_link_hash_undefined))))
1474 {
1475 /* Make sure this symbol is output as a dynamic symbol.
1476 Undefined weak syms won't yet be marked as dynamic. */
1477 if (h->dynindx == -1
f5385ebf 1478 && !h->forced_local)
c434dee6 1479 {
c152c796 1480 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 1481 return FALSE;
c434dee6
AJ		 1482 }
1483
1484 /* If that succeeded, we know we'll be keeping all the
1485 relocs. */
1486 if (h->dynindx != -1)
1487 goto keep;
1488 }
1489
1490 eh->dyn_relocs = NULL;
1491
1492 keep: ;
1493 }
1494
1495 /* Finally, allocate space. */
1496 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1497 {
1498 asection *sreloc = elf_section_data (p->sec)->sreloc;
eea6121a 1499 sreloc->size += p->count * sizeof (Elf64_External_Rela);
c434dee6
AJ		 1500 }
1501
b34976b6 1502 return TRUE;
c434dee6
AJ		 1503}
1504
1505/* Find any dynamic relocs that apply to read-only sections. */
1506
b34976b6 1507static bfd_boolean
27482721 1508readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
c434dee6
AJ		 1509{
1510 struct elf64_x86_64_link_hash_entry *eh;
1511 struct elf64_x86_64_dyn_relocs *p;
1512
e92d460e
AM		 1513 if (h->root.type == bfd_link_hash_warning)
1514 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1515
c434dee6
AJ		 1516 eh = (struct elf64_x86_64_link_hash_entry *) h;
1517 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1518 {
1519 asection *s = p->sec->output_section;
1520
1521 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1522 {
1523 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1524
1525 info->flags |= DF_TEXTREL;
1526
1527 /* Not an error, just cut short the traversal. */
b34976b6 1528 return FALSE;
c434dee6
AJ		 1529 }
1530 }
b34976b6 1531 return TRUE;
c434dee6
AJ		 1532}
1533
70256ad8
AJ		 1534/* Set the sizes of the dynamic sections. */
1535
b34976b6 1536static bfd_boolean
27482721
AJ		 1537elf64_x86_64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1538 struct bfd_link_info *info)
70256ad8 1539{
c434dee6 1540 struct elf64_x86_64_link_hash_table *htab;
70256ad8
AJ		 1541 bfd *dynobj;
1542 asection *s;
b34976b6 1543 bfd_boolean relocs;
c434dee6 1544 bfd *ibfd;
70256ad8 1545
c434dee6
AJ		 1546 htab = elf64_x86_64_hash_table (info);
1547 dynobj = htab->elf.dynobj;
1548 if (dynobj == NULL)
1549 abort ();
70256ad8 1550
c434dee6 1551 if (htab->elf.dynamic_sections_created)
70256ad8
AJ		 1552 {
1553 /* Set the contents of the .interp section to the interpreter. */
36af4a4e 1554 if (info->executable)
70256ad8
AJ		 1555 {
1556 s = bfd_get_section_by_name (dynobj, ".interp");
c434dee6
AJ		 1557 if (s == NULL)
1558 abort ();
eea6121a 1559 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
70256ad8
AJ		 1560 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1561 }
1562 }
70256ad8 1563
c434dee6
AJ		 1564 /* Set up .got offsets for local syms, and space for local dynamic
1565 relocs. */
1566 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
70256ad8 1567 {
c434dee6
AJ		 1568 bfd_signed_vma *local_got;
1569 bfd_signed_vma *end_local_got;
bffbf940 1570 char *local_tls_type;
c434dee6
AJ		 1571 bfd_size_type locsymcount;
1572 Elf_Internal_Shdr *symtab_hdr;
1573 asection *srel;
70256ad8 1574
c434dee6 1575 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
70256ad8
AJ		 1576 continue;
1577
c434dee6 1578 for (s = ibfd->sections; s != NULL; s = s->next)
70256ad8 1579 {
c434dee6
AJ		 1580 struct elf64_x86_64_dyn_relocs *p;
1581
1582 for (p = *((struct elf64_x86_64_dyn_relocs **)
1583 &elf_section_data (s)->local_dynrel);
1584 p != NULL;
1585 p = p->next)
70256ad8 1586 {
c434dee6
AJ		 1587 if (!bfd_is_abs_section (p->sec)
1588 && bfd_is_abs_section (p->sec->output_section))
1589 {
1590 /* Input section has been discarded, either because
1591 it is a copy of a linkonce section or due to
1592 linker script /DISCARD/, so we'll be discarding
1593 the relocs too. */
1594 }
1595 else if (p->count != 0)
1596 {
1597 srel = elf_section_data (p->sec)->sreloc;
eea6121a 1598 srel->size += p->count * sizeof (Elf64_External_Rela);
c434dee6
AJ		 1599 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1600 info->flags |= DF_TEXTREL;
1601
1602 }
70256ad8
AJ		 1603 }
1604 }
c434dee6
AJ		 1605
1606 local_got = elf_local_got_refcounts (ibfd);
1607 if (!local_got)
1608 continue;
1609
1610 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1611 locsymcount = symtab_hdr->sh_info;
1612 end_local_got = local_got + locsymcount;
bffbf940 1613 local_tls_type = elf64_x86_64_local_got_tls_type (ibfd);
c434dee6
AJ		 1614 s = htab->sgot;
1615 srel = htab->srelgot;
bffbf940 1616 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
70256ad8 1617 {
c434dee6 1618 if (*local_got > 0)
70256ad8 1619 {
eea6121a
AM		 1620 *local_got = s->size;
1621 s->size += GOT_ENTRY_SIZE;
bffbf940 1622 if (*local_tls_type == GOT_TLS_GD)
eea6121a 1623 s->size += GOT_ENTRY_SIZE;
bffbf940
JJ		 1624 if (info->shared
1625 || *local_tls_type == GOT_TLS_GD
1626 || *local_tls_type == GOT_TLS_IE)
eea6121a 1627 srel->size += sizeof (Elf64_External_Rela);
70256ad8
AJ		 1628 }
1629 else
c434dee6
AJ		 1630 *local_got = (bfd_vma) -1;
1631 }
1632 }
70256ad8 1633
bffbf940
JJ		 1634 if (htab->tls_ld_got.refcount > 0)
1635 {
1636 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
1637 relocs. */
eea6121a
AM		 1638 htab->tls_ld_got.offset = htab->sgot->size;
1639 htab->sgot->size += 2 * GOT_ENTRY_SIZE;
1640 htab->srelgot->size += sizeof (Elf64_External_Rela);
bffbf940
JJ		 1641 }
1642 else
1643 htab->tls_ld_got.offset = -1;
1644
c434dee6
AJ		 1645 /* Allocate global sym .plt and .got entries, and space for global
1646 sym dynamic relocs. */
1647 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
1648
1649 /* We now have determined the sizes of the various dynamic sections.
1650 Allocate memory for them. */
b34976b6 1651 relocs = FALSE;
c434dee6
AJ		 1652 for (s = dynobj->sections; s != NULL; s = s->next)
1653 {
1654 if ((s->flags & SEC_LINKER_CREATED) == 0)
1655 continue;
1656
1657 if (s == htab->splt
1658 || s == htab->sgot
75ff4589
L		 1659 || s == htab->sgotplt
1660 || s == htab->sdynbss)
c434dee6
AJ		 1661 {
1662 /* Strip this section if we don't need it; see the
1663 comment below. */
1664 }
1665 else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
1666 {
eea6121a 1667 if (s->size != 0 && s != htab->srelplt)
b34976b6 1668 relocs = TRUE;
c434dee6
AJ		 1669
1670 /* We use the reloc_count field as a counter if we need
1671 to copy relocs into the output file. */
1672 s->reloc_count = 0;
70256ad8 1673 }
c434dee6 1674 else
70256ad8
AJ		 1675 {
1676 /* It's not one of our sections, so don't allocate space. */
1677 continue;
1678 }
1679
eea6121a 1680 if (s->size == 0)
70256ad8 1681 {
c434dee6
AJ		 1682 /* If we don't need this section, strip it from the
1683 output file. This is mostly to handle .rela.bss and
1684 .rela.plt. We must create both sections in
1685 create_dynamic_sections, because they must be created
1686 before the linker maps input sections to output
1687 sections. The linker does that before
1688 adjust_dynamic_symbol is called, and it is that
1689 function which decides whether anything needs to go
1690 into these sections. */
1691
8423293d 1692 s->flags |= SEC_EXCLUDE;
70256ad8
AJ		 1693 continue;
1694 }
1695
c456f082
AM		 1696 if ((s->flags & SEC_HAS_CONTENTS) == 0)
1697 continue;
1698
70256ad8
AJ		 1699 /* Allocate memory for the section contents. We use bfd_zalloc
1700 here in case unused entries are not reclaimed before the
1701 section's contents are written out. This should not happen,
1702 but this way if it does, we get a R_X86_64_NONE reloc instead
1703 of garbage. */
eea6121a 1704 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
c434dee6 1705 if (s->contents == NULL)
b34976b6 1706 return FALSE;
70256ad8
AJ		 1707 }
1708
c434dee6 1709 if (htab->elf.dynamic_sections_created)
70256ad8
AJ		 1710 {
1711 /* Add some entries to the .dynamic section. We fill in the
1712 values later, in elf64_x86_64_finish_dynamic_sections, but we
1713 must add the entries now so that we get the correct size for
407443a3 1714 the .dynamic section. The DT_DEBUG entry is filled in by the
70256ad8 1715 dynamic linker and used by the debugger. */
dc810e39 1716#define add_dynamic_entry(TAG, VAL) \
5a580b3a 1717 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
dc810e39 1718
36af4a4e 1719 if (info->executable)
70256ad8 1720 {
dc810e39 1721 if (!add_dynamic_entry (DT_DEBUG, 0))
b34976b6 1722 return FALSE;
70256ad8
AJ		 1723 }
1724
eea6121a 1725 if (htab->splt->size != 0)
70256ad8 1726 {
dc810e39
AM		 1727 if (!add_dynamic_entry (DT_PLTGOT, 0)
1728 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1729 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1730 || !add_dynamic_entry (DT_JMPREL, 0))
b34976b6 1731 return FALSE;
70256ad8
AJ		 1732 }
1733
1734 if (relocs)
1735 {
dc810e39
AM		 1736 if (!add_dynamic_entry (DT_RELA, 0)
1737 || !add_dynamic_entry (DT_RELASZ, 0)
1738 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
b34976b6 1739 return FALSE;
70256ad8 1740
c434dee6
AJ		 1741 /* If any dynamic relocs apply to a read-only section,
1742 then we need a DT_TEXTREL entry. */
1743 if ((info->flags & DF_TEXTREL) == 0)
1744 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
1745 (PTR) info);
1746
1747 if ((info->flags & DF_TEXTREL) != 0)
1748 {
1749 if (!add_dynamic_entry (DT_TEXTREL, 0))
b34976b6 1750 return FALSE;
c434dee6 1751 }
70256ad8
AJ		 1752 }
1753 }
dc810e39 1754#undef add_dynamic_entry
70256ad8 1755
b34976b6 1756 return TRUE;
70256ad8
AJ		 1757}
1758
bffbf940
JJ		 1759/* Return the base VMA address which should be subtracted from real addresses
1760 when resolving @dtpoff relocation.
1761 This is PT_TLS segment p_vaddr. */
1762
1763static bfd_vma
27482721 1764dtpoff_base (struct bfd_link_info *info)
bffbf940 1765{
e1918d23
AM		 1766 /* If tls_sec is NULL, we should have signalled an error already. */
1767 if (elf_hash_table (info)->tls_sec == NULL)
bffbf940 1768 return 0;
e1918d23 1769 return elf_hash_table (info)->tls_sec->vma;
bffbf940
JJ		 1770}
1771
1772/* Return the relocation value for @tpoff relocation
1773 if STT_TLS virtual address is ADDRESS. */
1774
1775static bfd_vma
27482721 1776tpoff (struct bfd_link_info *info, bfd_vma address)
bffbf940 1777{
e1918d23 1778 struct elf_link_hash_table *htab = elf_hash_table (info);
bffbf940
JJ		 1779
1780 /* If tls_segment is NULL, we should have signalled an error already. */
e1918d23 1781 if (htab->tls_sec == NULL)
bffbf940 1782 return 0;
e1918d23 1783 return address - htab->tls_size - htab->tls_sec->vma;
bffbf940
JJ		 1784}
1785
90f487df
L		 1786/* Is the instruction before OFFSET in CONTENTS a 32bit relative
1787 branch? */
1788
1789static bfd_boolean
1790is_32bit_relative_branch (bfd_byte *contents, bfd_vma offset)
1791{
1792 /* Opcode Instruction
1793 0xe8 call
1794 0xe9 jump
1795 0x0f 0x8x conditional jump */
1796 return ((offset > 0
1797 && (contents [offset - 1] == 0xe8
1798 || contents [offset - 1] == 0xe9))
1799 || (offset > 1
1800 && contents [offset - 2] == 0x0f
1801 && (contents [offset - 1] & 0xf0) == 0x80));
1802}
1803
8d88c4ca
NC		 1804/* Relocate an x86_64 ELF section. */
1805
b34976b6 1806static bfd_boolean
27482721
AJ		 1807elf64_x86_64_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
1808 bfd *input_bfd, asection *input_section,
1809 bfd_byte *contents, Elf_Internal_Rela *relocs,
1810 Elf_Internal_Sym *local_syms,
1811 asection **local_sections)
8d88c4ca 1812{
c434dee6 1813 struct elf64_x86_64_link_hash_table *htab;
8d88c4ca
NC		 1814 Elf_Internal_Shdr *symtab_hdr;
1815 struct elf_link_hash_entry **sym_hashes;
1816 bfd_vma *local_got_offsets;
c434dee6 1817 Elf_Internal_Rela *rel;
8d88c4ca
NC		 1818 Elf_Internal_Rela *relend;
1819
1049f94e 1820 if (info->relocatable)
b34976b6 1821 return TRUE;
b491616a 1822
c434dee6 1823 htab = elf64_x86_64_hash_table (info);
8d88c4ca
NC		 1824 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1825 sym_hashes = elf_sym_hashes (input_bfd);
1826 local_got_offsets = elf_local_got_offsets (input_bfd);
1827
c434dee6 1828 rel = relocs;
8d88c4ca 1829 relend = relocs + input_section->reloc_count;
c434dee6 1830 for (; rel < relend; rel++)
8d88c4ca 1831 {
bffbf940 1832 unsigned int r_type;
8d88c4ca
NC		 1833 reloc_howto_type *howto;
1834 unsigned long r_symndx;
1835 struct elf_link_hash_entry *h;
1836 Elf_Internal_Sym *sym;
1837 asection *sec;
c434dee6 1838 bfd_vma off;
8d88c4ca 1839 bfd_vma relocation;
b34976b6 1840 bfd_boolean unresolved_reloc;
8d88c4ca 1841 bfd_reloc_status_type r;
bffbf940 1842 int tls_type;
8d88c4ca 1843
c434dee6 1844 r_type = ELF64_R_TYPE (rel->r_info);
fe4770f4
AJ		 1845 if (r_type == (int) R_X86_64_GNU_VTINHERIT
1846 || r_type == (int) R_X86_64_GNU_VTENTRY)
1847 continue;
8d88c4ca 1848
bffbf940 1849 if (r_type >= R_X86_64_max)
8da6118f
KH		 1850 {
1851 bfd_set_error (bfd_error_bad_value);
b34976b6 1852 return FALSE;
8da6118f 1853 }
8d88c4ca 1854
b491616a 1855 howto = x86_64_elf_howto_table + r_type;
c434dee6 1856 r_symndx = ELF64_R_SYM (rel->r_info);
8d88c4ca
NC		 1857 h = NULL;
1858 sym = NULL;
1859 sec = NULL;
b34976b6 1860 unresolved_reloc = FALSE;
8d88c4ca 1861 if (r_symndx < symtab_hdr->sh_info)
8da6118f
KH		 1862 {
1863 sym = local_syms + r_symndx;
1864 sec = local_sections[r_symndx];
c434dee6 1865
8517fae7 1866 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
8da6118f 1867 }
8d88c4ca 1868 else
8da6118f 1869 {
560e09e9 1870 bfd_boolean warned;
c434dee6 1871
b2a8e766
AM		 1872 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1873 r_symndx, symtab_hdr, sym_hashes,
1874 h, sec, relocation,
1875 unresolved_reloc, warned);
8da6118f 1876 }
70256ad8
AJ		 1877 /* When generating a shared object, the relocations handled here are
1878 copied into the output file to be resolved at run time. */
1879 switch (r_type)
1880 {
1881 case R_X86_64_GOT32:
1882 /* Relocation is to the entry for this symbol in the global
1883 offset table. */
70256ad8
AJ		 1884 case R_X86_64_GOTPCREL:
1885 /* Use global offset table as symbol value. */
c434dee6
AJ		 1886 if (htab->sgot == NULL)
1887 abort ();
053579d7 1888
51e0a107 1889 if (h != NULL)
70256ad8 1890 {
b34976b6 1891 bfd_boolean dyn;
c434dee6
AJ		 1892
1893 off = h->got.offset;
1894 dyn = htab->elf.dynamic_sections_created;
51e0a107 1895
27482721 1896 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
51e0a107 1897 || (info->shared
27482721 1898 && SYMBOL_REFERENCES_LOCAL (info, h))
4bc6e03a
AJ		 1899 || (ELF_ST_VISIBILITY (h->other)
1900 && h->root.type == bfd_link_hash_undefweak))
51e0a107
JH		 1901 {
1902 /* This is actually a static link, or it is a -Bsymbolic
1903 link and the symbol is defined locally, or the symbol
407443a3 1904 was forced to be local because of a version file. We
51e0a107
JH		 1905 must initialize this entry in the global offset table.
1906 Since the offset must always be a multiple of 8, we
1907 use the least significant bit to record whether we
1908 have initialized it already.
1909
1910 When doing a dynamic link, we create a .rela.got
407443a3
AJ		 1911 relocation entry to initialize the value. This is
1912 done in the finish_dynamic_symbol routine. */
51e0a107
JH		 1913 if ((off & 1) != 0)
1914 off &= ~1;
1915 else
1916 {
1917 bfd_put_64 (output_bfd, relocation,
c434dee6 1918 htab->sgot->contents + off);
51e0a107
JH		 1919 h->got.offset |= 1;
1920 }
1921 }
053579d7 1922 else
b34976b6 1923 unresolved_reloc = FALSE;
70256ad8 1924 }
51e0a107
JH		 1925 else
1926 {
c434dee6
AJ		 1927 if (local_got_offsets == NULL)
1928 abort ();
51e0a107
JH		 1929
1930 off = local_got_offsets[r_symndx];
1931
1932 /* The offset must always be a multiple of 8. We use
407443a3
AJ		 1933 the least significant bit to record whether we have
1934 already generated the necessary reloc. */
51e0a107
JH		 1935 if ((off & 1) != 0)
1936 off &= ~1;
1937 else
1938 {
c434dee6
AJ		 1939 bfd_put_64 (output_bfd, relocation,
1940 htab->sgot->contents + off);
51e0a107
JH		 1941
1942 if (info->shared)
1943 {
947216bf 1944 asection *s;
51e0a107 1945 Elf_Internal_Rela outrel;
947216bf 1946 bfd_byte *loc;
70256ad8 1947
51e0a107
JH		 1948 /* We need to generate a R_X86_64_RELATIVE reloc
1949 for the dynamic linker. */
947216bf
AM		 1950 s = htab->srelgot;
1951 if (s == NULL)
c434dee6 1952 abort ();
51e0a107 1953
c434dee6
AJ		 1954 outrel.r_offset = (htab->sgot->output_section->vma
1955 + htab->sgot->output_offset
51e0a107
JH		 1956 + off);
1957 outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
1958 outrel.r_addend = relocation;
947216bf
AM		 1959 loc = s->contents;
1960 loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
c434dee6 1961 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
51e0a107
JH		 1962 }
1963
1964 local_got_offsets[r_symndx] |= 1;
1965 }
51e0a107 1966 }
6a2bda3f 1967
c434dee6
AJ		 1968 if (off >= (bfd_vma) -2)
1969 abort ();
1970
8c37241b
JJ		 1971 relocation = htab->sgot->output_section->vma
1972 + htab->sgot->output_offset + off;
1973 if (r_type != R_X86_64_GOTPCREL)
1974 relocation -= htab->sgotplt->output_section->vma
1975 - htab->sgotplt->output_offset;
c434dee6 1976
70256ad8
AJ		 1977 break;
1978
d6ab8113
JB		 1979 case R_X86_64_GOTOFF64:
1980 /* Relocation is relative to the start of the global offset
1981 table. */
1982
1983 /* Check to make sure it isn't a protected function symbol
1984 for shared library since it may not be local when used
1985 as function address. */
1986 if (info->shared
1987 && h
1988 && h->def_regular
1989 && h->type == STT_FUNC
1990 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
1991 {
1992 (*_bfd_error_handler)
1993 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
1994 input_bfd, h->root.root.string);
1995 bfd_set_error (bfd_error_bad_value);
1996 return FALSE;
1997 }
1998
1999 /* Note that sgot is not involved in this
2000 calculation. We always want the start of .got.plt. If we
2001 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
2002 permitted by the ABI, we might have to change this
2003 calculation. */
2004 relocation -= htab->sgotplt->output_section->vma
2005 + htab->sgotplt->output_offset;
2006 break;
2007
2008 case R_X86_64_GOTPC32:
2009 /* Use global offset table as symbol value. */
2010 relocation = htab->sgotplt->output_section->vma
2011 + htab->sgotplt->output_offset;
2012 unresolved_reloc = FALSE;
2013 break;
2014
70256ad8
AJ		 2015 case R_X86_64_PLT32:
2016 /* Relocation is to the entry for this symbol in the
2017 procedure linkage table. */
2018
2019 /* Resolve a PLT32 reloc against a local symbol directly,
407443a3 2020 without using the procedure linkage table. */
70256ad8
AJ		 2021 if (h == NULL)
2022 break;
2023
c434dee6
AJ		 2024 if (h->plt.offset == (bfd_vma) -1
2025 || htab->splt == NULL)
70256ad8
AJ		 2026 {
2027 /* We didn't make a PLT entry for this symbol. This
407443a3
AJ		 2028 happens when statically linking PIC code, or when
2029 using -Bsymbolic. */
70256ad8
AJ		 2030 break;
2031 }
2032
c434dee6
AJ		 2033 relocation = (htab->splt->output_section->vma
2034 + htab->splt->output_offset
70256ad8 2035 + h->plt.offset);
b34976b6 2036 unresolved_reloc = FALSE;
70256ad8
AJ		 2037 break;
2038
fd8ab9e5
AJ		 2039 case R_X86_64_PC8:
2040 case R_X86_64_PC16:
2041 case R_X86_64_PC32:
6610a52d
L		 2042 if (info->shared
2043 && !SYMBOL_REFERENCES_LOCAL (info, h)
ba3bee0b 2044 && (input_section->flags & SEC_ALLOC) != 0
90f487df
L		 2045 && (input_section->flags & SEC_READONLY) != 0
2046 && (!h->def_regular
2047 || r_type != R_X86_64_PC32
2048 || h->type != STT_FUNC
2049 || ELF_ST_VISIBILITY (h->other) != STV_PROTECTED
2050 || !is_32bit_relative_branch (contents,
2051 rel->r_offset)))
6610a52d 2052 {
90f487df
L		 2053 if (h->def_regular
2054 && r_type == R_X86_64_PC32
2055 && h->type == STT_FUNC
2056 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
2057 (*_bfd_error_handler)
2058 (_("%B: relocation R_X86_64_PC32 against protected function `%s' can not be used when making a shared object"),
2059 input_bfd, h->root.root.string);
2060 else
2061 (*_bfd_error_handler)
2062 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
2063 input_bfd, x86_64_elf_howto_table[r_type].name,
2064 h->root.root.string);
6610a52d
L		 2065 bfd_set_error (bfd_error_bad_value);
2066 return FALSE;
2067 }
2068 /* Fall through. */
2069
70256ad8
AJ		 2070 case R_X86_64_8:
2071 case R_X86_64_16:
2072 case R_X86_64_32:
d6ab8113 2073 case R_X86_64_PC64:
6b3db546 2074 case R_X86_64_64:
80643fbc 2075 /* FIXME: The ABI says the linker should make sure the value is
407443a3 2076 the same when it's zeroextended to 64 bit. */
c434dee6
AJ		 2077
2078 /* r_symndx will be zero only for relocs against symbols
2079 from removed linkonce sections, or sections discarded by
2080 a linker script. */
2081 if (r_symndx == 0
2082 || (input_section->flags & SEC_ALLOC) == 0)
2083 break;
2084
2085 if ((info->shared
4bc6e03a
AJ		 2086 && (h == NULL
2087 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2088 || h->root.type != bfd_link_hash_undefweak)
c434dee6
AJ		 2089 && ((r_type != R_X86_64_PC8
2090 && r_type != R_X86_64_PC16
d6ab8113
JB		 2091 && r_type != R_X86_64_PC32
2092 && r_type != R_X86_64_PC64)
f6c52c13 2093 || !SYMBOL_CALLS_LOCAL (info, h)))
d40d037c
AJ		 2094 || (ELIMINATE_COPY_RELOCS
2095 && !info->shared
c434dee6
AJ		 2096 && h != NULL
2097 && h->dynindx != -1
f5385ebf
AM		 2098 && !h->non_got_ref
2099 && ((h->def_dynamic
2100 && !h->def_regular)
c434dee6
AJ		 2101 || h->root.type == bfd_link_hash_undefweak
2102 || h->root.type == bfd_link_hash_undefined)))
70256ad8
AJ		 2103 {
2104 Elf_Internal_Rela outrel;
947216bf 2105 bfd_byte *loc;
b34976b6 2106 bfd_boolean skip, relocate;
c434dee6 2107 asection *sreloc;
70256ad8
AJ		 2108
2109 /* When generating a shared object, these relocations
2110 are copied into the output file to be resolved at run
407443a3 2111 time. */
b34976b6
AM		 2112 skip = FALSE;
2113 relocate = FALSE;
70256ad8 2114
c629eae0
JJ		 2115 outrel.r_offset =
2116 _bfd_elf_section_offset (output_bfd, info, input_section,
c434dee6 2117 rel->r_offset);
c629eae0 2118 if (outrel.r_offset == (bfd_vma) -1)
b34976b6 2119 skip = TRUE;
0fb19cbc 2120 else if (outrel.r_offset == (bfd_vma) -2)
b34976b6 2121 skip = TRUE, relocate = TRUE;
70256ad8
AJ		 2122
2123 outrel.r_offset += (input_section->output_section->vma
2124 + input_section->output_offset);
2125
2126 if (skip)
0bb2d96a 2127 memset (&outrel, 0, sizeof outrel);
c434dee6 2128
fd8ab9e5
AJ		 2129 /* h->dynindx may be -1 if this symbol was marked to
2130 become local. */
2131 else if (h != NULL
c434dee6
AJ		 2132 && h->dynindx != -1
2133 && (r_type == R_X86_64_PC8
2134 || r_type == R_X86_64_PC16
2135 || r_type == R_X86_64_PC32
d6ab8113 2136 || r_type == R_X86_64_PC64
c434dee6
AJ		 2137 || !info->shared
2138 || !info->symbolic
f5385ebf 2139 || !h->def_regular))
70256ad8 2140 {
70256ad8 2141 outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
c434dee6 2142 outrel.r_addend = rel->r_addend;
70256ad8
AJ		 2143 }
2144 else
2145 {
c434dee6 2146 /* This symbol is local, or marked to become local. */
607c0e09
AS		 2147 if (r_type == R_X86_64_64)
2148 {
b34976b6 2149 relocate = TRUE;
607c0e09
AS		 2150 outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
2151 outrel.r_addend = relocation + rel->r_addend;
2152 }
2153 else
2154 {
2155 long sindx;
2156
8517fae7 2157 if (bfd_is_abs_section (sec))
607c0e09
AS		 2158 sindx = 0;
2159 else if (sec == NULL || sec->owner == NULL)
2160 {
2161 bfd_set_error (bfd_error_bad_value);
b34976b6 2162 return FALSE;
607c0e09
AS		 2163 }
2164 else
2165 {
2166 asection *osec;
2167
2168 osec = sec->output_section;
2169 sindx = elf_section_data (osec)->dynindx;
2170 BFD_ASSERT (sindx > 0);
2171 }
2172
2173 outrel.r_info = ELF64_R_INFO (sindx, r_type);
2174 outrel.r_addend = relocation + rel->r_addend;
2175 }
70256ad8
AJ		 2176 }
2177
c434dee6
AJ		 2178 sreloc = elf_section_data (input_section)->sreloc;
2179 if (sreloc == NULL)
2180 abort ();
2181
947216bf
AM		 2182 loc = sreloc->contents;
2183 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
c434dee6 2184 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
70256ad8
AJ		 2185
2186 /* If this reloc is against an external symbol, we do
2187 not want to fiddle with the addend. Otherwise, we
2188 need to include the symbol value so that it becomes
2189 an addend for the dynamic reloc. */
2190 if (! relocate)
2191 continue;
2192 }
2193
2194 break;
2195
bffbf940
JJ		 2196 case R_X86_64_TLSGD:
2197 case R_X86_64_GOTTPOFF:
2198 r_type = elf64_x86_64_tls_transition (info, r_type, h == NULL);
2199 tls_type = GOT_UNKNOWN;
2200 if (h == NULL && local_got_offsets)
2201 tls_type = elf64_x86_64_local_got_tls_type (input_bfd) [r_symndx];
2202 else if (h != NULL)
2203 {
2204 tls_type = elf64_x86_64_hash_entry (h)->tls_type;
2205 if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
2206 r_type = R_X86_64_TPOFF32;
2207 }
2208 if (r_type == R_X86_64_TLSGD)
2209 {
2210 if (tls_type == GOT_TLS_IE)
2211 r_type = R_X86_64_GOTTPOFF;
2212 }
2213
2214 if (r_type == R_X86_64_TPOFF32)
2215 {
2216 BFD_ASSERT (! unresolved_reloc);
2217 if (ELF64_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
2218 {
2219 unsigned int i;
abcf1d52
JJ		 2220 static unsigned char tlsgd[8]
2221 = { 0x66, 0x48, 0x8d, 0x3d, 0x66, 0x66, 0x48, 0xe8 };
bffbf940
JJ		 2222
2223 /* GD->LE transition.
abcf1d52
JJ		 2224 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
2225 .word 0x6666; rex64; call __tls_get_addr@plt
bffbf940
JJ		 2226 Change it into:
2227 movq %fs:0, %rax
2228 leaq foo@tpoff(%rax), %rax */
abcf1d52
JJ		 2229 BFD_ASSERT (rel->r_offset >= 4);
2230 for (i = 0; i < 4; i++)
bffbf940 2231 BFD_ASSERT (bfd_get_8 (input_bfd,
abcf1d52 2232 contents + rel->r_offset - 4 + i)
bffbf940 2233 == tlsgd[i]);
eea6121a 2234 BFD_ASSERT (rel->r_offset + 12 <= input_section->size);
abcf1d52
JJ		 2235 for (i = 0; i < 4; i++)
2236 BFD_ASSERT (bfd_get_8 (input_bfd,
2237 contents + rel->r_offset + 4 + i)
2238 == tlsgd[i+4]);
bffbf940
JJ		 2239 BFD_ASSERT (rel + 1 < relend);
2240 BFD_ASSERT (ELF64_R_TYPE (rel[1].r_info) == R_X86_64_PLT32);
abcf1d52 2241 memcpy (contents + rel->r_offset - 4,
bffbf940
JJ		 2242 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
2243 16);
2244 bfd_put_32 (output_bfd, tpoff (info, relocation),
abcf1d52 2245 contents + rel->r_offset + 8);
bffbf940
JJ		 2246 /* Skip R_X86_64_PLT32. */
2247 rel++;
2248 continue;
2249 }
2250 else
2251 {
2252 unsigned int val, type, reg;
2253
2254 /* IE->LE transition:
2255 Originally it can be one of:
2256 movq foo@gottpoff(%rip), %reg
2257 addq foo@gottpoff(%rip), %reg
2258 We change it into:
2259 movq $foo, %reg
2260 leaq foo(%reg), %reg
2261 addq $foo, %reg. */
2262 BFD_ASSERT (rel->r_offset >= 3);
2263 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 3);
2264 BFD_ASSERT (val == 0x48 || val == 0x4c);
2265 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2266 BFD_ASSERT (type == 0x8b || type == 0x03);
2267 reg = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2268 BFD_ASSERT ((reg & 0xc7) == 5);
2269 reg >>= 3;
eea6121a 2270 BFD_ASSERT (rel->r_offset + 4 <= input_section->size);
bffbf940
JJ		 2271 if (type == 0x8b)
2272 {
2273 /* movq */
2274 if (val == 0x4c)
2275 bfd_put_8 (output_bfd, 0x49,
2276 contents + rel->r_offset - 3);
2277 bfd_put_8 (output_bfd, 0xc7,
2278 contents + rel->r_offset - 2);
2279 bfd_put_8 (output_bfd, 0xc0 | reg,
2280 contents + rel->r_offset - 1);
2281 }
2282 else if (reg == 4)
2283 {
2284 /* addq -> addq - addressing with %rsp/%r12 is
2285 special */
2286 if (val == 0x4c)
2287 bfd_put_8 (output_bfd, 0x49,
2288 contents + rel->r_offset - 3);
2289 bfd_put_8 (output_bfd, 0x81,
2290 contents + rel->r_offset - 2);
2291 bfd_put_8 (output_bfd, 0xc0 | reg,
2292 contents + rel->r_offset - 1);
2293 }
2294 else
2295 {
2296 /* addq -> leaq */
2297 if (val == 0x4c)
2298 bfd_put_8 (output_bfd, 0x4d,
2299 contents + rel->r_offset - 3);
2300 bfd_put_8 (output_bfd, 0x8d,
2301 contents + rel->r_offset - 2);
2302 bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
2303 contents + rel->r_offset - 1);
2304 }
2305 bfd_put_32 (output_bfd, tpoff (info, relocation),
2306 contents + rel->r_offset);
2307 continue;
2308 }
2309 }
2310
2311 if (htab->sgot == NULL)
2312 abort ();
2313
2314 if (h != NULL)
2315 off = h->got.offset;
2316 else
2317 {
2318 if (local_got_offsets == NULL)
2319 abort ();
2320
2321 off = local_got_offsets[r_symndx];
2322 }
2323
2324 if ((off & 1) != 0)
2325 off &= ~1;
26e41594 2326 else
bffbf940
JJ		 2327 {
2328 Elf_Internal_Rela outrel;
947216bf 2329 bfd_byte *loc;
bffbf940
JJ		 2330 int dr_type, indx;
2331
2332 if (htab->srelgot == NULL)
2333 abort ();
2334
2335 outrel.r_offset = (htab->sgot->output_section->vma
2336 + htab->sgot->output_offset + off);
2337
2338 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2339 if (r_type == R_X86_64_TLSGD)
2340 dr_type = R_X86_64_DTPMOD64;
2341 else
2342 dr_type = R_X86_64_TPOFF64;
2343
2344 bfd_put_64 (output_bfd, 0, htab->sgot->contents + off);
2345 outrel.r_addend = 0;
2346 if (dr_type == R_X86_64_TPOFF64 && indx == 0)
2347 outrel.r_addend = relocation - dtpoff_base (info);
2348 outrel.r_info = ELF64_R_INFO (indx, dr_type);
2349
947216bf
AM		 2350 loc = htab->srelgot->contents;
2351 loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
bffbf940
JJ		 2352 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2353
2354 if (r_type == R_X86_64_TLSGD)
2355 {
2356 if (indx == 0)
2357 {
d40d037c 2358 BFD_ASSERT (! unresolved_reloc);
bffbf940
JJ		 2359 bfd_put_64 (output_bfd,
2360 relocation - dtpoff_base (info),
2361 htab->sgot->contents + off + GOT_ENTRY_SIZE);
2362 }
2363 else
2364 {
2365 bfd_put_64 (output_bfd, 0,
2366 htab->sgot->contents + off + GOT_ENTRY_SIZE);
2367 outrel.r_info = ELF64_R_INFO (indx,
2368 R_X86_64_DTPOFF64);
2369 outrel.r_offset += GOT_ENTRY_SIZE;
2370 htab->srelgot->reloc_count++;
947216bf
AM		 2371 loc += sizeof (Elf64_External_Rela);
2372 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
bffbf940
JJ		 2373 }
2374 }
2375
2376 if (h != NULL)
2377 h->got.offset |= 1;
2378 else
2379 local_got_offsets[r_symndx] |= 1;
2380 }
2381
2382 if (off >= (bfd_vma) -2)
2383 abort ();
2384 if (r_type == ELF64_R_TYPE (rel->r_info))
2385 {
2386 relocation = htab->sgot->output_section->vma
2387 + htab->sgot->output_offset + off;
b34976b6 2388 unresolved_reloc = FALSE;
bffbf940
JJ		 2389 }
2390 else
2391 {
2392 unsigned int i;
abcf1d52
JJ		 2393 static unsigned char tlsgd[8]
2394 = { 0x66, 0x48, 0x8d, 0x3d, 0x66, 0x66, 0x48, 0xe8 };
bffbf940
JJ		 2395
2396 /* GD->IE transition.
abcf1d52
JJ		 2397 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
2398 .word 0x6666; rex64; call __tls_get_addr@plt
bffbf940
JJ		 2399 Change it into:
2400 movq %fs:0, %rax
2401 addq foo@gottpoff(%rip), %rax */
abcf1d52
JJ		 2402 BFD_ASSERT (rel->r_offset >= 4);
2403 for (i = 0; i < 4; i++)
26e41594 2404 BFD_ASSERT (bfd_get_8 (input_bfd,
abcf1d52 2405 contents + rel->r_offset - 4 + i)
bffbf940 2406 == tlsgd[i]);
eea6121a 2407 BFD_ASSERT (rel->r_offset + 12 <= input_section->size);
abcf1d52 2408 for (i = 0; i < 4; i++)
26e41594 2409 BFD_ASSERT (bfd_get_8 (input_bfd,
abcf1d52
JJ		 2410 contents + rel->r_offset + 4 + i)
2411 == tlsgd[i+4]);
bffbf940
JJ		 2412 BFD_ASSERT (rel + 1 < relend);
2413 BFD_ASSERT (ELF64_R_TYPE (rel[1].r_info) == R_X86_64_PLT32);
abcf1d52 2414 memcpy (contents + rel->r_offset - 4,
bffbf940
JJ		 2415 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
2416 16);
2417
2418 relocation = (htab->sgot->output_section->vma
2419 + htab->sgot->output_offset + off
2420 - rel->r_offset
2421 - input_section->output_section->vma
2422 - input_section->output_offset
abcf1d52 2423 - 12);
bffbf940 2424 bfd_put_32 (output_bfd, relocation,
abcf1d52 2425 contents + rel->r_offset + 8);
bffbf940
JJ		 2426 /* Skip R_X86_64_PLT32. */
2427 rel++;
2428 continue;
2429 }
2430 break;
2431
2432 case R_X86_64_TLSLD:
2433 if (! info->shared)
2434 {
2435 /* LD->LE transition:
2436 Ensure it is:
2437 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr@plt.
2438 We change it into:
2439 .word 0x6666; .byte 0x66; movl %fs:0, %rax. */
2440 BFD_ASSERT (rel->r_offset >= 3);
2441 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 3)
2442 == 0x48);
2443 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 2)
2444 == 0x8d);
2445 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 1)
2446 == 0x3d);
eea6121a 2447 BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
bffbf940
JJ		 2448 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2449 == 0xe8);
2450 BFD_ASSERT (rel + 1 < relend);
2451 BFD_ASSERT (ELF64_R_TYPE (rel[1].r_info) == R_X86_64_PLT32);
2452 memcpy (contents + rel->r_offset - 3,
2453 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
2454 /* Skip R_X86_64_PLT32. */
2455 rel++;
2456 continue;
2457 }
2458
2459 if (htab->sgot == NULL)
2460 abort ();
2461
2462 off = htab->tls_ld_got.offset;
2463 if (off & 1)
2464 off &= ~1;
2465 else
2466 {
2467 Elf_Internal_Rela outrel;
947216bf 2468 bfd_byte *loc;
bffbf940
JJ		 2469
2470 if (htab->srelgot == NULL)
2471 abort ();
2472
2473 outrel.r_offset = (htab->sgot->output_section->vma
2474 + htab->sgot->output_offset + off);
2475
2476 bfd_put_64 (output_bfd, 0,
2477 htab->sgot->contents + off);
2478 bfd_put_64 (output_bfd, 0,
2479 htab->sgot->contents + off + GOT_ENTRY_SIZE);
2480 outrel.r_info = ELF64_R_INFO (0, R_X86_64_DTPMOD64);
2481 outrel.r_addend = 0;
947216bf
AM		 2482 loc = htab->srelgot->contents;
2483 loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
bffbf940
JJ		 2484 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2485 htab->tls_ld_got.offset |= 1;
2486 }
2487 relocation = htab->sgot->output_section->vma
2488 + htab->sgot->output_offset + off;
b34976b6 2489 unresolved_reloc = FALSE;
bffbf940
JJ		 2490 break;
2491
2492 case R_X86_64_DTPOFF32:
a45bb67d 2493 if (info->shared || (input_section->flags & SEC_CODE) == 0)
bffbf940
JJ		 2494 relocation -= dtpoff_base (info);
2495 else
2496 relocation = tpoff (info, relocation);
2497 break;
2498
2499 case R_X86_64_TPOFF32:
2500 BFD_ASSERT (! info->shared);
2501 relocation = tpoff (info, relocation);
2502 break;
2503
70256ad8
AJ		 2504 default:
2505 break;
2506 }
8d88c4ca 2507
239e1f3a
AM		 2508 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2509 because such sections are not SEC_ALLOC and thus ld.so will
2510 not process them. */
c434dee6 2511 if (unresolved_reloc
239e1f3a 2512 && !((input_section->flags & SEC_DEBUGGING) != 0
f5385ebf 2513 && h->def_dynamic))
c434dee6 2514 (*_bfd_error_handler)
d003868e
AM		 2515 (_("%B(%A+0x%lx): unresolvable relocation against symbol `%s'"),
2516 input_bfd,
2517 input_section,
c434dee6
AJ		 2518 (long) rel->r_offset,
2519 h->root.root.string);
2520
8d88c4ca 2521 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
c434dee6
AJ		 2522 contents, rel->r_offset,
2523 relocation, rel->r_addend);
8d88c4ca
NC		 2524
2525 if (r != bfd_reloc_ok)
8da6118f 2526 {
c434dee6
AJ		 2527 const char *name;
2528
2529 if (h != NULL)
2530 name = h->root.root.string;
2531 else
8da6118f 2532 {
c434dee6
AJ		 2533 name = bfd_elf_string_from_elf_section (input_bfd,
2534 symtab_hdr->sh_link,
2535 sym->st_name);
2536 if (name == NULL)
b34976b6 2537 return FALSE;
c434dee6
AJ		 2538 if (*name == '\0')
2539 name = bfd_section_name (input_bfd, sec);
2540 }
2541
2542 if (r == bfd_reloc_overflow)
2543 {
3ffa5234
AM		 2544 if (h != NULL
2545 && h->root.type == bfd_link_hash_undefweak
2546 && howto->pc_relative)
2547 /* Ignore reloc overflow on branches to undefweak syms. */
2548 continue;
c434dee6
AJ		 2549
2550 if (! ((*info->callbacks->reloc_overflow)
dfeffb9f
L		 2551 (info, (h ? &h->root : NULL), name, howto->name,
2552 (bfd_vma) 0, input_bfd, input_section,
2553 rel->r_offset)))
b34976b6 2554 return FALSE;
c434dee6
AJ		 2555 }
2556 else
2557 {
2558 (*_bfd_error_handler)
d003868e
AM		 2559 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
2560 input_bfd, input_section,
c434dee6 2561 (long) rel->r_offset, name, (int) r);
b34976b6 2562 return FALSE;
8da6118f
KH		 2563 }
2564 }
8d88c4ca 2565 }
70256ad8 2566
b34976b6 2567 return TRUE;
70256ad8
AJ		 2568}
2569
2570/* Finish up dynamic symbol handling. We set the contents of various
2571 dynamic sections here. */
2572
b34976b6 2573static bfd_boolean
27482721
AJ		 2574elf64_x86_64_finish_dynamic_symbol (bfd *output_bfd,
2575 struct bfd_link_info *info,
2576 struct elf_link_hash_entry *h,
2577 Elf_Internal_Sym *sym)
70256ad8 2578{
c434dee6 2579 struct elf64_x86_64_link_hash_table *htab;
70256ad8 2580
c434dee6 2581 htab = elf64_x86_64_hash_table (info);
70256ad8
AJ		 2582
2583 if (h->plt.offset != (bfd_vma) -1)
2584 {
70256ad8
AJ		 2585 bfd_vma plt_index;
2586 bfd_vma got_offset;
2587 Elf_Internal_Rela rela;
947216bf 2588 bfd_byte *loc;
70256ad8
AJ		 2589
2590 /* This symbol has an entry in the procedure linkage table. Set
407443a3 2591 it up. */
c434dee6
AJ		 2592 if (h->dynindx == -1
2593 || htab->splt == NULL
2594 || htab->sgotplt == NULL
2595 || htab->srelplt == NULL)
2596 abort ();
70256ad8
AJ		 2597
2598 /* Get the index in the procedure linkage table which
2599 corresponds to this symbol. This is the index of this symbol
2600 in all the symbols for which we are making plt entries. The
2601 first entry in the procedure linkage table is reserved. */
2602 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2603
2604 /* Get the offset into the .got table of the entry that
407443a3 2605 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
fe4770f4 2606 bytes. The first three are reserved for the dynamic linker. */
70256ad8
AJ		 2607 got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
2608
2609 /* Fill in the entry in the procedure linkage table. */
c434dee6 2610 memcpy (htab->splt->contents + h->plt.offset, elf64_x86_64_plt_entry,
70256ad8
AJ		 2611 PLT_ENTRY_SIZE);
2612
2613 /* Insert the relocation positions of the plt section. The magic
2614 numbers at the end of the statements are the positions of the
2615 relocations in the plt section. */
653165cc
AJ		 2616 /* Put offset for jmp *name@GOTPCREL(%rip), since the
2617 instruction uses 6 bytes, subtract this value. */
2618 bfd_put_32 (output_bfd,
c434dee6
AJ		 2619 (htab->sgotplt->output_section->vma
2620 + htab->sgotplt->output_offset
653165cc 2621 + got_offset
c434dee6
AJ		 2622 - htab->splt->output_section->vma
2623 - htab->splt->output_offset
653165cc
AJ		 2624 - h->plt.offset
2625 - 6),
c434dee6 2626 htab->splt->contents + h->plt.offset + 2);
653165cc
AJ		 2627 /* Put relocation index. */
2628 bfd_put_32 (output_bfd, plt_index,
c434dee6 2629 htab->splt->contents + h->plt.offset + 7);
653165cc
AJ		 2630 /* Put offset for jmp .PLT0. */
2631 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
c434dee6 2632 htab->splt->contents + h->plt.offset + 12);
70256ad8 2633
653165cc
AJ		 2634 /* Fill in the entry in the global offset table, initially this
2635 points to the pushq instruction in the PLT which is at offset 6. */
c434dee6
AJ		 2636 bfd_put_64 (output_bfd, (htab->splt->output_section->vma
2637 + htab->splt->output_offset
70256ad8 2638 + h->plt.offset + 6),
c434dee6 2639 htab->sgotplt->contents + got_offset);
70256ad8
AJ		 2640
2641 /* Fill in the entry in the .rela.plt section. */
c434dee6
AJ		 2642 rela.r_offset = (htab->sgotplt->output_section->vma
2643 + htab->sgotplt->output_offset
70256ad8
AJ		 2644 + got_offset);
2645 rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_JUMP_SLOT);
2646 rela.r_addend = 0;
947216bf 2647 loc = htab->srelplt->contents + plt_index * sizeof (Elf64_External_Rela);
c434dee6 2648 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
70256ad8 2649
f5385ebf 2650 if (!h->def_regular)
70256ad8
AJ		 2651 {
2652 /* Mark the symbol as undefined, rather than as defined in
47a9f7b3
JJ		 2653 the .plt section. Leave the value if there were any
2654 relocations where pointer equality matters (this is a clue
c434dee6
AJ		 2655 for the dynamic linker, to make function pointer
2656 comparisons work between an application and shared
47a9f7b3
JJ		 2657 library), otherwise set it to zero. If a function is only
2658 called from a binary, there is no need to slow down
2659 shared libraries because of that. */
70256ad8 2660 sym->st_shndx = SHN_UNDEF;
f5385ebf 2661 if (!h->pointer_equality_needed)
47a9f7b3 2662 sym->st_value = 0;
70256ad8
AJ		 2663 }
2664 }
2665
bffbf940
JJ		 2666 if (h->got.offset != (bfd_vma) -1
2667 && elf64_x86_64_hash_entry (h)->tls_type != GOT_TLS_GD
2668 && elf64_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE)
053579d7 2669 {
053579d7 2670 Elf_Internal_Rela rela;
947216bf 2671 bfd_byte *loc;
053579d7
AJ		 2672
2673 /* This symbol has an entry in the global offset table. Set it
bffbf940 2674 up. */
c434dee6
AJ		 2675 if (htab->sgot == NULL || htab->srelgot == NULL)
2676 abort ();
053579d7 2677
c434dee6
AJ		 2678 rela.r_offset = (htab->sgot->output_section->vma
2679 + htab->sgot->output_offset
dc810e39 2680 + (h->got.offset &~ (bfd_vma) 1));
053579d7
AJ		 2681
2682 /* If this is a static link, or it is a -Bsymbolic link and the
2683 symbol is defined locally or was forced to be local because
2684 of a version file, we just want to emit a RELATIVE reloc.
2685 The entry in the global offset table will already have been
2686 initialized in the relocate_section function. */
c434dee6 2687 if (info->shared
27482721 2688 && SYMBOL_REFERENCES_LOCAL (info, h))
053579d7 2689 {
cc78d0af 2690 BFD_ASSERT((h->got.offset & 1) != 0);
053579d7
AJ		 2691 rela.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
2692 rela.r_addend = (h->root.u.def.value
2693 + h->root.u.def.section->output_section->vma
2694 + h->root.u.def.section->output_offset);
2695 }
2696 else
2697 {
2698 BFD_ASSERT((h->got.offset & 1) == 0);
c434dee6
AJ		 2699 bfd_put_64 (output_bfd, (bfd_vma) 0,
2700 htab->sgot->contents + h->got.offset);
053579d7
AJ		 2701 rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_GLOB_DAT);
2702 rela.r_addend = 0;
2703 }
2704
947216bf
AM		 2705 loc = htab->srelgot->contents;
2706 loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
c434dee6 2707 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
053579d7
AJ		 2708 }
2709
f5385ebf 2710 if (h->needs_copy)
70256ad8 2711 {
70256ad8 2712 Elf_Internal_Rela rela;
947216bf 2713 bfd_byte *loc;
70256ad8
AJ		 2714
2715 /* This symbol needs a copy reloc. Set it up. */
2716
c434dee6
AJ		 2717 if (h->dynindx == -1
2718 || (h->root.type != bfd_link_hash_defined
2719 && h->root.type != bfd_link_hash_defweak)
2720 || htab->srelbss == NULL)
2721 abort ();
70256ad8
AJ		 2722
2723 rela.r_offset = (h->root.u.def.value
2724 + h->root.u.def.section->output_section->vma
2725 + h->root.u.def.section->output_offset);
2726 rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_COPY);
2727 rela.r_addend = 0;
947216bf
AM		 2728 loc = htab->srelbss->contents;
2729 loc += htab->srelbss->reloc_count++ * sizeof (Elf64_External_Rela);
c434dee6 2730 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
70256ad8
AJ		 2731 }
2732
2733 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2734 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2735 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2736 sym->st_shndx = SHN_ABS;
2737
b34976b6 2738 return TRUE;
70256ad8
AJ		 2739}
2740
c434dee6
AJ		 2741/* Used to decide how to sort relocs in an optimal manner for the
2742 dynamic linker, before writing them out. */
2743
2744static enum elf_reloc_type_class
27482721 2745elf64_x86_64_reloc_type_class (const Elf_Internal_Rela *rela)
c434dee6
AJ		 2746{
2747 switch ((int) ELF64_R_TYPE (rela->r_info))
2748 {
2749 case R_X86_64_RELATIVE:
2750 return reloc_class_relative;
2751 case R_X86_64_JUMP_SLOT:
2752 return reloc_class_plt;
2753 case R_X86_64_COPY:
2754 return reloc_class_copy;
2755 default:
2756 return reloc_class_normal;
2757 }
2758}
2759
70256ad8
AJ		 2760/* Finish up the dynamic sections. */
2761
b34976b6 2762static bfd_boolean
27482721 2763elf64_x86_64_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
70256ad8 2764{
c434dee6 2765 struct elf64_x86_64_link_hash_table *htab;
70256ad8
AJ		 2766 bfd *dynobj;
2767 asection *sdyn;
70256ad8 2768
c434dee6
AJ		 2769 htab = elf64_x86_64_hash_table (info);
2770 dynobj = htab->elf.dynobj;
70256ad8
AJ		 2771 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2772
c434dee6 2773 if (htab->elf.dynamic_sections_created)
70256ad8 2774 {
70256ad8
AJ		 2775 Elf64_External_Dyn *dyncon, *dynconend;
2776
c434dee6
AJ		 2777 if (sdyn == NULL || htab->sgot == NULL)
2778 abort ();
70256ad8
AJ		 2779
2780 dyncon = (Elf64_External_Dyn *) sdyn->contents;
eea6121a 2781 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
70256ad8
AJ		 2782 for (; dyncon < dynconend; dyncon++)
2783 {
2784 Elf_Internal_Dyn dyn;
70256ad8
AJ		 2785 asection *s;
2786
2787 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
2788
2789 switch (dyn.d_tag)
2790 {
2791 default:
053579d7 2792 continue;
70256ad8
AJ		 2793
2794 case DT_PLTGOT:
8c37241b
JJ		 2795 s = htab->sgotplt;
2796 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
c434dee6 2797 break;
70256ad8
AJ		 2798
2799 case DT_JMPREL:
c434dee6
AJ		 2800 dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
2801 break;
70256ad8 2802
c434dee6
AJ		 2803 case DT_PLTRELSZ:
2804 s = htab->srelplt->output_section;
eea6121a 2805 dyn.d_un.d_val = s->size;
70256ad8
AJ		 2806 break;
2807
2808 case DT_RELASZ:
c434dee6
AJ		 2809 /* The procedure linkage table relocs (DT_JMPREL) should
2810 not be included in the overall relocs (DT_RELA).
2811 Therefore, we override the DT_RELASZ entry here to
2812 make it not include the JMPREL relocs. Since the
2813 linker script arranges for .rela.plt to follow all
2814 other relocation sections, we don't have to worry
2815 about changing the DT_RELA entry. */
2816 if (htab->srelplt != NULL)
70256ad8 2817 {
c434dee6 2818 s = htab->srelplt->output_section;
eea6121a 2819 dyn.d_un.d_val -= s->size;
70256ad8
AJ		 2820 }
2821 break;
70256ad8 2822 }
c434dee6 2823
70256ad8
AJ		 2824 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2825 }
2826
c434dee6 2827 /* Fill in the special first entry in the procedure linkage table. */
eea6121a 2828 if (htab->splt && htab->splt->size > 0)
70256ad8 2829 {
653165cc 2830 /* Fill in the first entry in the procedure linkage table. */
c434dee6
AJ		 2831 memcpy (htab->splt->contents, elf64_x86_64_plt0_entry,
2832 PLT_ENTRY_SIZE);
653165cc
AJ		 2833 /* Add offset for pushq GOT+8(%rip), since the instruction
2834 uses 6 bytes subtract this value. */
2835 bfd_put_32 (output_bfd,
c434dee6
AJ		 2836 (htab->sgotplt->output_section->vma
2837 + htab->sgotplt->output_offset
653165cc 2838 + 8
c434dee6
AJ		 2839 - htab->splt->output_section->vma
2840 - htab->splt->output_offset
653165cc 2841 - 6),
c434dee6 2842 htab->splt->contents + 2);
653165cc
AJ		 2843 /* Add offset for jmp *GOT+16(%rip). The 12 is the offset to
2844 the end of the instruction. */
2845 bfd_put_32 (output_bfd,
c434dee6
AJ		 2846 (htab->sgotplt->output_section->vma
2847 + htab->sgotplt->output_offset
653165cc 2848 + 16
c434dee6
AJ		 2849 - htab->splt->output_section->vma
2850 - htab->splt->output_offset
653165cc 2851 - 12),
c434dee6 2852 htab->splt->contents + 8);
653165cc 2853
c434dee6
AJ		 2854 elf_section_data (htab->splt->output_section)->this_hdr.sh_entsize =
2855 PLT_ENTRY_SIZE;
70256ad8 2856 }
70256ad8
AJ		 2857 }
2858
c434dee6 2859 if (htab->sgotplt)
70256ad8 2860 {
c434dee6 2861 /* Fill in the first three entries in the global offset table. */
eea6121a 2862 if (htab->sgotplt->size > 0)
c434dee6
AJ		 2863 {
2864 /* Set the first entry in the global offset table to the address of
2865 the dynamic section. */
2866 if (sdyn == NULL)
2867 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents);
2868 else
2869 bfd_put_64 (output_bfd,
2870 sdyn->output_section->vma + sdyn->output_offset,
2871 htab->sgotplt->contents);
2872 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
2873 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + GOT_ENTRY_SIZE);
2874 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + GOT_ENTRY_SIZE*2);
2875 }
70256ad8 2876
c434dee6
AJ		 2877 elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize =
2878 GOT_ENTRY_SIZE;
2879 }
70256ad8 2880
eea6121a 2881 if (htab->sgot && htab->sgot->size > 0)
8c37241b
JJ		 2882 elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize
2883 = GOT_ENTRY_SIZE;
2884
b34976b6 2885 return TRUE;
8d88c4ca
NC		 2886}
2887
4c45e5c9
JJ		 2888/* Return address for Ith PLT stub in section PLT, for relocation REL
2889 or (bfd_vma) -1 if it should not be included. */
2890
2891static bfd_vma
2892elf64_x86_64_plt_sym_val (bfd_vma i, const asection *plt,
2893 const arelent *rel ATTRIBUTE_UNUSED)
2894{
2895 return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
2896}
8df9fc9d 2897
d2b2c203
DJ		 2898/* Handle an x86-64 specific section when reading an object file. This
2899 is called when elfcode.h finds a section with an unknown type. */
2900
2901static bfd_boolean
6dc132d9
L		 2902elf64_x86_64_section_from_shdr (bfd *abfd,
2903 Elf_Internal_Shdr *hdr,
2904 const char *name,
2905 int shindex)
d2b2c203
DJ		 2906{
2907 if (hdr->sh_type != SHT_X86_64_UNWIND)
2908 return FALSE;
2909
6dc132d9 2910 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
d2b2c203
DJ		 2911 return FALSE;
2912
2913 return TRUE;
2914}
2915
3b22753a
L		 2916/* Hook called by the linker routine which adds symbols from an object
2917 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
2918 of .bss. */
2919
2920static bfd_boolean
2921elf64_x86_64_add_symbol_hook (bfd *abfd,
2922 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2923 Elf_Internal_Sym *sym,
2924 const char **namep ATTRIBUTE_UNUSED,
2925 flagword *flagsp ATTRIBUTE_UNUSED,
2926 asection **secp, bfd_vma *valp)
2927{
2928 asection *lcomm;
2929
2930 switch (sym->st_shndx)
2931 {
2932 case SHN_X86_64_LCOMMON:
2933 lcomm = bfd_get_section_by_name (abfd, "LARGE_COMMON");
2934 if (lcomm == NULL)
2935 {
2936 lcomm = bfd_make_section_with_flags (abfd,
2937 "LARGE_COMMON",
2938 (SEC_ALLOC
2939 | SEC_IS_COMMON
2940 | SEC_LINKER_CREATED));
2941 if (lcomm == NULL)
2942 return FALSE;
2943 elf_section_flags (lcomm) |= SHF_X86_64_LARGE;
2944 }
2945 *secp = lcomm;
2946 *valp = sym->st_size;
2947 break;
2948 }
2949 return TRUE;
2950}
2951
2952
2953/* Given a BFD section, try to locate the corresponding ELF section
2954 index. */
2955
2956static bfd_boolean
2957elf64_x86_64_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
2958 asection *sec, int *index)
2959{
2960 if (sec == &_bfd_elf_large_com_section)
2961 {
2962 *index = SHN_X86_64_LCOMMON;
2963 return TRUE;
2964 }
2965 return FALSE;
2966}
2967
2968/* Process a symbol. */
2969
2970static void
2971elf64_x86_64_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
2972 asymbol *asym)
2973{
2974 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
2975
2976 switch (elfsym->internal_elf_sym.st_shndx)
2977 {
2978 case SHN_X86_64_LCOMMON:
2979 asym->section = &_bfd_elf_large_com_section;
2980 asym->value = elfsym->internal_elf_sym.st_size;
2981 /* Common symbol doesn't set BSF_GLOBAL. */
2982 asym->flags &= ~BSF_GLOBAL;
2983 break;
2984 }
2985}
2986
2987static bfd_boolean
2988elf64_x86_64_common_definition (Elf_Internal_Sym *sym)
2989{
2990 return (sym->st_shndx == SHN_COMMON
2991 || sym->st_shndx == SHN_X86_64_LCOMMON);
2992}
2993
2994static unsigned int
2995elf64_x86_64_common_section_index (asection *sec)
2996{
2997 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
2998 return SHN_COMMON;
2999 else
3000 return SHN_X86_64_LCOMMON;
3001}
3002
3003static asection *
3004elf64_x86_64_common_section (asection *sec)
3005{
3006 if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
3007 return bfd_com_section_ptr;
3008 else
3009 return &_bfd_elf_large_com_section;
3010}
3011
3012static bfd_boolean
3013elf64_x86_64_merge_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
3014 struct elf_link_hash_entry **sym_hash ATTRIBUTE_UNUSED,
3015 struct elf_link_hash_entry *h,
3016 Elf_Internal_Sym *sym,
3017 asection **psec ATTRIBUTE_UNUSED,
3018 bfd_vma *pvalue ATTRIBUTE_UNUSED,
3019 unsigned int *pold_alignment ATTRIBUTE_UNUSED,
3020 bfd_boolean *skip ATTRIBUTE_UNUSED,
3021 bfd_boolean *override ATTRIBUTE_UNUSED,
3022 bfd_boolean *type_change_ok ATTRIBUTE_UNUSED,
3023 bfd_boolean *size_change_ok ATTRIBUTE_UNUSED,
3024 bfd_boolean *newdef ATTRIBUTE_UNUSED,
3025 bfd_boolean *newdyn,
3026 bfd_boolean *newdyncommon ATTRIBUTE_UNUSED,
3027 bfd_boolean *newweak ATTRIBUTE_UNUSED,
3028 bfd *abfd ATTRIBUTE_UNUSED,
3029 asection **sec,
3030 bfd_boolean *olddef ATTRIBUTE_UNUSED,
3031 bfd_boolean *olddyn,
3032 bfd_boolean *olddyncommon ATTRIBUTE_UNUSED,
3033 bfd_boolean *oldweak ATTRIBUTE_UNUSED,
3034 bfd *oldbfd ATTRIBUTE_UNUSED,
3035 asection **oldsec)
3036{
3037 /* A normal common symbol and a large common symbol result in a
3038 normal common symbol. If we see the normal symbol first, we
3039 do nothing since the first one will be used. If we see the
3040 large common symbol first, we need to change the large common
3041 symbol to the normal common symbol. */
3042 if (!*olddyn
3043 && h->root.type == bfd_link_hash_common
3044 && !*newdyn
3045 && bfd_is_com_section (*sec)
3046 && *oldsec != *sec
3047 && sym->st_shndx == SHN_COMMON
3048 && (elf_section_flags (*oldsec) & SHF_X86_64_LARGE) != 0)
3049 {
3050 h->root.u.c.p->section = bfd_make_section_old_way (abfd,
3051 "COMMON");
3052 h->root.u.c.p->section->flags = SEC_ALLOC;
3053 }
3054
3055 return TRUE;
3056}
3057
3058static int
3059elf64_x86_64_additional_program_headers (bfd *abfd)
3060{
3061 asection *s;
3062 int count = 0;
3063
3064 /* Check to see if we need a large readonly segment. */
3065 s = bfd_get_section_by_name (abfd, ".lrodata");
3066 if (s && (s->flags & SEC_LOAD))
3067 count++;
3068
3069 /* Check to see if we need a large data segment. Since .lbss sections
3070 is placed right after the .bss section, there should be no need for
3071 a large data segment just because of .lbss. */
3072 s = bfd_get_section_by_name (abfd, ".ldata");
3073 if (s && (s->flags & SEC_LOAD))
3074 count++;
3075
3076 return count;
3077}
3078
3079static const struct bfd_elf_special_section
3080 elf64_x86_64_special_sections[]=
3081{
3082 { ".gnu.linkonce.lb", 16, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
3083 { ".gnu.linkonce.lr", 16, -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
3084 { ".gnu.linkonce.lt", 16, -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR + SHF_X86_64_LARGE},
3085 { ".lbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
3086 { ".ldata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
3087 { ".lrodata", 8, -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
3088 { NULL, 0, 0, 0, 0 }
3089};
3090
70256ad8
AJ		 3091#define TARGET_LITTLE_SYM bfd_elf64_x86_64_vec
3092#define TARGET_LITTLE_NAME "elf64-x86-64"
3093#define ELF_ARCH bfd_arch_i386
3094#define ELF_MACHINE_CODE EM_X86_64
3095#define ELF_MAXPAGESIZE 0x100000
3096
3097#define elf_backend_can_gc_sections 1
51b64d56 3098#define elf_backend_can_refcount 1
70256ad8
AJ		 3099#define elf_backend_want_got_plt 1
3100#define elf_backend_plt_readonly 1
3101#define elf_backend_want_plt_sym 0
3102#define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
b491616a 3103#define elf_backend_rela_normal 1
70256ad8
AJ		 3104
3105#define elf_info_to_howto elf64_x86_64_info_to_howto
70256ad8 3106
70256ad8
AJ		 3107#define bfd_elf64_bfd_link_hash_table_create \
3108 elf64_x86_64_link_hash_table_create
407443a3 3109#define bfd_elf64_bfd_reloc_type_lookup elf64_x86_64_reloc_type_lookup
70256ad8
AJ		 3110
3111#define elf_backend_adjust_dynamic_symbol elf64_x86_64_adjust_dynamic_symbol
3112#define elf_backend_check_relocs elf64_x86_64_check_relocs
c434dee6
AJ		 3113#define elf_backend_copy_indirect_symbol elf64_x86_64_copy_indirect_symbol
3114#define elf_backend_create_dynamic_sections elf64_x86_64_create_dynamic_sections
3115#define elf_backend_finish_dynamic_sections elf64_x86_64_finish_dynamic_sections
70256ad8
AJ		 3116#define elf_backend_finish_dynamic_symbol elf64_x86_64_finish_dynamic_symbol
3117#define elf_backend_gc_mark_hook elf64_x86_64_gc_mark_hook
3118#define elf_backend_gc_sweep_hook elf64_x86_64_gc_sweep_hook
3bab7989
ML		 3119#define elf_backend_grok_prstatus elf64_x86_64_grok_prstatus
3120#define elf_backend_grok_psinfo elf64_x86_64_grok_psinfo
c434dee6 3121#define elf_backend_reloc_type_class elf64_x86_64_reloc_type_class
70256ad8
AJ		 3122#define elf_backend_relocate_section elf64_x86_64_relocate_section
3123#define elf_backend_size_dynamic_sections elf64_x86_64_size_dynamic_sections
4c45e5c9 3124#define elf_backend_plt_sym_val elf64_x86_64_plt_sym_val
407443a3 3125#define elf_backend_object_p elf64_x86_64_elf_object_p
bffbf940 3126#define bfd_elf64_mkobject elf64_x86_64_mkobject
8d88c4ca 3127
d2b2c203
DJ		 3128#define elf_backend_section_from_shdr \
3129 elf64_x86_64_section_from_shdr
3130
3b22753a
L		 3131#define elf_backend_section_from_bfd_section \
3132 elf64_x86_64_elf_section_from_bfd_section
3133#define elf_backend_add_symbol_hook \
3134 elf64_x86_64_add_symbol_hook
3135#define elf_backend_symbol_processing \
3136 elf64_x86_64_symbol_processing
3137#define elf_backend_common_section_index \
3138 elf64_x86_64_common_section_index
3139#define elf_backend_common_section \
3140 elf64_x86_64_common_section
3141#define elf_backend_common_definition \
3142 elf64_x86_64_common_definition
3143#define elf_backend_merge_symbol \
3144 elf64_x86_64_merge_symbol
3145#define elf_backend_special_sections \
3146 elf64_x86_64_special_sections
3147#define elf_backend_additional_program_headers \
3148 elf64_x86_64_additional_program_headers
3149
8d88c4ca 3150#include "elf64-target.h"
A mirror of the official binutils-gdb repository