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