1 /* X86-64 specific support for 64-bit ELF
2 Copyright 2000, 2001 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. */
26 #include "elf/x86-64.h"
28 /* We use only the RELA entries. */
31 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
32 #define MINUS_ONE (~ (bfd_vma) 0)
34 /* The relocation "howto" table. Order of fields:
35 type, size, bitsize, pc_relative, complain_on_overflow,
36 special_function, name, partial_inplace, src_mask, dst_pack, pcrel_offset. */
37 static reloc_howto_type x86_64_elf_howto_table[] =
39 HOWTO(R_X86_64_NONE, 0, 0, 0, false, 0, complain_overflow_dont,
40 bfd_elf_generic_reloc, "R_X86_64_NONE", false, 0x00000000, 0x00000000,
42 HOWTO(R_X86_64_64, 0, 4, 64, false, 0, complain_overflow_bitfield,
43 bfd_elf_generic_reloc, "R_X86_64_64", false, MINUS_ONE, MINUS_ONE,
45 HOWTO(R_X86_64_PC32, 0, 4, 32, true, 0, complain_overflow_signed,
46 bfd_elf_generic_reloc, "R_X86_64_PC32", false, 0xffffffff, 0xffffffff,
48 HOWTO(R_X86_64_GOT32, 0, 4, 32, false, 0, complain_overflow_signed,
49 bfd_elf_generic_reloc, "R_X86_64_GOT32", false, 0xffffffff, 0xffffffff,
51 HOWTO(R_X86_64_PLT32, 0, 4, 32, true, 0, complain_overflow_signed,
52 bfd_elf_generic_reloc, "R_X86_64_PLT32", false, 0xffffffff, 0xffffffff,
54 HOWTO(R_X86_64_COPY, 0, 4, 32, false, 0, complain_overflow_bitfield,
55 bfd_elf_generic_reloc, "R_X86_64_COPY", false, 0xffffffff, 0xffffffff,
57 HOWTO(R_X86_64_GLOB_DAT, 0, 4, 64, false, 0, complain_overflow_bitfield,
58 bfd_elf_generic_reloc, "R_X86_64_GLOB_DAT", false, MINUS_ONE,
60 HOWTO(R_X86_64_JUMP_SLOT, 0, 4, 64, false, 0, complain_overflow_bitfield,
61 bfd_elf_generic_reloc, "R_X86_64_JUMP_SLOT", false, MINUS_ONE,
63 HOWTO(R_X86_64_RELATIVE, 0, 4, 64, false, 0, complain_overflow_bitfield,
64 bfd_elf_generic_reloc, "R_X86_64_RELATIVE", false, MINUS_ONE,
66 HOWTO(R_X86_64_GOTPCREL, 0, 4, 32, true,0 , complain_overflow_signed,
67 bfd_elf_generic_reloc, "R_X86_64_GOTPCREL", false, 0xffffffff,
69 HOWTO(R_X86_64_32, 0, 4, 32, false, 0, complain_overflow_unsigned,
70 bfd_elf_generic_reloc, "R_X86_64_32", false, 0xffffffff, 0xffffffff,
72 HOWTO(R_X86_64_32S, 0, 4, 32, false, 0, complain_overflow_signed,
73 bfd_elf_generic_reloc, "R_X86_64_32S", false, 0xffffffff, 0xffffffff,
75 HOWTO(R_X86_64_16, 0, 1, 16, false, 0, complain_overflow_bitfield,
76 bfd_elf_generic_reloc, "R_X86_64_16", false, 0xffff, 0xffff, false),
77 HOWTO(R_X86_64_PC16,0, 1, 16, true, 0, complain_overflow_bitfield,
78 bfd_elf_generic_reloc, "R_X86_64_PC16", false, 0xffff, 0xffff, true),
79 HOWTO(R_X86_64_8, 0, 0, 8, false, 0, complain_overflow_signed,
80 bfd_elf_generic_reloc, "R_X86_64_8", false, 0xff, 0xff, false),
81 HOWTO(R_X86_64_PC8, 0, 0, 8, true, 0, complain_overflow_signed,
82 bfd_elf_generic_reloc, "R_X86_64_PC8", false, 0xff, 0xff, true),
84 /* GNU extension to record C++ vtable hierarchy. */
85 HOWTO (R_X86_64_GNU_VTINHERIT, 0, 4, 0, false, 0, complain_overflow_dont,
86 NULL, "R_X86_64_GNU_VTINHERIT", false, 0, 0, false),
88 /* GNU extension to record C++ vtable member usage. */
89 HOWTO (R_X86_64_GNU_VTENTRY, 0, 4, 0, false, 0, complain_overflow_dont,
90 _bfd_elf_rel_vtable_reloc_fn, "R_X86_64_GNU_VTENTRY", false, 0, 0,
94 /* Map BFD relocs to the x86_64 elf relocs. */
97 bfd_reloc_code_real_type bfd_reloc_val;
98 unsigned char elf_reloc_val;
101 static const struct elf_reloc_map x86_64_reloc_map[] =
103 { BFD_RELOC_NONE, R_X86_64_NONE, },
104 { BFD_RELOC_64, R_X86_64_64, },
105 { BFD_RELOC_32_PCREL, R_X86_64_PC32, },
106 { BFD_RELOC_X86_64_GOT32, R_X86_64_GOT32,},
107 { BFD_RELOC_X86_64_PLT32, R_X86_64_PLT32,},
108 { BFD_RELOC_X86_64_COPY, R_X86_64_COPY, },
109 { BFD_RELOC_X86_64_GLOB_DAT, R_X86_64_GLOB_DAT, },
110 { BFD_RELOC_X86_64_JUMP_SLOT, R_X86_64_JUMP_SLOT, },
111 { BFD_RELOC_X86_64_RELATIVE, R_X86_64_RELATIVE, },
112 { BFD_RELOC_X86_64_GOTPCREL, R_X86_64_GOTPCREL, },
113 { BFD_RELOC_32, R_X86_64_32, },
114 { BFD_RELOC_X86_64_32S, R_X86_64_32S, },
115 { BFD_RELOC_16, R_X86_64_16, },
116 { BFD_RELOC_16_PCREL, R_X86_64_PC16, },
117 { BFD_RELOC_8, R_X86_64_8, },
118 { BFD_RELOC_8_PCREL, R_X86_64_PC8, },
119 { BFD_RELOC_VTABLE_INHERIT, R_X86_64_GNU_VTINHERIT, },
120 { BFD_RELOC_VTABLE_ENTRY, R_X86_64_GNU_VTENTRY, },
123 static reloc_howto_type *elf64_x86_64_reloc_type_lookup
124 PARAMS ((bfd *, bfd_reloc_code_real_type));
125 static void elf64_x86_64_info_to_howto
126 PARAMS ((bfd *, arelent *, Elf64_Internal_Rela *));
127 static struct bfd_link_hash_table *elf64_x86_64_link_hash_table_create
129 static boolean elf64_x86_64_elf_object_p PARAMS ((bfd *abfd));
130 static boolean elf64_x86_64_check_relocs
131 PARAMS ((bfd *, struct bfd_link_info *, asection *sec,
132 const Elf_Internal_Rela *));
133 static asection *elf64_x86_64_gc_mark_hook
134 PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *,
135 struct elf_link_hash_entry *, Elf_Internal_Sym *));
137 static boolean elf64_x86_64_gc_sweep_hook
138 PARAMS ((bfd *, struct bfd_link_info *, asection *,
139 const Elf_Internal_Rela *));
141 static struct bfd_hash_entry *elf64_x86_64_link_hash_newfunc
142 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
143 static boolean elf64_x86_64_adjust_dynamic_symbol
144 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
146 static boolean elf64_x86_64_size_dynamic_sections
147 PARAMS ((bfd *, struct bfd_link_info *));
148 static boolean elf64_x86_64_relocate_section
149 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
150 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
151 static boolean elf64_x86_64_finish_dynamic_symbol
152 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
153 Elf_Internal_Sym *sym));
154 static boolean elf64_x86_64_finish_dynamic_sections
155 PARAMS ((bfd *, struct bfd_link_info *));
156 static enum elf_reloc_type_class elf64_x86_64_reloc_type_class
157 PARAMS ((const Elf_Internal_Rela *));
159 /* Given a BFD reloc type, return a HOWTO structure. */
160 static reloc_howto_type *
161 elf64_x86_64_reloc_type_lookup (abfd, code)
162 bfd *abfd ATTRIBUTE_UNUSED;
163 bfd_reloc_code_real_type code;
166 for (i = 0; i < sizeof (x86_64_reloc_map) / sizeof (struct elf_reloc_map);
169 if (x86_64_reloc_map[i].bfd_reloc_val == code)
170 return &x86_64_elf_howto_table[i];
175 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
178 elf64_x86_64_info_to_howto (abfd, cache_ptr, dst)
179 bfd *abfd ATTRIBUTE_UNUSED;
181 Elf64_Internal_Rela *dst;
185 r_type = ELF64_R_TYPE (dst->r_info);
186 if (r_type < (unsigned int) R_X86_64_GNU_VTINHERIT)
188 BFD_ASSERT (r_type <= (unsigned int) R_X86_64_PC8);
193 BFD_ASSERT (r_type < (unsigned int) R_X86_64_max);
194 i = r_type - ((unsigned int) R_X86_64_GNU_VTINHERIT - R_X86_64_PC8 - 1);
196 cache_ptr->howto = &x86_64_elf_howto_table[i];
197 BFD_ASSERT (r_type == cache_ptr->howto->type);
200 /* Functions for the x86-64 ELF linker. */
202 /* The name of the dynamic interpreter. This is put in the .interp
205 #define ELF_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
207 /* The size in bytes of an entry in the global offset table. */
209 #define GOT_ENTRY_SIZE 8
211 /* The size in bytes of an entry in the procedure linkage table. */
213 #define PLT_ENTRY_SIZE 16
215 /* The first entry in a procedure linkage table looks like this. See the
216 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
218 static const bfd_byte elf64_x86_64_plt0_entry[PLT_ENTRY_SIZE] =
220 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
221 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
222 0x90, 0x90, 0x90, 0x90 /* pad out to 16 bytes with nops. */
225 /* Subsequent entries in a procedure linkage table look like this. */
227 static const bfd_byte elf64_x86_64_plt_entry[PLT_ENTRY_SIZE] =
229 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
230 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
231 0x68, /* pushq immediate */
232 0, 0, 0, 0, /* replaced with index into relocation table. */
233 0xe9, /* jmp relative */
234 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
237 /* The x86-64 linker needs to keep track of the number of relocs that
238 it decides to copy in check_relocs for each symbol. This is so
239 that it can discard PC relative relocs if it doesn't need them when
240 linking with -Bsymbolic. We store the information in a field
241 extending the regular ELF linker hash table. */
243 /* This structure keeps track of the number of PC relative relocs we
244 have copied for a given symbol. */
246 struct elf64_x86_64_pcrel_relocs_copied
249 struct elf64_x86_64_pcrel_relocs_copied *next;
250 /* A section in dynobj. */
252 /* Number of relocs copied in this section. */
256 /* x86-64 ELF linker hash entry. */
258 struct elf64_x86_64_link_hash_entry
260 struct elf_link_hash_entry root;
262 /* Number of PC relative relocs copied for this symbol. */
263 struct elf64_x86_64_pcrel_relocs_copied *pcrel_relocs_copied;
266 /* x86-64 ELF linker hash table. */
268 struct elf64_x86_64_link_hash_table
270 struct elf_link_hash_table root;
273 /* Declare this now that the above structures are defined. */
275 static boolean elf64_x86_64_discard_copies
276 PARAMS ((struct elf64_x86_64_link_hash_entry *, PTR));
278 /* Traverse an x86-64 ELF linker hash table. */
280 #define elf64_x86_64_link_hash_traverse(table, func, info) \
281 (elf_link_hash_traverse \
283 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
286 /* Get the x86-64 ELF linker hash table from a link_info structure. */
288 #define elf64_x86_64_hash_table(p) \
289 ((struct elf64_x86_64_link_hash_table *) ((p)->hash))
291 /* Create an entry in an x86-64 ELF linker hash table. */
293 static struct bfd_hash_entry *
294 elf64_x86_64_link_hash_newfunc (entry, table, string)
295 struct bfd_hash_entry *entry;
296 struct bfd_hash_table *table;
299 struct elf64_x86_64_link_hash_entry *ret =
300 (struct elf64_x86_64_link_hash_entry *) entry;
302 /* Allocate the structure if it has not already been allocated by a
304 if (ret == (struct elf64_x86_64_link_hash_entry *) NULL)
305 ret = ((struct elf64_x86_64_link_hash_entry *)
306 bfd_hash_allocate (table,
307 sizeof (struct elf64_x86_64_link_hash_entry)));
308 if (ret == (struct elf64_x86_64_link_hash_entry *) NULL)
309 return (struct bfd_hash_entry *) ret;
311 /* Call the allocation method of the superclass. */
312 ret = ((struct elf64_x86_64_link_hash_entry *)
313 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
315 if (ret != (struct elf64_x86_64_link_hash_entry *) NULL)
317 ret->pcrel_relocs_copied = NULL;
320 return (struct bfd_hash_entry *) ret;
323 /* Create an X86-64 ELF linker hash table. */
325 static struct bfd_link_hash_table *
326 elf64_x86_64_link_hash_table_create (abfd)
329 struct elf64_x86_64_link_hash_table *ret;
330 bfd_size_type amt = sizeof (struct elf64_x86_64_link_hash_table);
332 ret = ((struct elf64_x86_64_link_hash_table *) bfd_alloc (abfd, amt));
333 if (ret == (struct elf64_x86_64_link_hash_table *) NULL)
336 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
337 elf64_x86_64_link_hash_newfunc))
339 bfd_release (abfd, ret);
343 return &ret->root.root;
347 elf64_x86_64_elf_object_p (abfd)
350 /* Set the right machine number for an x86-64 elf64 file. */
351 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64);
355 /* Look through the relocs for a section during the first phase, and
356 allocate space in the global offset table or procedure linkage
360 elf64_x86_64_check_relocs (abfd, info, sec, relocs)
362 struct bfd_link_info *info;
364 const Elf_Internal_Rela *relocs;
367 Elf_Internal_Shdr *symtab_hdr;
368 struct elf_link_hash_entry **sym_hashes;
369 bfd_signed_vma *local_got_refcounts;
370 const Elf_Internal_Rela *rel;
371 const Elf_Internal_Rela *rel_end;
376 if (info->relocateable)
379 dynobj = elf_hash_table (info)->dynobj;
380 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
381 sym_hashes = elf_sym_hashes (abfd);
382 local_got_refcounts = elf_local_got_refcounts (abfd);
384 sgot = srelgot = sreloc = NULL;
385 rel_end = relocs + sec->reloc_count;
386 for (rel = relocs; rel < rel_end; rel++)
388 unsigned long r_symndx;
389 struct elf_link_hash_entry *h;
391 r_symndx = ELF64_R_SYM (rel->r_info);
392 if (r_symndx < symtab_hdr->sh_info)
395 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
397 /* Some relocs require a global offset table. */
400 switch (ELF64_R_TYPE (rel->r_info))
403 case R_X86_64_GOTPCREL:
404 elf_hash_table (info)->dynobj = dynobj = abfd;
405 if (! _bfd_elf_create_got_section (dynobj, info))
411 switch (ELF64_R_TYPE (rel->r_info))
413 case R_X86_64_GOTPCREL:
415 /* This symbol requires a global offset table entry. */
419 sgot = bfd_get_section_by_name (dynobj, ".got");
420 BFD_ASSERT (sgot != NULL);
423 if (srelgot == NULL && (h != NULL || info->shared))
425 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
428 srelgot = bfd_make_section (dynobj, ".rela.got");
430 || ! bfd_set_section_flags (dynobj, srelgot,
437 || ! bfd_set_section_alignment (dynobj, srelgot, 3))
444 if (h->got.refcount == 0)
446 /* Make sure this symbol is output as a dynamic symbol. */
447 if (h->dynindx == -1)
449 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
453 sgot->_raw_size += GOT_ENTRY_SIZE;
454 srelgot->_raw_size += sizeof (Elf64_External_Rela);
456 h->got.refcount += 1;
460 /* This is a global offset table entry for a local symbol. */
461 if (local_got_refcounts == NULL)
465 size = symtab_hdr->sh_info;
466 size *= sizeof (bfd_signed_vma);
467 local_got_refcounts = ((bfd_signed_vma *)
468 bfd_zalloc (abfd, size));
469 if (local_got_refcounts == NULL)
471 elf_local_got_refcounts (abfd) = local_got_refcounts;
473 if (local_got_refcounts[r_symndx] == 0)
475 sgot->_raw_size += GOT_ENTRY_SIZE;
478 /* If we are generating a shared object, we need to
479 output a R_X86_64_RELATIVE reloc so that the dynamic
480 linker can adjust this GOT entry. */
481 srelgot->_raw_size += sizeof (Elf64_External_Rela);
484 local_got_refcounts[r_symndx] += 1;
489 /* This symbol requires a procedure linkage table entry. We
490 actually build the entry in adjust_dynamic_symbol,
491 because this might be a case of linking PIC code which is
492 never referenced by a dynamic object, in which case we
493 don't need to generate a procedure linkage table entry
496 /* If this is a local symbol, we resolve it directly without
497 creating a procedure linkage table entry. */
501 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
502 h->plt.refcount += 1;
512 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
514 /* If we are creating a shared library, and this is a reloc
515 against a global symbol, or a non PC relative reloc
516 against a local symbol, then we need to copy the reloc
517 into the shared library. However, if we are linking with
518 -Bsymbolic, we do not need to copy a reloc against a
519 global symbol which is defined in an object we are
520 including in the link (i.e., DEF_REGULAR is set). At
521 this point we have not seen all the input files, so it is
522 possible that DEF_REGULAR is not set now but will be set
523 later (it is never cleared). We account for that
524 possibility below by storing information in the
525 pcrel_relocs_copied field of the hash table entry.
526 A similar situation occurs when creating shared libraries
527 and symbol visibility changes render the symbol local. */
529 && (sec->flags & SEC_ALLOC) != 0
530 && (((ELF64_R_TYPE (rel->r_info) != R_X86_64_PC8)
531 && (ELF64_R_TYPE (rel->r_info) != R_X86_64_PC16)
532 && (ELF64_R_TYPE (rel->r_info) != R_X86_64_PC32))
535 || (h->elf_link_hash_flags
536 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
538 /* When creating a shared object, we must copy these
539 reloc types into the output file. We create a reloc
540 section in dynobj and make room for this reloc. */
545 name = (bfd_elf_string_from_elf_section
547 elf_elfheader (abfd)->e_shstrndx,
548 elf_section_data (sec)->rel_hdr.sh_name));
552 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
553 && strcmp (bfd_get_section_name (abfd, sec),
556 sreloc = bfd_get_section_by_name (dynobj, name);
561 sreloc = bfd_make_section (dynobj, name);
562 flags = (SEC_HAS_CONTENTS | SEC_READONLY
563 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
564 if ((sec->flags & SEC_ALLOC) != 0)
565 flags |= SEC_ALLOC | SEC_LOAD;
567 || ! bfd_set_section_flags (dynobj, sreloc, flags)
568 || ! bfd_set_section_alignment (dynobj, sreloc, 3))
571 if (sec->flags & SEC_READONLY)
572 info->flags |= DF_TEXTREL;
575 sreloc->_raw_size += sizeof (Elf64_External_Rela);
577 /* If this is a global symbol, we count the number of PC
578 relative relocations we have entered for this symbol,
579 so that we can discard them later as necessary. Note
580 that this function is only called if we are using an
581 elf64_x86_64 linker hash table, which means that h is
582 really a pointer to an elf64_x86_64_link_hash_entry. */
584 && ((ELF64_R_TYPE (rel->r_info) == R_X86_64_PC8)
585 || (ELF64_R_TYPE (rel->r_info) == R_X86_64_PC16)
586 || (ELF64_R_TYPE (rel->r_info) == R_X86_64_PC32)))
588 struct elf64_x86_64_link_hash_entry *eh;
589 struct elf64_x86_64_pcrel_relocs_copied *p;
591 eh = (struct elf64_x86_64_link_hash_entry *) h;
593 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
594 if (p->section == sreloc)
599 p = ((struct elf64_x86_64_pcrel_relocs_copied *)
600 bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
603 p->next = eh->pcrel_relocs_copied;
604 eh->pcrel_relocs_copied = p;
614 /* This relocation describes the C++ object vtable hierarchy.
615 Reconstruct it for later use during GC. */
616 case R_X86_64_GNU_VTINHERIT:
617 if (!_bfd_elf64_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
621 /* This relocation describes which C++ vtable entries are actually
622 used. Record for later use during GC. */
623 case R_X86_64_GNU_VTENTRY:
624 if (!_bfd_elf64_gc_record_vtentry (abfd, sec, h, rel->r_addend))
633 /* Return the section that should be marked against GC for a given
637 elf64_x86_64_gc_mark_hook (abfd, info, rel, h, sym)
639 struct bfd_link_info *info ATTRIBUTE_UNUSED;
640 Elf_Internal_Rela *rel ATTRIBUTE_UNUSED;
641 struct elf_link_hash_entry *h;
642 Elf_Internal_Sym *sym;
646 switch (ELF64_R_TYPE (rel->r_info))
648 case R_X86_64_GNU_VTINHERIT:
649 case R_X86_64_GNU_VTENTRY:
653 switch (h->root.type)
655 case bfd_link_hash_defined:
656 case bfd_link_hash_defweak:
657 return h->root.u.def.section;
659 case bfd_link_hash_common:
660 return h->root.u.c.p->section;
669 if (!(elf_bad_symtab (abfd)
670 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
671 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
672 && sym->st_shndx != SHN_COMMON))
674 return bfd_section_from_elf_index (abfd, sym->st_shndx);
681 /* Update the got entry reference counts for the section being removed. */
684 elf64_x86_64_gc_sweep_hook (abfd, info, sec, relocs)
686 struct bfd_link_info *info ATTRIBUTE_UNUSED;
688 const Elf_Internal_Rela *relocs;
690 Elf_Internal_Shdr *symtab_hdr;
691 struct elf_link_hash_entry **sym_hashes;
692 bfd_signed_vma *local_got_refcounts;
693 const Elf_Internal_Rela *rel, *relend;
694 unsigned long r_symndx;
695 struct elf_link_hash_entry *h;
700 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
701 sym_hashes = elf_sym_hashes (abfd);
702 local_got_refcounts = elf_local_got_refcounts (abfd);
704 dynobj = elf_hash_table (info)->dynobj;
708 sgot = bfd_get_section_by_name (dynobj, ".got");
709 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
711 relend = relocs + sec->reloc_count;
712 for (rel = relocs; rel < relend; rel++)
713 switch (ELF64_R_TYPE (rel->r_info))
716 case R_X86_64_GOTPCREL:
717 r_symndx = ELF64_R_SYM (rel->r_info);
718 if (r_symndx >= symtab_hdr->sh_info)
720 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
721 if (h->got.refcount > 0)
723 h->got.refcount -= 1;
724 if (h->got.refcount == 0)
726 sgot->_raw_size -= GOT_ENTRY_SIZE;
727 srelgot->_raw_size -= sizeof (Elf64_External_Rela);
731 else if (local_got_refcounts != NULL)
733 if (local_got_refcounts[r_symndx] > 0)
735 local_got_refcounts[r_symndx] -= 1;
736 if (local_got_refcounts[r_symndx] == 0)
738 sgot->_raw_size -= GOT_ENTRY_SIZE;
740 srelgot->_raw_size -= sizeof (Elf64_External_Rela);
747 r_symndx = ELF64_R_SYM (rel->r_info);
748 if (r_symndx >= symtab_hdr->sh_info)
750 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
751 if (h->plt.refcount > 0)
752 h->plt.refcount -= 1;
763 /* Adjust a symbol defined by a dynamic object and referenced by a
764 regular object. The current definition is in some section of the
765 dynamic object, but we're not including those sections. We have to
766 change the definition to something the rest of the link can
770 elf64_x86_64_adjust_dynamic_symbol (info, h)
771 struct bfd_link_info *info;
772 struct elf_link_hash_entry *h;
776 unsigned int power_of_two;
778 dynobj = elf_hash_table (info)->dynobj;
780 /* Make sure we know what is going on here. */
781 BFD_ASSERT (dynobj != NULL
782 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
783 || h->weakdef != NULL
784 || ((h->elf_link_hash_flags
785 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
786 && (h->elf_link_hash_flags
787 & ELF_LINK_HASH_REF_REGULAR) != 0
788 && (h->elf_link_hash_flags
789 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
791 /* If this is a function, put it in the procedure linkage table. We
792 will fill in the contents of the procedure linkage table later,
793 when we know the address of the .got section. */
794 if (h->type == STT_FUNC
795 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
798 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
799 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
800 || (info->shared && h->plt.refcount <= 0))
802 /* This case can occur if we saw a PLT32 reloc in an input
803 file, but the symbol was never referred to by a dynamic
804 object, or if all references were garbage collected. In
805 such a case, we don't actually need to build a procedure
806 linkage table, and we can just do a PC32 reloc instead. */
807 h->plt.offset = (bfd_vma) -1;
808 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
812 /* Make sure this symbol is output as a dynamic symbol. */
813 if (h->dynindx == -1)
815 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
819 s = bfd_get_section_by_name (dynobj, ".plt");
820 BFD_ASSERT (s != NULL);
822 /* If this is the first .plt entry, make room for the special
824 if (s->_raw_size == 0)
825 s->_raw_size = PLT_ENTRY_SIZE;
827 /* If this symbol is not defined in a regular file, and we are
828 not generating a shared library, then set the symbol to this
829 location in the .plt. This is required to make function
830 pointers compare as equal between the normal executable and
831 the shared library. */
833 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
835 h->root.u.def.section = s;
836 h->root.u.def.value = s->_raw_size;
839 h->plt.offset = s->_raw_size;
841 /* Make room for this entry. */
842 s->_raw_size += PLT_ENTRY_SIZE;
844 /* We also need to make an entry in the .got.plt section, which
845 will be placed in the .got section by the linker script. */
846 s = bfd_get_section_by_name (dynobj, ".got.plt");
847 BFD_ASSERT (s != NULL);
848 s->_raw_size += GOT_ENTRY_SIZE;
850 /* We also need to make an entry in the .rela.plt section. */
851 s = bfd_get_section_by_name (dynobj, ".rela.plt");
852 BFD_ASSERT (s != NULL);
853 s->_raw_size += sizeof (Elf64_External_Rela);
858 h->plt.offset = (bfd_vma) -1;
860 /* If this is a weak symbol, and there is a real definition, the
861 processor independent code will have arranged for us to see the
862 real definition first, and we can just use the same value. */
863 if (h->weakdef != NULL)
865 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
866 || h->weakdef->root.type == bfd_link_hash_defweak);
867 h->root.u.def.section = h->weakdef->root.u.def.section;
868 h->root.u.def.value = h->weakdef->root.u.def.value;
872 /* This is a reference to a symbol defined by a dynamic object which
873 is not a function. */
875 /* If we are creating a shared library, we must presume that the
876 only references to the symbol are via the global offset table.
877 For such cases we need not do anything here; the relocations will
878 be handled correctly by relocate_section. */
882 /* If there are no references to this symbol that do not use the
883 GOT, we don't need to generate a copy reloc. */
884 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
887 /* We must allocate the symbol in our .dynbss section, which will
888 become part of the .bss section of the executable. There will be
889 an entry for this symbol in the .dynsym section. The dynamic
890 object will contain position independent code, so all references
891 from the dynamic object to this symbol will go through the global
892 offset table. The dynamic linker will use the .dynsym entry to
893 determine the address it must put in the global offset table, so
894 both the dynamic object and the regular object will refer to the
895 same memory location for the variable. */
897 s = bfd_get_section_by_name (dynobj, ".dynbss");
898 BFD_ASSERT (s != NULL);
900 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
901 to copy the initial value out of the dynamic object and into the
902 runtime process image. We need to remember the offset into the
903 .rela.bss section we are going to use. */
904 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
908 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
909 BFD_ASSERT (srel != NULL);
910 srel->_raw_size += sizeof (Elf64_External_Rela);
911 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
914 /* We need to figure out the alignment required for this symbol. I
915 have no idea how ELF linkers handle this. 16-bytes is the size
916 of the largest type that requires hard alignment -- long double. */
917 /* FIXME: This is VERY ugly. Should be fixed for all architectures using
919 power_of_two = bfd_log2 (h->size);
920 if (power_of_two > 4)
923 /* Apply the required alignment. */
924 s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
925 if (power_of_two > bfd_get_section_alignment (dynobj, s))
927 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
931 /* Define the symbol as being at this point in the section. */
932 h->root.u.def.section = s;
933 h->root.u.def.value = s->_raw_size;
935 /* Increment the section size to make room for the symbol. */
936 s->_raw_size += h->size;
941 /* Set the sizes of the dynamic sections. */
944 elf64_x86_64_size_dynamic_sections (output_bfd, info)
945 bfd *output_bfd ATTRIBUTE_UNUSED;
946 struct bfd_link_info *info;
953 dynobj = elf_hash_table (info)->dynobj;
954 BFD_ASSERT (dynobj != NULL);
956 if (elf_hash_table (info)->dynamic_sections_created)
958 /* Set the contents of the .interp section to the interpreter. */
961 s = bfd_get_section_by_name (dynobj, ".interp");
962 BFD_ASSERT (s != NULL);
963 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
964 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
969 /* We may have created entries in the .rela.got section.
970 However, if we are not creating the dynamic sections, we will
971 not actually use these entries. Reset the size of .rela.got,
972 which will cause it to get stripped from the output file
974 s = bfd_get_section_by_name (dynobj, ".rela.got");
979 /* If this is a -Bsymbolic shared link, then we need to discard all
980 PC relative relocs against symbols defined in a regular object.
981 We allocated space for them in the check_relocs routine, but we
982 will not fill them in in the relocate_section routine. */
984 elf64_x86_64_link_hash_traverse (elf64_x86_64_hash_table (info),
985 elf64_x86_64_discard_copies,
988 /* The check_relocs and adjust_dynamic_symbol entry points have
989 determined the sizes of the various dynamic sections. Allocate
991 plt = relocs = false;
992 for (s = dynobj->sections; s != NULL; s = s->next)
997 if ((s->flags & SEC_LINKER_CREATED) == 0)
1000 /* It's OK to base decisions on the section name, because none
1001 of the dynobj section names depend upon the input files. */
1002 name = bfd_get_section_name (dynobj, s);
1005 if (strcmp (name, ".plt") == 0)
1007 if (s->_raw_size == 0)
1009 /* Strip this section if we don't need it; see the
1015 /* Remember whether there is a PLT. */
1019 else if (strncmp (name, ".rela", 5) == 0)
1021 if (s->_raw_size == 0)
1023 /* If we don't need this section, strip it from the
1024 output file. This is mostly to handle .rela.bss and
1025 .rela.plt. We must create both sections in
1026 create_dynamic_sections, because they must be created
1027 before the linker maps input sections to output
1028 sections. The linker does that before
1029 adjust_dynamic_symbol is called, and it is that
1030 function which decides whether anything needs to go
1031 into these sections. */
1036 if (strcmp (name, ".rela.plt") != 0)
1039 /* We use the reloc_count field as a counter if we need
1040 to copy relocs into the output file. */
1044 else if (strncmp (name, ".got", 4) != 0)
1046 /* It's not one of our sections, so don't allocate space. */
1052 _bfd_strip_section_from_output (info, s);
1056 /* Allocate memory for the section contents. We use bfd_zalloc
1057 here in case unused entries are not reclaimed before the
1058 section's contents are written out. This should not happen,
1059 but this way if it does, we get a R_X86_64_NONE reloc instead
1061 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1062 if (s->contents == NULL && s->_raw_size != 0)
1066 if (elf_hash_table (info)->dynamic_sections_created)
1068 /* Add some entries to the .dynamic section. We fill in the
1069 values later, in elf64_x86_64_finish_dynamic_sections, but we
1070 must add the entries now so that we get the correct size for
1071 the .dynamic section. The DT_DEBUG entry is filled in by the
1072 dynamic linker and used by the debugger. */
1073 #define add_dynamic_entry(TAG, VAL) \
1074 bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1078 if (!add_dynamic_entry (DT_DEBUG, 0))
1084 if (!add_dynamic_entry (DT_PLTGOT, 0)
1085 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1086 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1087 || !add_dynamic_entry (DT_JMPREL, 0))
1093 if (!add_dynamic_entry (DT_RELA, 0)
1094 || !add_dynamic_entry (DT_RELASZ, 0)
1095 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
1099 if ((info->flags & DF_TEXTREL) != 0)
1101 if (!add_dynamic_entry (DT_TEXTREL, 0))
1105 #undef add_dynamic_entry
1110 /* This function is called via elf64_x86_64_link_hash_traverse if we are
1111 creating a shared object. In the -Bsymbolic case, it discards the
1112 space allocated to copy PC relative relocs against symbols which
1113 are defined in regular objects. For the normal non-symbolic case,
1114 we also discard space for relocs that have become local due to
1115 symbol visibility changes. We allocated space for them in the
1116 check_relocs routine, but we won't fill them in in the
1117 relocate_section routine. */
1120 elf64_x86_64_discard_copies (h, inf)
1121 struct elf64_x86_64_link_hash_entry *h;
1124 struct elf64_x86_64_pcrel_relocs_copied *s;
1125 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1127 /* If a symbol has been forced local or we have found a regular
1128 definition for the symbolic link case, then we won't be needing
1130 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1131 && ((h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1134 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
1135 s->section->_raw_size -= s->count * sizeof (Elf64_External_Rela);
1141 /* Relocate an x86_64 ELF section. */
1144 elf64_x86_64_relocate_section (output_bfd, info, input_bfd, input_section,
1145 contents, relocs, local_syms, local_sections)
1147 struct bfd_link_info *info;
1149 asection *input_section;
1151 Elf_Internal_Rela *relocs;
1152 Elf_Internal_Sym *local_syms;
1153 asection **local_sections;
1156 Elf_Internal_Shdr *symtab_hdr;
1157 struct elf_link_hash_entry **sym_hashes;
1158 bfd_vma *local_got_offsets;
1162 Elf_Internal_Rela *rela;
1163 Elf_Internal_Rela *relend;
1165 dynobj = elf_hash_table (info)->dynobj;
1166 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1167 sym_hashes = elf_sym_hashes (input_bfd);
1168 local_got_offsets = elf_local_got_offsets (input_bfd);
1170 sreloc = splt = sgot = NULL;
1173 splt = bfd_get_section_by_name (dynobj, ".plt");
1174 sgot = bfd_get_section_by_name (dynobj, ".got");
1178 relend = relocs + input_section->reloc_count;
1179 for (; rela < relend; rela++)
1182 reloc_howto_type *howto;
1183 unsigned long r_symndx;
1184 struct elf_link_hash_entry *h;
1185 Elf_Internal_Sym *sym;
1188 bfd_reloc_status_type r;
1191 r_type = ELF64_R_TYPE (rela->r_info);
1192 if (r_type == (int) R_X86_64_GNU_VTINHERIT
1193 || r_type == (int) R_X86_64_GNU_VTENTRY)
1196 if ((indx = (unsigned) r_type) >= R_X86_64_max)
1198 bfd_set_error (bfd_error_bad_value);
1201 howto = x86_64_elf_howto_table + indx;
1203 r_symndx = ELF64_R_SYM (rela->r_info);
1205 if (info->relocateable)
1207 /* This is a relocateable link. We don't have to change
1208 anything, unless the reloc is against a section symbol,
1209 in which case we have to adjust according to where the
1210 section symbol winds up in the output section. */
1211 if (r_symndx < symtab_hdr->sh_info)
1213 sym = local_syms + r_symndx;
1214 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1216 sec = local_sections[r_symndx];
1217 rela->r_addend += sec->output_offset + sym->st_value;
1224 /* This is a final link. */
1228 if (r_symndx < symtab_hdr->sh_info)
1230 sym = local_syms + r_symndx;
1231 sec = local_sections[r_symndx];
1232 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rela);
1236 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1237 while (h->root.type == bfd_link_hash_indirect
1238 || h->root.type == bfd_link_hash_warning)
1239 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1240 if (h->root.type == bfd_link_hash_defined
1241 || h->root.type == bfd_link_hash_defweak)
1243 sec = h->root.u.def.section;
1244 if ((r_type == R_X86_64_PLT32
1246 && h->plt.offset != (bfd_vma) -1)
1247 || ((r_type == R_X86_64_GOT32 || r_type == R_X86_64_GOTPCREL)
1248 && elf_hash_table (info)->dynamic_sections_created
1250 || (! info->symbolic && h->dynindx != -1)
1251 || (h->elf_link_hash_flags
1252 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1254 && ((! info->symbolic && h->dynindx != -1)
1255 || (h->elf_link_hash_flags
1256 & ELF_LINK_HASH_DEF_REGULAR) == 0)
1257 && (r_type == R_X86_64_8
1258 || r_type == R_X86_64_16
1259 || r_type == R_X86_64_32
1260 || r_type == R_X86_64_64
1261 || r_type == R_X86_64_PC8
1262 || r_type == R_X86_64_PC16
1263 || r_type == R_X86_64_PC32)
1264 && ((input_section->flags & SEC_ALLOC) != 0
1265 /* DWARF will emit R_X86_64_32 relocations in its
1266 sections against symbols defined externally
1267 in shared libraries. We can't do anything
1269 || ((input_section->flags & SEC_DEBUGGING) != 0
1270 && (h->elf_link_hash_flags
1271 & ELF_LINK_HASH_DEF_DYNAMIC) != 0))))
1273 /* In these cases, we don't need the relocation
1274 value. We check specially because in some
1275 obscure cases sec->output_section will be NULL. */
1278 else if (sec->output_section == NULL)
1280 (*_bfd_error_handler)
1281 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1282 bfd_archive_filename (input_bfd), h->root.root.string,
1283 bfd_get_section_name (input_bfd, input_section));
1287 relocation = (h->root.u.def.value
1288 + sec->output_section->vma
1289 + sec->output_offset);
1291 else if (h->root.type == bfd_link_hash_undefweak)
1293 else if (info->shared
1294 && (!info->symbolic || info->allow_shlib_undefined)
1295 && !info->no_undefined
1296 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1300 if (! ((*info->callbacks->undefined_symbol)
1301 (info, h->root.root.string, input_bfd,
1302 input_section, rela->r_offset,
1303 (!info->shared || info->no_undefined
1304 || ELF_ST_VISIBILITY (h->other)))))
1310 /* When generating a shared object, the relocations handled here are
1311 copied into the output file to be resolved at run time. */
1314 case R_X86_64_GOT32:
1315 /* Relocation is to the entry for this symbol in the global
1317 case R_X86_64_GOTPCREL:
1318 /* Use global offset table as symbol value. */
1319 BFD_ASSERT (sgot != NULL);
1323 bfd_vma off = h->got.offset;
1324 BFD_ASSERT (off != (bfd_vma) -1);
1326 if (! elf_hash_table (info)->dynamic_sections_created
1328 && (info->symbolic || h->dynindx == -1)
1329 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1331 /* This is actually a static link, or it is a -Bsymbolic
1332 link and the symbol is defined locally, or the symbol
1333 was forced to be local because of a version file. We
1334 must initialize this entry in the global offset table.
1335 Since the offset must always be a multiple of 8, we
1336 use the least significant bit to record whether we
1337 have initialized it already.
1339 When doing a dynamic link, we create a .rela.got
1340 relocation entry to initialize the value. This is
1341 done in the finish_dynamic_symbol routine. */
1346 bfd_put_64 (output_bfd, relocation,
1347 sgot->contents + off);
1351 if (r_type == R_X86_64_GOTPCREL)
1352 relocation = sgot->output_section->vma + sgot->output_offset + off;
1354 relocation = sgot->output_offset + off;
1360 BFD_ASSERT (local_got_offsets != NULL
1361 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1363 off = local_got_offsets[r_symndx];
1365 /* The offset must always be a multiple of 8. We use
1366 the least significant bit to record whether we have
1367 already generated the necessary reloc. */
1372 bfd_put_64 (output_bfd, relocation, sgot->contents + off);
1377 Elf_Internal_Rela outrel;
1379 /* We need to generate a R_X86_64_RELATIVE reloc
1380 for the dynamic linker. */
1381 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1382 BFD_ASSERT (srelgot != NULL);
1384 outrel.r_offset = (sgot->output_section->vma
1385 + sgot->output_offset
1387 outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
1388 outrel.r_addend = relocation;
1389 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
1390 (((Elf64_External_Rela *)
1392 + srelgot->reloc_count));
1393 ++srelgot->reloc_count;
1396 local_got_offsets[r_symndx] |= 1;
1399 if (r_type == R_X86_64_GOTPCREL)
1400 relocation = sgot->output_section->vma + sgot->output_offset + off;
1402 relocation = sgot->output_offset + off;
1407 case R_X86_64_PLT32:
1408 /* Relocation is to the entry for this symbol in the
1409 procedure linkage table. */
1411 /* Resolve a PLT32 reloc against a local symbol directly,
1412 without using the procedure linkage table. */
1416 if (h->plt.offset == (bfd_vma) -1 || splt == NULL)
1418 /* We didn't make a PLT entry for this symbol. This
1419 happens when statically linking PIC code, or when
1420 using -Bsymbolic. */
1424 relocation = (splt->output_section->vma
1425 + splt->output_offset
1432 if (h == NULL || h->dynindx == -1
1434 && h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
1441 /* FIXME: The ABI says the linker should make sure the value is
1442 the same when it's zeroextended to 64 bit. */
1445 && (input_section->flags & SEC_ALLOC) != 0)
1447 Elf_Internal_Rela outrel;
1448 boolean skip, relocate;
1450 /* When generating a shared object, these relocations
1451 are copied into the output file to be resolved at run
1458 name = (bfd_elf_string_from_elf_section
1460 elf_elfheader (input_bfd)->e_shstrndx,
1461 elf_section_data (input_section)->rel_hdr.sh_name));
1465 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1466 && strcmp (bfd_get_section_name (input_bfd,
1470 sreloc = bfd_get_section_by_name (dynobj, name);
1471 BFD_ASSERT (sreloc != NULL);
1476 if (elf_section_data (input_section)->stab_info == NULL)
1477 outrel.r_offset = rela->r_offset;
1482 off = (_bfd_stab_section_offset
1483 (output_bfd, &elf_hash_table (info)->stab_info,
1485 &elf_section_data (input_section)->stab_info,
1487 if (off == (bfd_vma) -1)
1489 outrel.r_offset = off;
1492 outrel.r_offset += (input_section->output_section->vma
1493 + input_section->output_offset);
1497 memset (&outrel, 0, sizeof outrel);
1500 /* h->dynindx may be -1 if this symbol was marked to
1503 && ((! info->symbolic && h->dynindx != -1)
1504 || (h->elf_link_hash_flags
1505 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1507 BFD_ASSERT (h->dynindx != -1);
1509 outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
1510 outrel.r_addend = relocation + rela->r_addend;
1514 if (r_type == R_X86_64_64)
1517 outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
1518 outrel.r_addend = relocation + rela->r_addend;
1525 sec = local_sections[r_symndx];
1528 BFD_ASSERT (h->root.type == bfd_link_hash_defined
1530 == bfd_link_hash_defweak));
1531 sec = h->root.u.def.section;
1533 if (sec != NULL && bfd_is_abs_section (sec))
1535 else if (sec == NULL || sec->owner == NULL)
1537 bfd_set_error (bfd_error_bad_value);
1544 osec = sec->output_section;
1545 sindx = elf_section_data (osec)->dynindx;
1546 BFD_ASSERT (sindx > 0);
1550 outrel.r_info = ELF64_R_INFO (sindx, r_type);
1551 outrel.r_addend = relocation + rela->r_addend;
1556 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
1557 (((Elf64_External_Rela *)
1559 + sreloc->reloc_count));
1560 ++sreloc->reloc_count;
1562 /* If this reloc is against an external symbol, we do
1563 not want to fiddle with the addend. Otherwise, we
1564 need to include the symbol value so that it becomes
1565 an addend for the dynamic reloc. */
1576 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1577 contents, rela->r_offset,
1578 relocation, rela->r_addend);
1580 if (r != bfd_reloc_ok)
1585 case bfd_reloc_outofrange:
1587 case bfd_reloc_overflow:
1592 name = h->root.root.string;
1595 name = bfd_elf_string_from_elf_section (input_bfd,
1596 symtab_hdr->sh_link,
1601 name = bfd_section_name (input_bfd, sec);
1603 if (! ((*info->callbacks->reloc_overflow)
1604 (info, name, howto->name, (bfd_vma) 0,
1605 input_bfd, input_section, rela->r_offset)))
1616 /* Finish up dynamic symbol handling. We set the contents of various
1617 dynamic sections here. */
1620 elf64_x86_64_finish_dynamic_symbol (output_bfd, info, h, sym)
1622 struct bfd_link_info *info;
1623 struct elf_link_hash_entry *h;
1624 Elf_Internal_Sym *sym;
1628 dynobj = elf_hash_table (info)->dynobj;
1630 if (h->plt.offset != (bfd_vma) -1)
1637 Elf_Internal_Rela rela;
1639 /* This symbol has an entry in the procedure linkage table. Set
1642 BFD_ASSERT (h->dynindx != -1);
1644 splt = bfd_get_section_by_name (dynobj, ".plt");
1645 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1646 srela = bfd_get_section_by_name (dynobj, ".rela.plt");
1647 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1649 /* Get the index in the procedure linkage table which
1650 corresponds to this symbol. This is the index of this symbol
1651 in all the symbols for which we are making plt entries. The
1652 first entry in the procedure linkage table is reserved. */
1653 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1655 /* Get the offset into the .got table of the entry that
1656 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
1657 bytes. The first three are reserved for the dynamic linker. */
1658 got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
1660 /* Fill in the entry in the procedure linkage table. */
1661 memcpy (splt->contents + h->plt.offset, elf64_x86_64_plt_entry,
1664 /* Insert the relocation positions of the plt section. The magic
1665 numbers at the end of the statements are the positions of the
1666 relocations in the plt section. */
1667 /* Put offset for jmp *name@GOTPCREL(%rip), since the
1668 instruction uses 6 bytes, subtract this value. */
1669 bfd_put_32 (output_bfd,
1670 (sgot->output_section->vma
1671 + sgot->output_offset
1673 - splt->output_section->vma
1674 - splt->output_offset
1677 splt->contents + h->plt.offset + 2);
1678 /* Put relocation index. */
1679 bfd_put_32 (output_bfd, plt_index,
1680 splt->contents + h->plt.offset + 7);
1681 /* Put offset for jmp .PLT0. */
1682 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
1683 splt->contents + h->plt.offset + 12);
1685 /* Fill in the entry in the global offset table, initially this
1686 points to the pushq instruction in the PLT which is at offset 6. */
1687 bfd_put_64 (output_bfd, (splt->output_section->vma + splt->output_offset
1688 + h->plt.offset + 6),
1689 sgot->contents + got_offset);
1691 /* Fill in the entry in the .rela.plt section. */
1692 rela.r_offset = (sgot->output_section->vma
1693 + sgot->output_offset
1695 rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_JUMP_SLOT);
1697 bfd_elf64_swap_reloca_out (output_bfd, &rela,
1698 ((Elf64_External_Rela *) srela->contents
1701 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1703 /* Mark the symbol as undefined, rather than as defined in
1704 the .plt section. Leave the value alone. */
1705 sym->st_shndx = SHN_UNDEF;
1706 /* If the symbol is weak, we do need to clear the value.
1707 Otherwise, the PLT entry would provide a definition for
1708 the symbol even if the symbol wasn't defined anywhere,
1709 and so the symbol would never be NULL. */
1710 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
1716 if (h->got.offset != (bfd_vma) -1)
1720 Elf_Internal_Rela rela;
1722 /* This symbol has an entry in the global offset table. Set it
1725 sgot = bfd_get_section_by_name (dynobj, ".got");
1726 srela = bfd_get_section_by_name (dynobj, ".rela.got");
1727 BFD_ASSERT (sgot != NULL && srela != NULL);
1729 rela.r_offset = (sgot->output_section->vma
1730 + sgot->output_offset
1731 + (h->got.offset &~ (bfd_vma) 1));
1733 /* If this is a static link, or it is a -Bsymbolic link and the
1734 symbol is defined locally or was forced to be local because
1735 of a version file, we just want to emit a RELATIVE reloc.
1736 The entry in the global offset table will already have been
1737 initialized in the relocate_section function. */
1738 if (! elf_hash_table (info)->dynamic_sections_created
1740 && (info->symbolic || h->dynindx == -1)
1741 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1743 BFD_ASSERT((h->got.offset & 1) != 0);
1744 rela.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
1745 rela.r_addend = (h->root.u.def.value
1746 + h->root.u.def.section->output_section->vma
1747 + h->root.u.def.section->output_offset);
1751 BFD_ASSERT((h->got.offset & 1) == 0);
1752 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1753 rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_GLOB_DAT);
1757 bfd_elf64_swap_reloca_out (output_bfd, &rela,
1758 ((Elf64_External_Rela *) srela->contents
1759 + srela->reloc_count));
1760 ++srela->reloc_count;
1763 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1766 Elf_Internal_Rela rela;
1768 /* This symbol needs a copy reloc. Set it up. */
1770 BFD_ASSERT (h->dynindx != -1
1771 && (h->root.type == bfd_link_hash_defined
1772 || h->root.type == bfd_link_hash_defweak));
1774 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1776 BFD_ASSERT (s != NULL);
1778 rela.r_offset = (h->root.u.def.value
1779 + h->root.u.def.section->output_section->vma
1780 + h->root.u.def.section->output_offset);
1781 rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_COPY);
1783 bfd_elf64_swap_reloca_out (output_bfd, &rela,
1784 ((Elf64_External_Rela *) s->contents
1789 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
1790 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1791 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1792 sym->st_shndx = SHN_ABS;
1797 /* Finish up the dynamic sections. */
1800 elf64_x86_64_finish_dynamic_sections (output_bfd, info)
1802 struct bfd_link_info *info;
1808 dynobj = elf_hash_table (info)->dynobj;
1810 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1811 BFD_ASSERT (sgot != NULL);
1812 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1814 if (elf_hash_table (info)->dynamic_sections_created)
1817 Elf64_External_Dyn *dyncon, *dynconend;
1819 BFD_ASSERT (sdyn != NULL);
1821 dyncon = (Elf64_External_Dyn *) sdyn->contents;
1822 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1823 for (; dyncon < dynconend; dyncon++)
1825 Elf_Internal_Dyn dyn;
1829 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
1844 s = bfd_get_section_by_name (output_bfd, name);
1845 BFD_ASSERT (s != NULL);
1846 dyn.d_un.d_ptr = s->vma;
1850 /* FIXME: This comment and code is from elf64-alpha.c: */
1851 /* My interpretation of the TIS v1.1 ELF document indicates
1852 that RELASZ should not include JMPREL. This is not what
1853 the rest of the BFD does. It is, however, what the
1854 glibc ld.so wants. Do this fixup here until we found
1855 out who is right. */
1856 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
1859 /* Subtract JMPREL size from RELASZ. */
1861 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
1866 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
1867 BFD_ASSERT (s != NULL);
1869 (s->_cooked_size != 0 ? s->_cooked_size : s->_raw_size);
1872 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
1875 /* Initialize the contents of the .plt section. */
1876 splt = bfd_get_section_by_name (dynobj, ".plt");
1877 BFD_ASSERT (splt != NULL);
1878 if (splt->_raw_size > 0)
1880 /* Fill in the first entry in the procedure linkage table. */
1881 memcpy (splt->contents, elf64_x86_64_plt0_entry, PLT_ENTRY_SIZE);
1882 /* Add offset for pushq GOT+8(%rip), since the instruction
1883 uses 6 bytes subtract this value. */
1884 bfd_put_32 (output_bfd,
1885 (sgot->output_section->vma
1886 + sgot->output_offset
1888 - splt->output_section->vma
1889 - splt->output_offset
1891 splt->contents + 2);
1892 /* Add offset for jmp *GOT+16(%rip). The 12 is the offset to
1893 the end of the instruction. */
1894 bfd_put_32 (output_bfd,
1895 (sgot->output_section->vma
1896 + sgot->output_offset
1898 - splt->output_section->vma
1899 - splt->output_offset
1901 splt->contents + 8);
1905 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
1909 /* Set the first entry in the global offset table to the address of
1910 the dynamic section. */
1911 if (sgot->_raw_size > 0)
1914 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents);
1916 bfd_put_64 (output_bfd,
1917 sdyn->output_section->vma + sdyn->output_offset,
1919 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
1920 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + GOT_ENTRY_SIZE);
1921 bfd_put_64 (output_bfd, (bfd_vma) 0, sgot->contents + GOT_ENTRY_SIZE*2);
1924 elf_section_data (sgot->output_section)->this_hdr.sh_entsize =
1930 static enum elf_reloc_type_class
1931 elf64_x86_64_reloc_type_class (rela)
1932 const Elf_Internal_Rela *rela;
1934 switch ((int) ELF64_R_TYPE (rela->r_info))
1936 case R_X86_64_RELATIVE:
1937 return reloc_class_relative;
1938 case R_X86_64_JUMP_SLOT:
1939 return reloc_class_plt;
1941 return reloc_class_copy;
1943 return reloc_class_normal;
1947 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_vec
1948 #define TARGET_LITTLE_NAME "elf64-x86-64"
1949 #define ELF_ARCH bfd_arch_i386
1950 #define ELF_MACHINE_CODE EM_X86_64
1951 #define ELF_MAXPAGESIZE 0x100000
1953 #define elf_backend_can_gc_sections 1
1954 #define elf_backend_can_refcount 1
1955 #define elf_backend_want_got_plt 1
1956 #define elf_backend_plt_readonly 1
1957 #define elf_backend_want_plt_sym 0
1958 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
1959 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
1961 #define elf_info_to_howto elf64_x86_64_info_to_howto
1963 #define bfd_elf64_bfd_final_link _bfd_elf64_gc_common_final_link
1964 #define bfd_elf64_bfd_link_hash_table_create \
1965 elf64_x86_64_link_hash_table_create
1966 #define bfd_elf64_bfd_reloc_type_lookup elf64_x86_64_reloc_type_lookup
1968 #define elf_backend_adjust_dynamic_symbol elf64_x86_64_adjust_dynamic_symbol
1969 #define elf_backend_check_relocs elf64_x86_64_check_relocs
1970 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
1971 #define elf_backend_finish_dynamic_sections \
1972 elf64_x86_64_finish_dynamic_sections
1973 #define elf_backend_finish_dynamic_symbol elf64_x86_64_finish_dynamic_symbol
1974 #define elf_backend_gc_mark_hook elf64_x86_64_gc_mark_hook
1975 #define elf_backend_gc_sweep_hook elf64_x86_64_gc_sweep_hook
1976 #define elf_backend_relocate_section elf64_x86_64_relocate_section
1977 #define elf_backend_size_dynamic_sections elf64_x86_64_size_dynamic_sections
1978 #define elf_backend_object_p elf64_x86_64_elf_object_p
1979 #define elf_backend_reloc_type_class elf64_x86_64_reloc_type_class
1981 #include "elf64-target.h"