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