1
/* X86-64 specific support for 64-bit ELF
2
Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
3
Contributed by Jan Hubicka <jh@suse.cz>.
5
This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
27
#include "elf/x86-64.h"
29
/* We use only the RELA entries. */
32
/* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
33
#define MINUS_ONE (~ (bfd_vma) 0)
35
/* The relocation "howto" table. Order of fields:
36
type, size, bitsize, pc_relative, complain_on_overflow,
37
special_function, name, partial_inplace, src_mask, dst_pack, pcrel_offset. */
38
static reloc_howto_type x86_64_elf_howto_table[] =
40
HOWTO(R_X86_64_NONE, 0, 0, 0, false, 0, complain_overflow_dont,
41
bfd_elf_generic_reloc, "R_X86_64_NONE", false, 0x00000000, 0x00000000,
43
HOWTO(R_X86_64_64, 0, 4, 64, false, 0, complain_overflow_bitfield,
44
bfd_elf_generic_reloc, "R_X86_64_64", false, MINUS_ONE, MINUS_ONE,
46
HOWTO(R_X86_64_PC32, 0, 4, 32, true, 0, complain_overflow_signed,
47
bfd_elf_generic_reloc, "R_X86_64_PC32", false, 0xffffffff, 0xffffffff,
49
HOWTO(R_X86_64_GOT32, 0, 4, 32, false, 0, complain_overflow_signed,
50
bfd_elf_generic_reloc, "R_X86_64_GOT32", false, 0xffffffff, 0xffffffff,
52
HOWTO(R_X86_64_PLT32, 0, 4, 32, true, 0, complain_overflow_signed,
53
bfd_elf_generic_reloc, "R_X86_64_PLT32", false, 0xffffffff, 0xffffffff,
55
HOWTO(R_X86_64_COPY, 0, 4, 32, false, 0, complain_overflow_bitfield,
56
bfd_elf_generic_reloc, "R_X86_64_COPY", false, 0xffffffff, 0xffffffff,
58
HOWTO(R_X86_64_GLOB_DAT, 0, 4, 64, false, 0, complain_overflow_bitfield,
59
bfd_elf_generic_reloc, "R_X86_64_GLOB_DAT", false, MINUS_ONE,
61
HOWTO(R_X86_64_JUMP_SLOT, 0, 4, 64, false, 0, complain_overflow_bitfield,
62
bfd_elf_generic_reloc, "R_X86_64_JUMP_SLOT", false, MINUS_ONE,
64
HOWTO(R_X86_64_RELATIVE, 0, 4, 64, false, 0, complain_overflow_bitfield,
65
bfd_elf_generic_reloc, "R_X86_64_RELATIVE", false, MINUS_ONE,
67
HOWTO(R_X86_64_GOTPCREL, 0, 4, 32, true,0 , complain_overflow_signed,
68
bfd_elf_generic_reloc, "R_X86_64_GOTPCREL", false, 0xffffffff,
70
HOWTO(R_X86_64_32, 0, 4, 32, false, 0, complain_overflow_unsigned,
71
bfd_elf_generic_reloc, "R_X86_64_32", false, 0xffffffff, 0xffffffff,
73
HOWTO(R_X86_64_32S, 0, 4, 32, false, 0, complain_overflow_signed,
74
bfd_elf_generic_reloc, "R_X86_64_32S", false, 0xffffffff, 0xffffffff,
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,
83
bfd_elf_generic_reloc, "R_X86_64_PC8", false, 0xff, 0xff, true),
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),
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,
95
/* Map BFD relocs to the x86_64 elf relocs. */
98
bfd_reloc_code_real_type bfd_reloc_val;
99
unsigned char elf_reloc_val;
102
static const struct elf_reloc_map x86_64_reloc_map[] =
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, },
120
{ BFD_RELOC_VTABLE_INHERIT, R_X86_64_GNU_VTINHERIT, },
121
{ BFD_RELOC_VTABLE_ENTRY, R_X86_64_GNU_VTENTRY, },
124
static reloc_howto_type *elf64_x86_64_reloc_type_lookup
125
PARAMS ((bfd *, bfd_reloc_code_real_type));
126
static void elf64_x86_64_info_to_howto
127
PARAMS ((bfd *, arelent *, Elf64_Internal_Rela *));
128
static boolean elf64_x86_64_grok_prstatus
129
PARAMS ((bfd *, Elf_Internal_Note *));
130
static boolean elf64_x86_64_grok_psinfo
131
PARAMS ((bfd *, Elf_Internal_Note *));
132
static struct bfd_link_hash_table *elf64_x86_64_link_hash_table_create
134
static boolean elf64_x86_64_elf_object_p PARAMS ((bfd *abfd));
135
static boolean create_got_section
136
PARAMS((bfd *, struct bfd_link_info *));
137
static boolean elf64_x86_64_create_dynamic_sections
138
PARAMS((bfd *, struct bfd_link_info *));
139
static void elf64_x86_64_copy_indirect_symbol
140
PARAMS ((struct elf_link_hash_entry *, struct elf_link_hash_entry *));
141
static boolean elf64_x86_64_check_relocs
142
PARAMS ((bfd *, struct bfd_link_info *, asection *sec,
143
const Elf_Internal_Rela *));
144
static asection *elf64_x86_64_gc_mark_hook
145
PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
146
struct elf_link_hash_entry *, Elf_Internal_Sym *));
148
static boolean elf64_x86_64_gc_sweep_hook
149
PARAMS ((bfd *, struct bfd_link_info *, asection *,
150
const Elf_Internal_Rela *));
152
static struct bfd_hash_entry *link_hash_newfunc
153
PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
154
static boolean elf64_x86_64_adjust_dynamic_symbol
155
PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
157
static boolean allocate_dynrelocs
158
PARAMS ((struct elf_link_hash_entry *, PTR));
159
static boolean readonly_dynrelocs
160
PARAMS ((struct elf_link_hash_entry *, PTR));
161
static boolean elf64_x86_64_size_dynamic_sections
162
PARAMS ((bfd *, struct bfd_link_info *));
163
static boolean elf64_x86_64_relocate_section
164
PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
165
Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
166
static boolean elf64_x86_64_finish_dynamic_symbol
167
PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
168
Elf_Internal_Sym *sym));
169
static boolean elf64_x86_64_finish_dynamic_sections
170
PARAMS ((bfd *, struct bfd_link_info *));
171
static enum elf_reloc_type_class elf64_x86_64_reloc_type_class
172
PARAMS ((const Elf_Internal_Rela *));
174
/* Given a BFD reloc type, return a HOWTO structure. */
175
static reloc_howto_type *
176
elf64_x86_64_reloc_type_lookup (abfd, code)
177
bfd *abfd ATTRIBUTE_UNUSED;
178
bfd_reloc_code_real_type code;
181
for (i = 0; i < sizeof (x86_64_reloc_map) / sizeof (struct elf_reloc_map);
184
if (x86_64_reloc_map[i].bfd_reloc_val == code)
185
return &x86_64_elf_howto_table[i];
190
/* Given an x86_64 ELF reloc type, fill in an arelent structure. */
193
elf64_x86_64_info_to_howto (abfd, cache_ptr, dst)
194
bfd *abfd ATTRIBUTE_UNUSED;
196
Elf64_Internal_Rela *dst;
200
r_type = ELF64_R_TYPE (dst->r_info);
201
if (r_type < (unsigned int) R_X86_64_GNU_VTINHERIT)
203
BFD_ASSERT (r_type <= (unsigned int) R_X86_64_PC8);
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);
211
cache_ptr->howto = &x86_64_elf_howto_table[i];
212
BFD_ASSERT (r_type == cache_ptr->howto->type);
215
/* Support for core dump NOTE sections. */
217
elf64_x86_64_grok_prstatus (abfd, note)
219
Elf_Internal_Note *note;
224
switch (note->descsz)
229
case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
231
elf_tdata (abfd)->core_signal
232
= bfd_get_16 (abfd, note->descdata + 12);
235
elf_tdata (abfd)->core_pid
236
= bfd_get_32 (abfd, note->descdata + 32);
245
/* Make a ".reg/999" section. */
246
return _bfd_elfcore_make_pseudosection (abfd, ".reg",
247
raw_size, note->descpos + offset);
251
elf64_x86_64_grok_psinfo (abfd, note)
253
Elf_Internal_Note *note;
255
switch (note->descsz)
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);
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. */
272
char *command = elf_tdata (abfd)->core_command;
273
int n = strlen (command);
275
if (0 < n && command[n - 1] == ' ')
276
command[n - 1] = '\0';
282
/* Functions for the x86-64 ELF linker. */
284
/* The name of the dynamic interpreter. This is put in the .interp
287
#define ELF_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
289
/* The size in bytes of an entry in the global offset table. */
291
#define GOT_ENTRY_SIZE 8
293
/* The size in bytes of an entry in the procedure linkage table. */
295
#define PLT_ENTRY_SIZE 16
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. */
300
static const bfd_byte elf64_x86_64_plt0_entry[PLT_ENTRY_SIZE] =
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. */
307
/* Subsequent entries in a procedure linkage table look like this. */
309
static const bfd_byte elf64_x86_64_plt_entry[PLT_ENTRY_SIZE] =
311
0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
312
0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
313
0x68, /* pushq immediate */
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. */
319
/* The x86-64 linker needs to keep track of the number of relocs that
320
it decides to copy as dynamic relocs in check_relocs for each symbol.
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. */
325
struct elf64_x86_64_dyn_relocs
328
struct elf64_x86_64_dyn_relocs *next;
330
/* The input section of the reloc. */
333
/* Total number of relocs copied for the input section. */
336
/* Number of pc-relative relocs copied for the input section. */
337
bfd_size_type pc_count;
340
/* x86-64 ELF linker hash entry. */
342
struct elf64_x86_64_link_hash_entry
344
struct elf_link_hash_entry elf;
346
/* Track dynamic relocs copied for this symbol. */
347
struct elf64_x86_64_dyn_relocs *dyn_relocs;
350
/* x86-64 ELF linker hash table. */
352
struct elf64_x86_64_link_hash_table
354
struct elf_link_hash_table elf;
356
/* Short-cuts to get to dynamic linker sections. */
365
/* Small local sym to section mapping cache. */
366
struct sym_sec_cache sym_sec;
369
/* Get the x86-64 ELF linker hash table from a link_info structure. */
371
#define elf64_x86_64_hash_table(p) \
372
((struct elf64_x86_64_link_hash_table *) ((p)->hash))
374
/* Create an entry in an x86-64 ELF linker hash table. */
376
static struct bfd_hash_entry *
377
link_hash_newfunc (entry, table, string)
378
struct bfd_hash_entry *entry;
379
struct bfd_hash_table *table;
382
/* Allocate the structure if it has not already been allocated by a
386
entry = bfd_hash_allocate (table,
387
sizeof (struct elf64_x86_64_link_hash_entry));
392
/* Call the allocation method of the superclass. */
393
entry = _bfd_elf_link_hash_newfunc (entry, table, string);
396
struct elf64_x86_64_link_hash_entry *eh;
398
eh = (struct elf64_x86_64_link_hash_entry *) entry;
399
eh->dyn_relocs = NULL;
405
/* Create an X86-64 ELF linker hash table. */
407
static struct bfd_link_hash_table *
408
elf64_x86_64_link_hash_table_create (abfd)
411
struct elf64_x86_64_link_hash_table *ret;
412
bfd_size_type amt = sizeof (struct elf64_x86_64_link_hash_table);
414
ret = (struct elf64_x86_64_link_hash_table *) bfd_malloc (amt);
418
if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc))
431
ret->sym_sec.abfd = NULL;
433
return &ret->elf.root;
436
/* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
437
shortcuts to them in our hash table. */
440
create_got_section (dynobj, info)
442
struct bfd_link_info *info;
444
struct elf64_x86_64_link_hash_table *htab;
446
if (! _bfd_elf_create_got_section (dynobj, info))
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)
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
461
|| ! bfd_set_section_alignment (dynobj, htab->srelgot, 3))
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
471
elf64_x86_64_create_dynamic_sections (dynobj, info)
473
struct bfd_link_info *info;
475
struct elf64_x86_64_link_hash_table *htab;
477
htab = elf64_x86_64_hash_table (info);
478
if (!htab->sgot && !create_got_section (dynobj, info))
481
if (!_bfd_elf_create_dynamic_sections (dynobj, info))
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");
488
htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
490
if (!htab->splt || !htab->srelplt || !htab->sdynbss
491
|| (!info->shared && !htab->srelbss))
497
/* Copy the extra info we tack onto an elf_link_hash_entry. */
500
elf64_x86_64_copy_indirect_symbol (dir, ind)
501
struct elf_link_hash_entry *dir, *ind;
503
struct elf64_x86_64_link_hash_entry *edir, *eind;
505
edir = (struct elf64_x86_64_link_hash_entry *) dir;
506
eind = (struct elf64_x86_64_link_hash_entry *) ind;
508
if (eind->dyn_relocs != NULL)
510
if (edir->dyn_relocs != NULL)
512
struct elf64_x86_64_dyn_relocs **pp;
513
struct elf64_x86_64_dyn_relocs *p;
515
if (ind->root.type == bfd_link_hash_indirect)
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; )
522
struct elf64_x86_64_dyn_relocs *q;
524
for (q = edir->dyn_relocs; q != NULL; q = q->next)
525
if (q->sec == p->sec)
527
q->pc_count += p->pc_count;
528
q->count += p->count;
535
*pp = edir->dyn_relocs;
538
edir->dyn_relocs = eind->dyn_relocs;
539
eind->dyn_relocs = NULL;
542
_bfd_elf_link_hash_copy_indirect (dir, ind);
546
elf64_x86_64_elf_object_p (abfd)
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);
554
/* Look through the relocs for a section during the first phase, and
555
calculate needed space in the global offset table, procedure
556
linkage table, and dynamic reloc sections. */
559
elf64_x86_64_check_relocs (abfd, info, sec, relocs)
561
struct bfd_link_info *info;
563
const Elf_Internal_Rela *relocs;
565
struct elf64_x86_64_link_hash_table *htab;
566
Elf_Internal_Shdr *symtab_hdr;
567
struct elf_link_hash_entry **sym_hashes;
568
const Elf_Internal_Rela *rel;
569
const Elf_Internal_Rela *rel_end;
572
if (info->relocateable)
575
htab = elf64_x86_64_hash_table (info);
576
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
577
sym_hashes = elf_sym_hashes (abfd);
581
rel_end = relocs + sec->reloc_count;
582
for (rel = relocs; rel < rel_end; rel++)
584
unsigned long r_symndx;
585
struct elf_link_hash_entry *h;
587
r_symndx = ELF64_R_SYM (rel->r_info);
589
if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
591
(*_bfd_error_handler) (_("%s: bad symbol index: %d"),
592
bfd_archive_filename (abfd),
597
if (r_symndx < symtab_hdr->sh_info)
600
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
602
switch (ELF64_R_TYPE (rel->r_info))
605
case R_X86_64_GOTPCREL:
606
/* This symbol requires a global offset table entry. */
609
h->got.refcount += 1;
613
bfd_signed_vma *local_got_refcounts;
615
/* This is a global offset table entry for a local symbol. */
616
local_got_refcounts = elf_local_got_refcounts (abfd);
617
if (local_got_refcounts == NULL)
621
size = symtab_hdr->sh_info;
622
size *= sizeof (bfd_signed_vma);
623
local_got_refcounts = ((bfd_signed_vma *)
624
bfd_zalloc (abfd, size));
625
if (local_got_refcounts == NULL)
627
elf_local_got_refcounts (abfd) = local_got_refcounts;
629
local_got_refcounts[r_symndx] += 1;
633
//case R_X86_64_GOTPCREL:
634
if (htab->sgot == NULL)
636
if (htab->elf.dynobj == NULL)
637
htab->elf.dynobj = abfd;
638
if (!create_got_section (htab->elf.dynobj, info))
644
/* This symbol requires a procedure linkage table entry. We
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
651
/* If this is a local symbol, we resolve it directly without
652
creating a procedure linkage table entry. */
656
h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
657
h->plt.refcount += 1;
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. */
669
&& (sec->flags & SEC_ALLOC) != 0
670
&& (sec->flags & SEC_READONLY) != 0)
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);
685
if (h != NULL && !info->shared)
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;
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;
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
706
including in the link (i.e., DEF_REGULAR is set). At
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
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
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
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))
728
|| h->root.type == bfd_link_hash_defweak
729
|| (h->elf_link_hash_flags
730
& ELF_LINK_HASH_DEF_REGULAR) == 0))))
732
&& (sec->flags & SEC_ALLOC) != 0
734
&& (h->root.type == bfd_link_hash_defweak
735
|| (h->elf_link_hash_flags
736
& ELF_LINK_HASH_DEF_REGULAR) == 0)))
738
struct elf64_x86_64_dyn_relocs *p;
739
struct elf64_x86_64_dyn_relocs **head;
741
/* We must copy these reloc types into the output file.
742
Create a reloc section in dynobj and make room for
749
name = (bfd_elf_string_from_elf_section
751
elf_elfheader (abfd)->e_shstrndx,
752
elf_section_data (sec)->rel_hdr.sh_name));
756
if (strncmp (name, ".rela", 5) != 0
757
|| strcmp (bfd_get_section_name (abfd, sec),
760
(*_bfd_error_handler)
761
(_("%s: bad relocation section name `%s\'"),
762
bfd_archive_filename (abfd), name);
765
if (htab->elf.dynobj == NULL)
766
htab->elf.dynobj = abfd;
768
dynobj = htab->elf.dynobj;
770
sreloc = bfd_get_section_by_name (dynobj, name);
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;
781
|| ! bfd_set_section_flags (dynobj, sreloc, flags)
782
|| ! bfd_set_section_alignment (dynobj, sreloc, 3))
785
elf_section_data (sec)->sreloc = sreloc;
788
/* If this is a global symbol, we count the number of
789
relocations we need for this symbol. */
792
head = &((struct elf64_x86_64_link_hash_entry *) h)->dyn_relocs;
796
/* Track dynamic relocs needed for local syms too.
797
We really need local syms available to do this
801
s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
806
head = ((struct elf64_x86_64_dyn_relocs **)
807
&elf_section_data (s)->local_dynrel);
811
if (p == NULL || p->sec != sec)
813
bfd_size_type amt = sizeof *p;
814
p = ((struct elf64_x86_64_dyn_relocs *)
815
bfd_alloc (htab->elf.dynobj, amt));
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)
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))
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:
843
if (!_bfd_elf64_gc_record_vtentry (abfd, sec, h, rel->r_addend))
855
/* Return the section that should be marked against GC for a given
859
elf64_x86_64_gc_mark_hook (sec, info, rel, h, sym)
861
struct bfd_link_info *info ATTRIBUTE_UNUSED;
862
Elf_Internal_Rela *rel;
863
struct elf_link_hash_entry *h;
864
Elf_Internal_Sym *sym;
868
switch (ELF64_R_TYPE (rel->r_info))
870
case R_X86_64_GNU_VTINHERIT:
871
case R_X86_64_GNU_VTENTRY:
875
switch (h->root.type)
877
case bfd_link_hash_defined:
878
case bfd_link_hash_defweak:
879
return h->root.u.def.section;
881
case bfd_link_hash_common:
882
return h->root.u.c.p->section;
890
return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
895
/* Update the got entry reference counts for the section being removed. */
898
elf64_x86_64_gc_sweep_hook (abfd, info, sec, relocs)
900
struct bfd_link_info *info;
902
const Elf_Internal_Rela *relocs;
904
Elf_Internal_Shdr *symtab_hdr;
905
struct elf_link_hash_entry **sym_hashes;
906
bfd_signed_vma *local_got_refcounts;
907
const Elf_Internal_Rela *rel, *relend;
908
unsigned long r_symndx;
909
struct elf_link_hash_entry *h;
911
elf_section_data (sec)->local_dynrel = NULL;
913
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
914
sym_hashes = elf_sym_hashes (abfd);
915
local_got_refcounts = elf_local_got_refcounts (abfd);
917
relend = relocs + sec->reloc_count;
918
for (rel = relocs; rel < relend; rel++)
919
switch (ELF64_R_TYPE (rel->r_info))
922
case R_X86_64_GOTPCREL:
923
r_symndx = ELF64_R_SYM (rel->r_info);
924
if (r_symndx >= symtab_hdr->sh_info)
926
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
927
if (h->got.refcount > 0)
928
h->got.refcount -= 1;
930
else if (local_got_refcounts != NULL)
932
if (local_got_refcounts[r_symndx] > 0)
933
local_got_refcounts[r_symndx] -= 1;
945
r_symndx = ELF64_R_SYM (rel->r_info);
946
if (r_symndx >= symtab_hdr->sh_info)
948
struct elf64_x86_64_link_hash_entry *eh;
949
struct elf64_x86_64_dyn_relocs **pp;
950
struct elf64_x86_64_dyn_relocs *p;
952
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
954
if (!info->shared && h->plt.refcount > 0)
955
h->plt.refcount -= 1;
957
eh = (struct elf64_x86_64_link_hash_entry *) h;
959
for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
962
if (ELF64_R_TYPE (rel->r_info) == R_X86_64_PC8
963
|| ELF64_R_TYPE (rel->r_info) == R_X86_64_PC16
964
|| ELF64_R_TYPE (rel->r_info) == R_X86_64_PC32)
976
r_symndx = ELF64_R_SYM (rel->r_info);
977
if (r_symndx >= symtab_hdr->sh_info)
979
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
980
if (h->plt.refcount > 0)
981
h->plt.refcount -= 1;
992
/* Adjust a symbol defined by a dynamic object and referenced by a
993
regular object. The current definition is in some section of the
994
dynamic object, but we're not including those sections. We have to
995
change the definition to something the rest of the link can
999
elf64_x86_64_adjust_dynamic_symbol (info, h)
1000
struct bfd_link_info *info;
1001
struct elf_link_hash_entry *h;
1003
struct elf64_x86_64_link_hash_table *htab;
1004
struct elf64_x86_64_link_hash_entry * eh;
1005
struct elf64_x86_64_dyn_relocs *p;
1007
unsigned int power_of_two;
1009
/* If this is a function, put it in the procedure linkage table. We
1010
will fill in the contents of the procedure linkage table later,
1011
when we know the address of the .got section. */
1012
if (h->type == STT_FUNC
1013
|| (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
1015
if (h->plt.refcount <= 0
1017
&& (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
1018
&& (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
1019
&& h->root.type != bfd_link_hash_undefweak
1020
&& h->root.type != bfd_link_hash_undefined))
1022
/* This case can occur if we saw a PLT32 reloc in an input
1023
file, but the symbol was never referred to by a dynamic
1024
object, or if all references were garbage collected. In
1025
such a case, we don't actually need to build a procedure
1026
linkage table, and we can just do a PC32 reloc instead. */
1027
h->plt.offset = (bfd_vma) -1;
1028
h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1034
/* It's possible that we incorrectly decided a .plt reloc was
1035
needed for an R_X86_64_PC32 reloc to a non-function sym in
1036
check_relocs. We can't decide accurately between function and
1037
non-function syms in check-relocs; Objects loaded later in
1038
the link may change h->type. So fix it now. */
1039
h->plt.offset = (bfd_vma) -1;
1041
/* If this is a weak symbol, and there is a real definition, the
1042
processor independent code will have arranged for us to see the
1043
real definition first, and we can just use the same value. */
1044
if (h->weakdef != NULL)
1046
BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1047
|| h->weakdef->root.type == bfd_link_hash_defweak);
1048
h->root.u.def.section = h->weakdef->root.u.def.section;
1049
h->root.u.def.value = h->weakdef->root.u.def.value;
1053
/* This is a reference to a symbol defined by a dynamic object which
1054
is not a function. */
1056
/* If we are creating a shared library, we must presume that the
1057
only references to the symbol are via the global offset table.
1058
For such cases we need not do anything here; the relocations will
1059
be handled correctly by relocate_section. */
1063
/* If there are no references to this symbol that do not use the
1064
GOT, we don't need to generate a copy reloc. */
1065
if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
1068
/* If -z nocopyreloc was given, we won't generate them either. */
1069
if (info->nocopyreloc)
1071
h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1075
eh = (struct elf64_x86_64_link_hash_entry *) h;
1076
for (p = eh->dyn_relocs; p != NULL; p = p->next)
1078
s = p->sec->output_section;
1079
if (s != NULL && (s->flags & SEC_READONLY) != 0)
1083
/* If we didn't find any dynamic relocs in read-only sections, then
1084
we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1087
h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1091
/* We must allocate the symbol in our .dynbss section, which will
1092
become part of the .bss section of the executable. There will be
1093
an entry for this symbol in the .dynsym section. The dynamic
1094
object will contain position independent code, so all references
1095
from the dynamic object to this symbol will go through the global
1096
offset table. The dynamic linker will use the .dynsym entry to
1097
determine the address it must put in the global offset table, so
1098
both the dynamic object and the regular object will refer to the
1099
same memory location for the variable. */
1101
htab = elf64_x86_64_hash_table (info);
1103
/* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
1104
to copy the initial value out of the dynamic object and into the
1105
runtime process image. */
1106
if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1108
htab->srelbss->_raw_size += sizeof (Elf64_External_Rela);
1109
h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1112
/* We need to figure out the alignment required for this symbol. I
1113
have no idea how ELF linkers handle this. 16-bytes is the size
1114
of the largest type that requires hard alignment -- long double. */
1115
/* FIXME: This is VERY ugly. Should be fixed for all architectures using
1117
power_of_two = bfd_log2 (h->size);
1118
if (power_of_two > 4)
1121
/* Apply the required alignment. */
1123
s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
1124
if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
1126
if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
1130
/* Define the symbol as being at this point in the section. */
1131
h->root.u.def.section = s;
1132
h->root.u.def.value = s->_raw_size;
1134
/* Increment the section size to make room for the symbol. */
1135
s->_raw_size += h->size;
1140
/* This is the condition under which elf64_x86_64_finish_dynamic_symbol
1141
will be called from elflink.h. If elflink.h doesn't call our
1142
finish_dynamic_symbol routine, we'll need to do something about
1143
initializing any .plt and .got entries in elf64_x86_64_relocate_section. */
1144
#define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1146
&& ((INFO)->shared \
1147
|| ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1148
&& ((H)->dynindx != -1 \
1149
|| ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1151
/* Allocate space in .plt, .got and associated reloc sections for
1155
allocate_dynrelocs (h, inf)
1156
struct elf_link_hash_entry *h;
1159
struct bfd_link_info *info;
1160
struct elf64_x86_64_link_hash_table *htab;
1161
struct elf64_x86_64_link_hash_entry *eh;
1162
struct elf64_x86_64_dyn_relocs *p;
1164
if (h->root.type == bfd_link_hash_indirect)
1167
if (h->root.type == bfd_link_hash_warning)
1168
h = (struct elf_link_hash_entry *) h->root.u.i.link;
1170
info = (struct bfd_link_info *) inf;
1171
htab = elf64_x86_64_hash_table (info);
1173
if (htab->elf.dynamic_sections_created
1174
&& h->plt.refcount > 0)
1176
/* Make sure this symbol is output as a dynamic symbol.
1177
Undefined weak syms won't yet be marked as dynamic. */
1178
if (h->dynindx == -1
1179
&& (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1181
if (! bfd_elf64_link_record_dynamic_symbol (info, h))
1185
if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
1187
asection *s = htab->splt;
1189
/* If this is the first .plt entry, make room for the special
1191
if (s->_raw_size == 0)
1192
s->_raw_size += PLT_ENTRY_SIZE;
1194
h->plt.offset = s->_raw_size;
1196
/* If this symbol is not defined in a regular file, and we are
1197
not generating a shared library, then set the symbol to this
1198
location in the .plt. This is required to make function
1199
pointers compare as equal between the normal executable and
1200
the shared library. */
1202
&& (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1204
h->root.u.def.section = s;
1205
h->root.u.def.value = h->plt.offset;
1208
/* Make room for this entry. */
1209
s->_raw_size += PLT_ENTRY_SIZE;
1211
/* We also need to make an entry in the .got.plt section, which
1212
will be placed in the .got section by the linker script. */
1213
htab->sgotplt->_raw_size += GOT_ENTRY_SIZE;
1215
/* We also need to make an entry in the .rela.plt section. */
1216
htab->srelplt->_raw_size += sizeof (Elf64_External_Rela);
1220
h->plt.offset = (bfd_vma) -1;
1221
h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1226
h->plt.offset = (bfd_vma) -1;
1227
h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1230
if (h->got.refcount > 0)
1235
/* Make sure this symbol is output as a dynamic symbol.
1236
Undefined weak syms won't yet be marked as dynamic. */
1237
if (h->dynindx == -1
1238
&& (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1240
if (! bfd_elf64_link_record_dynamic_symbol (info, h))
1245
h->got.offset = s->_raw_size;
1246
s->_raw_size += GOT_ENTRY_SIZE;
1247
dyn = htab->elf.dynamic_sections_created;
1248
if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
1249
htab->srelgot->_raw_size += sizeof (Elf64_External_Rela);
1252
h->got.offset = (bfd_vma) -1;
1254
eh = (struct elf64_x86_64_link_hash_entry *) h;
1255
if (eh->dyn_relocs == NULL)
1258
/* In the shared -Bsymbolic case, discard space allocated for
1259
dynamic pc-relative relocs against symbols which turn out to be
1260
defined in regular objects. For the normal shared case, discard
1261
space for pc-relative relocs that have become local due to symbol
1262
visibility changes. */
1266
if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1267
&& ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1270
struct elf64_x86_64_dyn_relocs **pp;
1272
for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1274
p->count -= p->pc_count;
1285
/* For the non-shared case, discard space for relocs against
1286
symbols which turn out to need copy relocs or are not
1289
if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1290
&& (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1291
&& (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1292
|| (htab->elf.dynamic_sections_created
1293
&& (h->root.type == bfd_link_hash_undefweak
1294
|| h->root.type == bfd_link_hash_undefined))))
1296
/* Make sure this symbol is output as a dynamic symbol.
1297
Undefined weak syms won't yet be marked as dynamic. */
1298
if (h->dynindx == -1
1299
&& (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1301
if (! bfd_elf64_link_record_dynamic_symbol (info, h))
1305
/* If that succeeded, we know we'll be keeping all the
1307
if (h->dynindx != -1)
1311
eh->dyn_relocs = NULL;
1316
/* Finally, allocate space. */
1317
for (p = eh->dyn_relocs; p != NULL; p = p->next)
1319
asection *sreloc = elf_section_data (p->sec)->sreloc;
1320
sreloc->_raw_size += p->count * sizeof (Elf64_External_Rela);
1326
/* Find any dynamic relocs that apply to read-only sections. */
1329
readonly_dynrelocs (h, inf)
1330
struct elf_link_hash_entry *h;
1333
struct elf64_x86_64_link_hash_entry *eh;
1334
struct elf64_x86_64_dyn_relocs *p;
1336
if (h->root.type == bfd_link_hash_warning)
1337
h = (struct elf_link_hash_entry *) h->root.u.i.link;
1339
eh = (struct elf64_x86_64_link_hash_entry *) h;
1340
for (p = eh->dyn_relocs; p != NULL; p = p->next)
1342
asection *s = p->sec->output_section;
1344
if (s != NULL && (s->flags & SEC_READONLY) != 0)
1346
struct bfd_link_info *info = (struct bfd_link_info *) inf;
1348
info->flags |= DF_TEXTREL;
1350
/* Not an error, just cut short the traversal. */
1357
/* Set the sizes of the dynamic sections. */
1360
elf64_x86_64_size_dynamic_sections (output_bfd, info)
1361
bfd *output_bfd ATTRIBUTE_UNUSED;
1362
struct bfd_link_info *info;
1364
struct elf64_x86_64_link_hash_table *htab;
1370
htab = elf64_x86_64_hash_table (info);
1371
dynobj = htab->elf.dynobj;
1375
if (htab->elf.dynamic_sections_created)
1377
/* Set the contents of the .interp section to the interpreter. */
1380
s = bfd_get_section_by_name (dynobj, ".interp");
1383
s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1384
s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1388
/* Set up .got offsets for local syms, and space for local dynamic
1390
for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1392
bfd_signed_vma *local_got;
1393
bfd_signed_vma *end_local_got;
1394
bfd_size_type locsymcount;
1395
Elf_Internal_Shdr *symtab_hdr;
1398
if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1401
for (s = ibfd->sections; s != NULL; s = s->next)
1403
struct elf64_x86_64_dyn_relocs *p;
1405
for (p = *((struct elf64_x86_64_dyn_relocs **)
1406
&elf_section_data (s)->local_dynrel);
1410
if (!bfd_is_abs_section (p->sec)
1411
&& bfd_is_abs_section (p->sec->output_section))
1413
/* Input section has been discarded, either because
1414
it is a copy of a linkonce section or due to
1415
linker script /DISCARD/, so we'll be discarding
1418
else if (p->count != 0)
1420
srel = elf_section_data (p->sec)->sreloc;
1421
srel->_raw_size += p->count * sizeof (Elf64_External_Rela);
1422
if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1423
info->flags |= DF_TEXTREL;
1429
local_got = elf_local_got_refcounts (ibfd);
1433
symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1434
locsymcount = symtab_hdr->sh_info;
1435
end_local_got = local_got + locsymcount;
1437
srel = htab->srelgot;
1438
for (; local_got < end_local_got; ++local_got)
1442
*local_got = s->_raw_size;
1443
s->_raw_size += GOT_ENTRY_SIZE;
1445
srel->_raw_size += sizeof (Elf64_External_Rela);
1448
*local_got = (bfd_vma) -1;
1452
/* Allocate global sym .plt and .got entries, and space for global
1453
sym dynamic relocs. */
1454
elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
1456
/* We now have determined the sizes of the various dynamic sections.
1457
Allocate memory for them. */
1459
for (s = dynobj->sections; s != NULL; s = s->next)
1461
if ((s->flags & SEC_LINKER_CREATED) == 0)
1466
|| s == htab->sgotplt)
1468
/* Strip this section if we don't need it; see the
1471
else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
1473
if (s->_raw_size != 0 && s != htab->srelplt)
1476
/* We use the reloc_count field as a counter if we need
1477
to copy relocs into the output file. */
1482
/* It's not one of our sections, so don't allocate space. */
1486
if (s->_raw_size == 0)
1488
/* If we don't need this section, strip it from the
1489
output file. This is mostly to handle .rela.bss and
1490
.rela.plt. We must create both sections in
1491
create_dynamic_sections, because they must be created
1492
before the linker maps input sections to output
1493
sections. The linker does that before
1494
adjust_dynamic_symbol is called, and it is that
1495
function which decides whether anything needs to go
1496
into these sections. */
1498
_bfd_strip_section_from_output (info, s);
1502
/* Allocate memory for the section contents. We use bfd_zalloc
1503
here in case unused entries are not reclaimed before the
1504
section's contents are written out. This should not happen,
1505
but this way if it does, we get a R_X86_64_NONE reloc instead
1507
s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1508
if (s->contents == NULL)
1512
if (htab->elf.dynamic_sections_created)
1514
/* Add some entries to the .dynamic section. We fill in the
1515
values later, in elf64_x86_64_finish_dynamic_sections, but we
1516
must add the entries now so that we get the correct size for
1517
the .dynamic section. The DT_DEBUG entry is filled in by the
1518
dynamic linker and used by the debugger. */
1519
#define add_dynamic_entry(TAG, VAL) \
1520
bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1524
if (!add_dynamic_entry (DT_DEBUG, 0))
1528
if (htab->splt->_raw_size != 0)
1530
if (!add_dynamic_entry (DT_PLTGOT, 0)
1531
|| !add_dynamic_entry (DT_PLTRELSZ, 0)
1532
|| !add_dynamic_entry (DT_PLTREL, DT_RELA)
1533
|| !add_dynamic_entry (DT_JMPREL, 0))
1539
if (!add_dynamic_entry (DT_RELA, 0)
1540
|| !add_dynamic_entry (DT_RELASZ, 0)
1541
|| !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
1544
/* If any dynamic relocs apply to a read-only section,
1545
then we need a DT_TEXTREL entry. */
1546
if ((info->flags & DF_TEXTREL) == 0)
1547
elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
1550
if ((info->flags & DF_TEXTREL) != 0)
1552
if (!add_dynamic_entry (DT_TEXTREL, 0))
1557
#undef add_dynamic_entry
1562
/* Relocate an x86_64 ELF section. */
1565
elf64_x86_64_relocate_section (output_bfd, info, input_bfd, input_section,
1566
contents, relocs, local_syms, local_sections)
1568
struct bfd_link_info *info;
1570
asection *input_section;
1572
Elf_Internal_Rela *relocs;
1573
Elf_Internal_Sym *local_syms;
1574
asection **local_sections;
1576
struct elf64_x86_64_link_hash_table *htab;
1577
Elf_Internal_Shdr *symtab_hdr;
1578
struct elf_link_hash_entry **sym_hashes;
1579
bfd_vma *local_got_offsets;
1580
Elf_Internal_Rela *rel;
1581
Elf_Internal_Rela *relend;
1583
if (info->relocateable)
1586
htab = elf64_x86_64_hash_table (info);
1587
symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1588
sym_hashes = elf_sym_hashes (input_bfd);
1589
local_got_offsets = elf_local_got_offsets (input_bfd);
1592
relend = relocs + input_section->reloc_count;
1593
for (; rel < relend; rel++)
1596
reloc_howto_type *howto;
1597
unsigned long r_symndx;
1598
struct elf_link_hash_entry *h;
1599
Elf_Internal_Sym *sym;
1603
boolean unresolved_reloc;
1604
bfd_reloc_status_type r;
1606
r_type = ELF64_R_TYPE (rel->r_info);
1607
if (r_type == (int) R_X86_64_GNU_VTINHERIT
1608
|| r_type == (int) R_X86_64_GNU_VTENTRY)
1611
if (r_type < 0 || r_type >= R_X86_64_max)
1613
bfd_set_error (bfd_error_bad_value);
1617
howto = x86_64_elf_howto_table + r_type;
1618
r_symndx = ELF64_R_SYM (rel->r_info);
1622
unresolved_reloc = false;
1623
if (r_symndx < symtab_hdr->sh_info)
1625
sym = local_syms + r_symndx;
1626
sec = local_sections[r_symndx];
1628
relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1632
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1633
while (h->root.type == bfd_link_hash_indirect
1634
|| h->root.type == bfd_link_hash_warning)
1635
h = (struct elf_link_hash_entry *) h->root.u.i.link;
1637
if (h->root.type == bfd_link_hash_defined
1638
|| h->root.type == bfd_link_hash_defweak)
1640
sec = h->root.u.def.section;
1641
if (sec->output_section == NULL)
1643
/* Set a flag that will be cleared later if we find a
1644
relocation value for this symbol. output_section
1645
is typically NULL for symbols satisfied by a shared
1647
unresolved_reloc = true;
1651
relocation = (h->root.u.def.value
1652
+ sec->output_section->vma
1653
+ sec->output_offset);
1655
else if (h->root.type == bfd_link_hash_undefweak)
1657
else if (info->shared
1658
&& (!info->symbolic || info->allow_shlib_undefined)
1659
&& !info->no_undefined
1660
&& ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1664
if (! ((*info->callbacks->undefined_symbol)
1665
(info, h->root.root.string, input_bfd,
1666
input_section, rel->r_offset,
1667
(!info->shared || info->no_undefined
1668
|| ELF_ST_VISIBILITY (h->other)))))
1673
/* When generating a shared object, the relocations handled here are
1674
copied into the output file to be resolved at run time. */
1677
case R_X86_64_GOT32:
1678
/* Relocation is to the entry for this symbol in the global
1680
case R_X86_64_GOTPCREL:
1681
/* Use global offset table as symbol value. */
1682
if (htab->sgot == NULL)
1689
off = h->got.offset;
1690
dyn = htab->elf.dynamic_sections_created;
1692
if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
1696
|| (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
1697
&& (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1699
/* This is actually a static link, or it is a -Bsymbolic
1700
link and the symbol is defined locally, or the symbol
1701
was forced to be local because of a version file. We
1702
must initialize this entry in the global offset table.
1703
Since the offset must always be a multiple of 8, we
1704
use the least significant bit to record whether we
1705
have initialized it already.
1707
When doing a dynamic link, we create a .rela.got
1708
relocation entry to initialize the value. This is
1709
done in the finish_dynamic_symbol routine. */
1714
bfd_put_64 (output_bfd, relocation,
1715
htab->sgot->contents + off);
1720
unresolved_reloc = false;
1724
if (local_got_offsets == NULL)
1727
off = local_got_offsets[r_symndx];
1729
/* The offset must always be a multiple of 8. We use
1730
the least significant bit to record whether we have
1731
already generated the necessary reloc. */
1736
bfd_put_64 (output_bfd, relocation,
1737
htab->sgot->contents + off);
1742
Elf_Internal_Rela outrel;
1743
Elf64_External_Rela *loc;
1745
/* We need to generate a R_X86_64_RELATIVE reloc
1746
for the dynamic linker. */
1747
srelgot = htab->srelgot;
1748
if (srelgot == NULL)
1751
outrel.r_offset = (htab->sgot->output_section->vma
1752
+ htab->sgot->output_offset
1754
outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
1755
outrel.r_addend = relocation;
1756
loc = (Elf64_External_Rela *) srelgot->contents;
1757
loc += srelgot->reloc_count++;
1758
bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
1761
local_got_offsets[r_symndx] |= 1;
1765
if (off >= (bfd_vma) -2)
1768
relocation = htab->sgot->output_offset + off;
1769
if (r_type == R_X86_64_GOTPCREL)
1770
relocation += htab->sgot->output_section->vma;
1774
case R_X86_64_PLT32:
1775
/* Relocation is to the entry for this symbol in the
1776
procedure linkage table. */
1778
/* Resolve a PLT32 reloc against a local symbol directly,
1779
without using the procedure linkage table. */
1783
if (h->plt.offset == (bfd_vma) -1
1784
|| htab->splt == NULL)
1786
/* We didn't make a PLT entry for this symbol. This
1787
happens when statically linking PIC code, or when
1788
using -Bsymbolic. */
1792
relocation = (htab->splt->output_section->vma
1793
+ htab->splt->output_offset
1795
unresolved_reloc = false;
1805
/* FIXME: The ABI says the linker should make sure the value is
1806
the same when it's zeroextended to 64 bit. */
1808
/* r_symndx will be zero only for relocs against symbols
1809
from removed linkonce sections, or sections discarded by
1812
|| (input_section->flags & SEC_ALLOC) == 0)
1816
&& ((r_type != R_X86_64_PC8
1817
&& r_type != R_X86_64_PC16
1818
&& r_type != R_X86_64_PC32)
1821
&& (! info->symbolic
1822
|| (h->elf_link_hash_flags
1823
& ELF_LINK_HASH_DEF_REGULAR) == 0))))
1827
&& (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1828
&& (((h->elf_link_hash_flags
1829
& ELF_LINK_HASH_DEF_DYNAMIC) != 0
1830
&& (h->elf_link_hash_flags
1831
& ELF_LINK_HASH_DEF_REGULAR) == 0)
1832
|| h->root.type == bfd_link_hash_undefweak
1833
|| h->root.type == bfd_link_hash_undefined)))
1835
Elf_Internal_Rela outrel;
1836
boolean skip, relocate;
1838
Elf64_External_Rela *loc;
1840
/* When generating a shared object, these relocations
1841
are copied into the output file to be resolved at run
1848
_bfd_elf_section_offset (output_bfd, info, input_section,
1850
if (outrel.r_offset == (bfd_vma) -1)
1852
else if (outrel.r_offset == (bfd_vma) -2)
1853
skip = true, relocate = true;
1855
outrel.r_offset += (input_section->output_section->vma
1856
+ input_section->output_offset);
1859
memset (&outrel, 0, sizeof outrel);
1861
/* h->dynindx may be -1 if this symbol was marked to
1865
&& (r_type == R_X86_64_PC8
1866
|| r_type == R_X86_64_PC16
1867
|| r_type == R_X86_64_PC32
1870
|| (h->elf_link_hash_flags
1871
& ELF_LINK_HASH_DEF_REGULAR) == 0))
1873
outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
1874
outrel.r_addend = rel->r_addend;
1878
/* This symbol is local, or marked to become local. */
1879
if (r_type == R_X86_64_64)
1882
outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
1883
outrel.r_addend = relocation + rel->r_addend;
1890
sec = local_sections[r_symndx];
1893
BFD_ASSERT (h->root.type == bfd_link_hash_defined
1895
== bfd_link_hash_defweak));
1896
sec = h->root.u.def.section;
1898
if (sec != NULL && bfd_is_abs_section (sec))
1900
else if (sec == NULL || sec->owner == NULL)
1902
bfd_set_error (bfd_error_bad_value);
1909
osec = sec->output_section;
1910
sindx = elf_section_data (osec)->dynindx;
1911
BFD_ASSERT (sindx > 0);
1914
outrel.r_info = ELF64_R_INFO (sindx, r_type);
1915
outrel.r_addend = relocation + rel->r_addend;
1919
sreloc = elf_section_data (input_section)->sreloc;
1923
loc = (Elf64_External_Rela *) sreloc->contents;
1924
loc += sreloc->reloc_count++;
1925
bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
1927
/* If this reloc is against an external symbol, we do
1928
not want to fiddle with the addend. Otherwise, we
1929
need to include the symbol value so that it becomes
1930
an addend for the dynamic reloc. */
1941
/* Dynamic relocs are not propagated for SEC_DEBUGGING sections
1942
because such sections are not SEC_ALLOC and thus ld.so will
1943
not process them. */
1944
if (unresolved_reloc
1945
&& !((input_section->flags & SEC_DEBUGGING) != 0
1946
&& (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
1947
(*_bfd_error_handler)
1948
(_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
1949
bfd_archive_filename (input_bfd),
1950
bfd_get_section_name (input_bfd, input_section),
1951
(long) rel->r_offset,
1952
h->root.root.string);
1954
r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1955
contents, rel->r_offset,
1956
relocation, rel->r_addend);
1958
if (r != bfd_reloc_ok)
1963
name = h->root.root.string;
1966
name = bfd_elf_string_from_elf_section (input_bfd,
1967
symtab_hdr->sh_link,
1972
name = bfd_section_name (input_bfd, sec);
1975
if (r == bfd_reloc_overflow)
1978
if (! ((*info->callbacks->reloc_overflow)
1979
(info, name, howto->name, (bfd_vma) 0,
1980
input_bfd, input_section, rel->r_offset)))
1985
(*_bfd_error_handler)
1986
(_("%s(%s+0x%lx): reloc against `%s': error %d"),
1987
bfd_archive_filename (input_bfd),
1988
bfd_get_section_name (input_bfd, input_section),
1989
(long) rel->r_offset, name, (int) r);
1998
/* Finish up dynamic symbol handling. We set the contents of various
1999
dynamic sections here. */
2002
elf64_x86_64_finish_dynamic_symbol (output_bfd, info, h, sym)
2004
struct bfd_link_info *info;
2005
struct elf_link_hash_entry *h;
2006
Elf_Internal_Sym *sym;
2008
struct elf64_x86_64_link_hash_table *htab;
2010
htab = elf64_x86_64_hash_table (info);
2012
if (h->plt.offset != (bfd_vma) -1)
2016
Elf_Internal_Rela rela;
2017
Elf64_External_Rela *loc;
2019
/* This symbol has an entry in the procedure linkage table. Set
2022
if (h->dynindx == -1
2023
|| htab->splt == NULL
2024
|| htab->sgotplt == NULL
2025
|| htab->srelplt == NULL)
2028
/* Get the index in the procedure linkage table which
2029
corresponds to this symbol. This is the index of this symbol
2030
in all the symbols for which we are making plt entries. The
2031
first entry in the procedure linkage table is reserved. */
2032
plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2034
/* Get the offset into the .got table of the entry that
2035
corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
2036
bytes. The first three are reserved for the dynamic linker. */
2037
got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
2039
/* Fill in the entry in the procedure linkage table. */
2040
memcpy (htab->splt->contents + h->plt.offset, elf64_x86_64_plt_entry,
2043
/* Insert the relocation positions of the plt section. The magic
2044
numbers at the end of the statements are the positions of the
2045
relocations in the plt section. */
2046
/* Put offset for jmp *name@GOTPCREL(%rip), since the
2047
instruction uses 6 bytes, subtract this value. */
2048
bfd_put_32 (output_bfd,
2049
(htab->sgotplt->output_section->vma
2050
+ htab->sgotplt->output_offset
2052
- htab->splt->output_section->vma
2053
- htab->splt->output_offset
2056
htab->splt->contents + h->plt.offset + 2);
2057
/* Put relocation index. */
2058
bfd_put_32 (output_bfd, plt_index,
2059
htab->splt->contents + h->plt.offset + 7);
2060
/* Put offset for jmp .PLT0. */
2061
bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
2062
htab->splt->contents + h->plt.offset + 12);
2064
/* Fill in the entry in the global offset table, initially this
2065
points to the pushq instruction in the PLT which is at offset 6. */
2066
bfd_put_64 (output_bfd, (htab->splt->output_section->vma
2067
+ htab->splt->output_offset
2068
+ h->plt.offset + 6),
2069
htab->sgotplt->contents + got_offset);
2071
/* Fill in the entry in the .rela.plt section. */
2072
rela.r_offset = (htab->sgotplt->output_section->vma
2073
+ htab->sgotplt->output_offset
2075
rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_JUMP_SLOT);
2077
loc = (Elf64_External_Rela *) htab->srelplt->contents + plt_index;
2078
bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
2080
if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2082
/* Mark the symbol as undefined, rather than as defined in
2083
the .plt section. Leave the value alone. This is a clue
2084
for the dynamic linker, to make function pointer
2085
comparisons work between an application and shared
2087
sym->st_shndx = SHN_UNDEF;
2091
if (h->got.offset != (bfd_vma) -1)
2093
Elf_Internal_Rela rela;
2094
Elf64_External_Rela *loc;
2096
/* This symbol has an entry in the global offset table. Set it
2099
if (htab->sgot == NULL || htab->srelgot == NULL)
2102
rela.r_offset = (htab->sgot->output_section->vma
2103
+ htab->sgot->output_offset
2104
+ (h->got.offset &~ (bfd_vma) 1));
2106
/* If this is a static link, or it is a -Bsymbolic link and the
2107
symbol is defined locally or was forced to be local because
2108
of a version file, we just want to emit a RELATIVE reloc.
2109
The entry in the global offset table will already have been
2110
initialized in the relocate_section function. */
2114
|| (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2115
&& (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
2117
BFD_ASSERT((h->got.offset & 1) != 0);
2118
rela.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
2119
rela.r_addend = (h->root.u.def.value
2120
+ h->root.u.def.section->output_section->vma
2121
+ h->root.u.def.section->output_offset);
2125
BFD_ASSERT((h->got.offset & 1) == 0);
2126
bfd_put_64 (output_bfd, (bfd_vma) 0,
2127
htab->sgot->contents + h->got.offset);
2128
rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_GLOB_DAT);
2132
loc = (Elf64_External_Rela *) htab->srelgot->contents;
2133
loc += htab->srelgot->reloc_count++;
2134
bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
2137
if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2139
Elf_Internal_Rela rela;
2140
Elf64_External_Rela *loc;
2142
/* This symbol needs a copy reloc. Set it up. */
2144
if (h->dynindx == -1
2145
|| (h->root.type != bfd_link_hash_defined
2146
&& h->root.type != bfd_link_hash_defweak)
2147
|| htab->srelbss == NULL)
2150
rela.r_offset = (h->root.u.def.value
2151
+ h->root.u.def.section->output_section->vma
2152
+ h->root.u.def.section->output_offset);
2153
rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_COPY);
2155
loc = (Elf64_External_Rela *) htab->srelbss->contents;
2156
loc += htab->srelbss->reloc_count++;
2157
bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
2160
/* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2161
if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2162
|| strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2163
sym->st_shndx = SHN_ABS;
2168
/* Used to decide how to sort relocs in an optimal manner for the
2169
dynamic linker, before writing them out. */
2171
static enum elf_reloc_type_class
2172
elf64_x86_64_reloc_type_class (rela)
2173
const Elf_Internal_Rela *rela;
2175
switch ((int) ELF64_R_TYPE (rela->r_info))
2177
case R_X86_64_RELATIVE:
2178
return reloc_class_relative;
2179
case R_X86_64_JUMP_SLOT:
2180
return reloc_class_plt;
2182
return reloc_class_copy;
2184
return reloc_class_normal;
2188
/* Finish up the dynamic sections. */
2191
elf64_x86_64_finish_dynamic_sections (output_bfd, info)
2193
struct bfd_link_info *info;
2195
struct elf64_x86_64_link_hash_table *htab;
2199
htab = elf64_x86_64_hash_table (info);
2200
dynobj = htab->elf.dynobj;
2201
sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2203
if (htab->elf.dynamic_sections_created)
2205
Elf64_External_Dyn *dyncon, *dynconend;
2207
if (sdyn == NULL || htab->sgot == NULL)
2210
dyncon = (Elf64_External_Dyn *) sdyn->contents;
2211
dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2212
for (; dyncon < dynconend; dyncon++)
2214
Elf_Internal_Dyn dyn;
2217
bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
2225
dyn.d_un.d_ptr = htab->sgot->output_section->vma;
2229
dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
2233
s = htab->srelplt->output_section;
2234
if (s->_cooked_size != 0)
2235
dyn.d_un.d_val = s->_cooked_size;
2237
dyn.d_un.d_val = s->_raw_size;
2241
/* The procedure linkage table relocs (DT_JMPREL) should
2242
not be included in the overall relocs (DT_RELA).
2243
Therefore, we override the DT_RELASZ entry here to
2244
make it not include the JMPREL relocs. Since the
2245
linker script arranges for .rela.plt to follow all
2246
other relocation sections, we don't have to worry
2247
about changing the DT_RELA entry. */
2248
if (htab->srelplt != NULL)
2250
s = htab->srelplt->output_section;
2251
if (s->_cooked_size != 0)
2252
dyn.d_un.d_val -= s->_cooked_size;
2254
dyn.d_un.d_val -= s->_raw_size;
2259
bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2262
/* Fill in the special first entry in the procedure linkage table. */
2263
if (htab->splt && htab->splt->_raw_size > 0)
2265
/* Fill in the first entry in the procedure linkage table. */
2266
memcpy (htab->splt->contents, elf64_x86_64_plt0_entry,
2268
/* Add offset for pushq GOT+8(%rip), since the instruction
2269
uses 6 bytes subtract this value. */
2270
bfd_put_32 (output_bfd,
2271
(htab->sgotplt->output_section->vma
2272
+ htab->sgotplt->output_offset
2274
- htab->splt->output_section->vma
2275
- htab->splt->output_offset
2277
htab->splt->contents + 2);
2278
/* Add offset for jmp *GOT+16(%rip). The 12 is the offset to
2279
the end of the instruction. */
2280
bfd_put_32 (output_bfd,
2281
(htab->sgotplt->output_section->vma
2282
+ htab->sgotplt->output_offset
2284
- htab->splt->output_section->vma
2285
- htab->splt->output_offset
2287
htab->splt->contents + 8);
2289
elf_section_data (htab->splt->output_section)->this_hdr.sh_entsize =
2296
/* Fill in the first three entries in the global offset table. */
2297
if (htab->sgotplt->_raw_size > 0)
2299
/* Set the first entry in the global offset table to the address of
2300
the dynamic section. */
2302
bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents);
2304
bfd_put_64 (output_bfd,
2305
sdyn->output_section->vma + sdyn->output_offset,
2306
htab->sgotplt->contents);
2307
/* Write GOT[1] and GOT[2], needed for the dynamic linker. */
2308
bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + GOT_ENTRY_SIZE);
2309
bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + GOT_ENTRY_SIZE*2);
2312
elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize =
2320
#define TARGET_LITTLE_SYM bfd_elf64_x86_64_vec
2321
#define TARGET_LITTLE_NAME "elf64-x86-64"
2322
#define ELF_ARCH bfd_arch_i386
2323
#define ELF_MACHINE_CODE EM_X86_64
2324
#define ELF_MAXPAGESIZE 0x100000
2326
#define elf_backend_can_gc_sections 1
2327
#define elf_backend_can_refcount 1
2328
#define elf_backend_want_got_plt 1
2329
#define elf_backend_plt_readonly 1
2330
#define elf_backend_want_plt_sym 0
2331
#define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
2332
#define elf_backend_plt_header_size PLT_ENTRY_SIZE
2333
#define elf_backend_rela_normal 1
2335
#define elf_info_to_howto elf64_x86_64_info_to_howto
2337
#define bfd_elf64_bfd_link_hash_table_create \
2338
elf64_x86_64_link_hash_table_create
2339
#define bfd_elf64_bfd_reloc_type_lookup elf64_x86_64_reloc_type_lookup
2341
#define elf_backend_adjust_dynamic_symbol elf64_x86_64_adjust_dynamic_symbol
2342
#define elf_backend_check_relocs elf64_x86_64_check_relocs
2343
#define elf_backend_copy_indirect_symbol elf64_x86_64_copy_indirect_symbol
2344
#define elf_backend_create_dynamic_sections elf64_x86_64_create_dynamic_sections
2345
#define elf_backend_finish_dynamic_sections elf64_x86_64_finish_dynamic_sections
2346
#define elf_backend_finish_dynamic_symbol elf64_x86_64_finish_dynamic_symbol
2347
#define elf_backend_gc_mark_hook elf64_x86_64_gc_mark_hook
2348
#define elf_backend_gc_sweep_hook elf64_x86_64_gc_sweep_hook
2349
#define elf_backend_grok_prstatus elf64_x86_64_grok_prstatus
2350
#define elf_backend_grok_psinfo elf64_x86_64_grok_psinfo
2351
#define elf_backend_reloc_type_class elf64_x86_64_reloc_type_class
2352
#define elf_backend_relocate_section elf64_x86_64_relocate_section
2353
#define elf_backend_size_dynamic_sections elf64_x86_64_size_dynamic_sections
2354
#define elf_backend_object_p elf64_x86_64_elf_object_p
2356
#include "elf64-target.h"
added
removed
binutils/bfd/elf64-x86-64.c
