1 /* X86-64 specific support for 64-bit ELF
2 Copyright 2000, 2001, 2002, 2003, 2004, 2005
3 Free Software Foundation, Inc.
4 Contributed by Jan Hubicka <jh@suse.cz>.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
28 #include "elf/x86-64.h"
30 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
31 #define MINUS_ONE (~ (bfd_vma) 0)
33 /* The relocation "howto" table. Order of fields:
34 type, size, bitsize, pc_relative, complain_on_overflow,
35 special_function, name, partial_inplace, src_mask, dst_pack, pcrel_offset. */
36 static reloc_howto_type x86_64_elf_howto_table
[] =
38 HOWTO(R_X86_64_NONE
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
39 bfd_elf_generic_reloc
, "R_X86_64_NONE", FALSE
, 0x00000000, 0x00000000,
41 HOWTO(R_X86_64_64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
42 bfd_elf_generic_reloc
, "R_X86_64_64", FALSE
, MINUS_ONE
, MINUS_ONE
,
44 HOWTO(R_X86_64_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
45 bfd_elf_generic_reloc
, "R_X86_64_PC32", FALSE
, 0xffffffff, 0xffffffff,
47 HOWTO(R_X86_64_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
48 bfd_elf_generic_reloc
, "R_X86_64_GOT32", FALSE
, 0xffffffff, 0xffffffff,
50 HOWTO(R_X86_64_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
51 bfd_elf_generic_reloc
, "R_X86_64_PLT32", FALSE
, 0xffffffff, 0xffffffff,
53 HOWTO(R_X86_64_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
54 bfd_elf_generic_reloc
, "R_X86_64_COPY", FALSE
, 0xffffffff, 0xffffffff,
56 HOWTO(R_X86_64_GLOB_DAT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
57 bfd_elf_generic_reloc
, "R_X86_64_GLOB_DAT", FALSE
, MINUS_ONE
,
59 HOWTO(R_X86_64_JUMP_SLOT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
60 bfd_elf_generic_reloc
, "R_X86_64_JUMP_SLOT", FALSE
, MINUS_ONE
,
62 HOWTO(R_X86_64_RELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
63 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE", FALSE
, MINUS_ONE
,
65 HOWTO(R_X86_64_GOTPCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
66 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL", FALSE
, 0xffffffff,
68 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
69 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
71 HOWTO(R_X86_64_32S
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
72 bfd_elf_generic_reloc
, "R_X86_64_32S", FALSE
, 0xffffffff, 0xffffffff,
74 HOWTO(R_X86_64_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
75 bfd_elf_generic_reloc
, "R_X86_64_16", FALSE
, 0xffff, 0xffff, FALSE
),
76 HOWTO(R_X86_64_PC16
,0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
77 bfd_elf_generic_reloc
, "R_X86_64_PC16", FALSE
, 0xffff, 0xffff, TRUE
),
78 HOWTO(R_X86_64_8
, 0, 0, 8, FALSE
, 0, complain_overflow_signed
,
79 bfd_elf_generic_reloc
, "R_X86_64_8", FALSE
, 0xff, 0xff, FALSE
),
80 HOWTO(R_X86_64_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
81 bfd_elf_generic_reloc
, "R_X86_64_PC8", FALSE
, 0xff, 0xff, TRUE
),
82 HOWTO(R_X86_64_DTPMOD64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
83 bfd_elf_generic_reloc
, "R_X86_64_DTPMOD64", FALSE
, MINUS_ONE
,
85 HOWTO(R_X86_64_DTPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
86 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF64", FALSE
, MINUS_ONE
,
88 HOWTO(R_X86_64_TPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
89 bfd_elf_generic_reloc
, "R_X86_64_TPOFF64", FALSE
, MINUS_ONE
,
91 HOWTO(R_X86_64_TLSGD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
92 bfd_elf_generic_reloc
, "R_X86_64_TLSGD", FALSE
, 0xffffffff,
94 HOWTO(R_X86_64_TLSLD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
95 bfd_elf_generic_reloc
, "R_X86_64_TLSLD", FALSE
, 0xffffffff,
97 HOWTO(R_X86_64_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
98 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF32", FALSE
, 0xffffffff,
100 HOWTO(R_X86_64_GOTTPOFF
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
101 bfd_elf_generic_reloc
, "R_X86_64_GOTTPOFF", FALSE
, 0xffffffff,
103 HOWTO(R_X86_64_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
104 bfd_elf_generic_reloc
, "R_X86_64_TPOFF32", FALSE
, 0xffffffff,
106 HOWTO(R_X86_64_PC64
, 0, 4, 64, TRUE
, 0, complain_overflow_bitfield
,
107 bfd_elf_generic_reloc
, "R_X86_64_PC64", FALSE
, MINUS_ONE
, MINUS_ONE
,
109 HOWTO(R_X86_64_GOTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
110 bfd_elf_generic_reloc
, "R_X86_64_GOTOFF64",
111 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
112 HOWTO(R_X86_64_GOTPC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
113 bfd_elf_generic_reloc
, "R_X86_64_GOTPC32",
114 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
116 /* GNU extension to record C++ vtable hierarchy. */
117 HOWTO (R_X86_64_GNU_VTINHERIT
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
118 NULL
, "R_X86_64_GNU_VTINHERIT", FALSE
, 0, 0, FALSE
),
120 /* GNU extension to record C++ vtable member usage. */
121 HOWTO (R_X86_64_GNU_VTENTRY
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
122 _bfd_elf_rel_vtable_reloc_fn
, "R_X86_64_GNU_VTENTRY", FALSE
, 0, 0,
126 /* Map BFD relocs to the x86_64 elf relocs. */
129 bfd_reloc_code_real_type bfd_reloc_val
;
130 unsigned char elf_reloc_val
;
133 static const struct elf_reloc_map x86_64_reloc_map
[] =
135 { BFD_RELOC_NONE
, R_X86_64_NONE
, },
136 { BFD_RELOC_64
, R_X86_64_64
, },
137 { BFD_RELOC_32_PCREL
, R_X86_64_PC32
, },
138 { BFD_RELOC_X86_64_GOT32
, R_X86_64_GOT32
,},
139 { BFD_RELOC_X86_64_PLT32
, R_X86_64_PLT32
,},
140 { BFD_RELOC_X86_64_COPY
, R_X86_64_COPY
, },
141 { BFD_RELOC_X86_64_GLOB_DAT
, R_X86_64_GLOB_DAT
, },
142 { BFD_RELOC_X86_64_JUMP_SLOT
, R_X86_64_JUMP_SLOT
, },
143 { BFD_RELOC_X86_64_RELATIVE
, R_X86_64_RELATIVE
, },
144 { BFD_RELOC_X86_64_GOTPCREL
, R_X86_64_GOTPCREL
, },
145 { BFD_RELOC_32
, R_X86_64_32
, },
146 { BFD_RELOC_X86_64_32S
, R_X86_64_32S
, },
147 { BFD_RELOC_16
, R_X86_64_16
, },
148 { BFD_RELOC_16_PCREL
, R_X86_64_PC16
, },
149 { BFD_RELOC_8
, R_X86_64_8
, },
150 { BFD_RELOC_8_PCREL
, R_X86_64_PC8
, },
151 { BFD_RELOC_X86_64_DTPMOD64
, R_X86_64_DTPMOD64
, },
152 { BFD_RELOC_X86_64_DTPOFF64
, R_X86_64_DTPOFF64
, },
153 { BFD_RELOC_X86_64_TPOFF64
, R_X86_64_TPOFF64
, },
154 { BFD_RELOC_X86_64_TLSGD
, R_X86_64_TLSGD
, },
155 { BFD_RELOC_X86_64_TLSLD
, R_X86_64_TLSLD
, },
156 { BFD_RELOC_X86_64_DTPOFF32
, R_X86_64_DTPOFF32
, },
157 { BFD_RELOC_X86_64_GOTTPOFF
, R_X86_64_GOTTPOFF
, },
158 { BFD_RELOC_X86_64_TPOFF32
, R_X86_64_TPOFF32
, },
159 { BFD_RELOC_64_PCREL
, R_X86_64_PC64
, },
160 { BFD_RELOC_X86_64_GOTOFF64
, R_X86_64_GOTOFF64
, },
161 { BFD_RELOC_X86_64_GOTPC32
, R_X86_64_GOTPC32
, },
162 { BFD_RELOC_VTABLE_INHERIT
, R_X86_64_GNU_VTINHERIT
, },
163 { BFD_RELOC_VTABLE_ENTRY
, R_X86_64_GNU_VTENTRY
, },
167 /* Given a BFD reloc type, return a HOWTO structure. */
168 static reloc_howto_type
*
169 elf64_x86_64_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
170 bfd_reloc_code_real_type code
)
174 for (i
= 0; i
< sizeof (x86_64_reloc_map
) / sizeof (struct elf_reloc_map
);
177 if (x86_64_reloc_map
[i
].bfd_reloc_val
== code
)
178 return &x86_64_elf_howto_table
[i
];
183 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
186 elf64_x86_64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
187 Elf_Internal_Rela
*dst
)
191 r_type
= ELF64_R_TYPE (dst
->r_info
);
192 if (r_type
< (unsigned int) R_X86_64_GNU_VTINHERIT
)
194 BFD_ASSERT (r_type
<= (unsigned int) R_X86_64_GOTPC32
);
199 BFD_ASSERT (r_type
< (unsigned int) R_X86_64_max
);
200 i
= r_type
- ((unsigned int) R_X86_64_GNU_VTINHERIT
- R_X86_64_GOTPC32
- 1);
202 cache_ptr
->howto
= &x86_64_elf_howto_table
[i
];
203 BFD_ASSERT (r_type
== cache_ptr
->howto
->type
);
206 /* Support for core dump NOTE sections. */
208 elf64_x86_64_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
213 switch (note
->descsz
)
218 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
220 elf_tdata (abfd
)->core_signal
221 = bfd_get_16 (abfd
, note
->descdata
+ 12);
224 elf_tdata (abfd
)->core_pid
225 = bfd_get_32 (abfd
, note
->descdata
+ 32);
234 /* Make a ".reg/999" section. */
235 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
236 size
, note
->descpos
+ offset
);
240 elf64_x86_64_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
242 switch (note
->descsz
)
247 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
248 elf_tdata (abfd
)->core_program
249 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
250 elf_tdata (abfd
)->core_command
251 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
254 /* Note that for some reason, a spurious space is tacked
255 onto the end of the args in some (at least one anyway)
256 implementations, so strip it off if it exists. */
259 char *command
= elf_tdata (abfd
)->core_command
;
260 int n
= strlen (command
);
262 if (0 < n
&& command
[n
- 1] == ' ')
263 command
[n
- 1] = '\0';
269 /* Functions for the x86-64 ELF linker. */
271 /* The name of the dynamic interpreter. This is put in the .interp
274 #define ELF_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
276 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
277 copying dynamic variables from a shared lib into an app's dynbss
278 section, and instead use a dynamic relocation to point into the
280 #define ELIMINATE_COPY_RELOCS 1
282 /* The size in bytes of an entry in the global offset table. */
284 #define GOT_ENTRY_SIZE 8
286 /* The size in bytes of an entry in the procedure linkage table. */
288 #define PLT_ENTRY_SIZE 16
290 /* The first entry in a procedure linkage table looks like this. See the
291 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
293 static const bfd_byte elf64_x86_64_plt0_entry
[PLT_ENTRY_SIZE
] =
295 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
296 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
297 0x90, 0x90, 0x90, 0x90 /* pad out to 16 bytes with nops. */
300 /* Subsequent entries in a procedure linkage table look like this. */
302 static const bfd_byte elf64_x86_64_plt_entry
[PLT_ENTRY_SIZE
] =
304 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
305 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
306 0x68, /* pushq immediate */
307 0, 0, 0, 0, /* replaced with index into relocation table. */
308 0xe9, /* jmp relative */
309 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
312 /* The x86-64 linker needs to keep track of the number of relocs that
313 it decides to copy as dynamic relocs in check_relocs for each symbol.
314 This is so that it can later discard them if they are found to be
315 unnecessary. We store the information in a field extending the
316 regular ELF linker hash table. */
318 struct elf64_x86_64_dyn_relocs
321 struct elf64_x86_64_dyn_relocs
*next
;
323 /* The input section of the reloc. */
326 /* Total number of relocs copied for the input section. */
329 /* Number of pc-relative relocs copied for the input section. */
330 bfd_size_type pc_count
;
333 /* x86-64 ELF linker hash entry. */
335 struct elf64_x86_64_link_hash_entry
337 struct elf_link_hash_entry elf
;
339 /* Track dynamic relocs copied for this symbol. */
340 struct elf64_x86_64_dyn_relocs
*dyn_relocs
;
342 #define GOT_UNKNOWN 0
346 unsigned char tls_type
;
349 #define elf64_x86_64_hash_entry(ent) \
350 ((struct elf64_x86_64_link_hash_entry *)(ent))
352 struct elf64_x86_64_obj_tdata
354 struct elf_obj_tdata root
;
356 /* tls_type for each local got entry. */
357 char *local_got_tls_type
;
360 #define elf64_x86_64_tdata(abfd) \
361 ((struct elf64_x86_64_obj_tdata *) (abfd)->tdata.any)
363 #define elf64_x86_64_local_got_tls_type(abfd) \
364 (elf64_x86_64_tdata (abfd)->local_got_tls_type)
367 /* x86-64 ELF linker hash table. */
369 struct elf64_x86_64_link_hash_table
371 struct elf_link_hash_table elf
;
373 /* Short-cuts to get to dynamic linker sections. */
383 bfd_signed_vma refcount
;
387 /* Small local sym to section mapping cache. */
388 struct sym_sec_cache sym_sec
;
391 /* Get the x86-64 ELF linker hash table from a link_info structure. */
393 #define elf64_x86_64_hash_table(p) \
394 ((struct elf64_x86_64_link_hash_table *) ((p)->hash))
396 /* Create an entry in an x86-64 ELF linker hash table. */
398 static struct bfd_hash_entry
*
399 link_hash_newfunc (struct bfd_hash_entry
*entry
, struct bfd_hash_table
*table
,
402 /* Allocate the structure if it has not already been allocated by a
406 entry
= bfd_hash_allocate (table
,
407 sizeof (struct elf64_x86_64_link_hash_entry
));
412 /* Call the allocation method of the superclass. */
413 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
416 struct elf64_x86_64_link_hash_entry
*eh
;
418 eh
= (struct elf64_x86_64_link_hash_entry
*) entry
;
419 eh
->dyn_relocs
= NULL
;
420 eh
->tls_type
= GOT_UNKNOWN
;
426 /* Create an X86-64 ELF linker hash table. */
428 static struct bfd_link_hash_table
*
429 elf64_x86_64_link_hash_table_create (bfd
*abfd
)
431 struct elf64_x86_64_link_hash_table
*ret
;
432 bfd_size_type amt
= sizeof (struct elf64_x86_64_link_hash_table
);
434 ret
= (struct elf64_x86_64_link_hash_table
*) bfd_malloc (amt
);
438 if (! _bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
))
451 ret
->sym_sec
.abfd
= NULL
;
452 ret
->tls_ld_got
.refcount
= 0;
454 return &ret
->elf
.root
;
457 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
458 shortcuts to them in our hash table. */
461 create_got_section (bfd
*dynobj
, struct bfd_link_info
*info
)
463 struct elf64_x86_64_link_hash_table
*htab
;
465 if (! _bfd_elf_create_got_section (dynobj
, info
))
468 htab
= elf64_x86_64_hash_table (info
);
469 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
470 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
471 if (!htab
->sgot
|| !htab
->sgotplt
)
474 htab
->srelgot
= bfd_make_section_with_flags (dynobj
, ".rela.got",
475 (SEC_ALLOC
| SEC_LOAD
480 if (htab
->srelgot
== NULL
481 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 3))
486 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
487 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
491 elf64_x86_64_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
493 struct elf64_x86_64_link_hash_table
*htab
;
495 htab
= elf64_x86_64_hash_table (info
);
496 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
499 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
502 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
503 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rela.plt");
504 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
506 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rela.bss");
508 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
509 || (!info
->shared
&& !htab
->srelbss
))
515 /* Copy the extra info we tack onto an elf_link_hash_entry. */
518 elf64_x86_64_copy_indirect_symbol (const struct elf_backend_data
*bed
,
519 struct elf_link_hash_entry
*dir
,
520 struct elf_link_hash_entry
*ind
)
522 struct elf64_x86_64_link_hash_entry
*edir
, *eind
;
524 edir
= (struct elf64_x86_64_link_hash_entry
*) dir
;
525 eind
= (struct elf64_x86_64_link_hash_entry
*) ind
;
527 if (eind
->dyn_relocs
!= NULL
)
529 if (edir
->dyn_relocs
!= NULL
)
531 struct elf64_x86_64_dyn_relocs
**pp
;
532 struct elf64_x86_64_dyn_relocs
*p
;
534 if (ind
->root
.type
== bfd_link_hash_indirect
)
537 /* Add reloc counts against the weak sym to the strong sym
538 list. Merge any entries against the same section. */
539 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
541 struct elf64_x86_64_dyn_relocs
*q
;
543 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
544 if (q
->sec
== p
->sec
)
546 q
->pc_count
+= p
->pc_count
;
547 q
->count
+= p
->count
;
554 *pp
= edir
->dyn_relocs
;
557 edir
->dyn_relocs
= eind
->dyn_relocs
;
558 eind
->dyn_relocs
= NULL
;
561 if (ind
->root
.type
== bfd_link_hash_indirect
562 && dir
->got
.refcount
<= 0)
564 edir
->tls_type
= eind
->tls_type
;
565 eind
->tls_type
= GOT_UNKNOWN
;
568 if (ELIMINATE_COPY_RELOCS
569 && ind
->root
.type
!= bfd_link_hash_indirect
570 && dir
->dynamic_adjusted
)
572 /* If called to transfer flags for a weakdef during processing
573 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
574 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
575 dir
->ref_dynamic
|= ind
->ref_dynamic
;
576 dir
->ref_regular
|= ind
->ref_regular
;
577 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
578 dir
->needs_plt
|= ind
->needs_plt
;
579 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
582 _bfd_elf_link_hash_copy_indirect (bed
, dir
, ind
);
586 elf64_x86_64_mkobject (bfd
*abfd
)
588 bfd_size_type amt
= sizeof (struct elf64_x86_64_obj_tdata
);
589 abfd
->tdata
.any
= bfd_zalloc (abfd
, amt
);
590 if (abfd
->tdata
.any
== NULL
)
596 elf64_x86_64_elf_object_p (bfd
*abfd
)
598 /* Set the right machine number for an x86-64 elf64 file. */
599 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
604 elf64_x86_64_tls_transition (struct bfd_link_info
*info
, int r_type
, int is_local
)
612 case R_X86_64_GOTTPOFF
:
614 return R_X86_64_TPOFF32
;
615 return R_X86_64_GOTTPOFF
;
617 return R_X86_64_TPOFF32
;
623 /* Look through the relocs for a section during the first phase, and
624 calculate needed space in the global offset table, procedure
625 linkage table, and dynamic reloc sections. */
628 elf64_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
629 const Elf_Internal_Rela
*relocs
)
631 struct elf64_x86_64_link_hash_table
*htab
;
632 Elf_Internal_Shdr
*symtab_hdr
;
633 struct elf_link_hash_entry
**sym_hashes
;
634 const Elf_Internal_Rela
*rel
;
635 const Elf_Internal_Rela
*rel_end
;
638 if (info
->relocatable
)
641 htab
= elf64_x86_64_hash_table (info
);
642 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
643 sym_hashes
= elf_sym_hashes (abfd
);
647 rel_end
= relocs
+ sec
->reloc_count
;
648 for (rel
= relocs
; rel
< rel_end
; rel
++)
651 unsigned long r_symndx
;
652 struct elf_link_hash_entry
*h
;
654 r_symndx
= ELF64_R_SYM (rel
->r_info
);
655 r_type
= ELF64_R_TYPE (rel
->r_info
);
657 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
659 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
664 if (r_symndx
< symtab_hdr
->sh_info
)
668 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
669 while (h
->root
.type
== bfd_link_hash_indirect
670 || h
->root
.type
== bfd_link_hash_warning
)
671 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
674 r_type
= elf64_x86_64_tls_transition (info
, r_type
, h
== NULL
);
678 htab
->tls_ld_got
.refcount
+= 1;
681 case R_X86_64_TPOFF32
:
684 (*_bfd_error_handler
)
685 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
687 x86_64_elf_howto_table
[r_type
].name
,
688 (h
) ? h
->root
.root
.string
: "a local symbol");
689 bfd_set_error (bfd_error_bad_value
);
694 case R_X86_64_GOTTPOFF
:
696 info
->flags
|= DF_STATIC_TLS
;
700 case R_X86_64_GOTPCREL
:
702 /* This symbol requires a global offset table entry. */
704 int tls_type
, old_tls_type
;
708 default: tls_type
= GOT_NORMAL
; break;
709 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
710 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
715 h
->got
.refcount
+= 1;
716 old_tls_type
= elf64_x86_64_hash_entry (h
)->tls_type
;
720 bfd_signed_vma
*local_got_refcounts
;
722 /* This is a global offset table entry for a local symbol. */
723 local_got_refcounts
= elf_local_got_refcounts (abfd
);
724 if (local_got_refcounts
== NULL
)
728 size
= symtab_hdr
->sh_info
;
729 size
*= sizeof (bfd_signed_vma
) + sizeof (char);
730 local_got_refcounts
= ((bfd_signed_vma
*)
731 bfd_zalloc (abfd
, size
));
732 if (local_got_refcounts
== NULL
)
734 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
735 elf64_x86_64_local_got_tls_type (abfd
)
736 = (char *) (local_got_refcounts
+ symtab_hdr
->sh_info
);
738 local_got_refcounts
[r_symndx
] += 1;
740 = elf64_x86_64_local_got_tls_type (abfd
) [r_symndx
];
743 /* If a TLS symbol is accessed using IE at least once,
744 there is no point to use dynamic model for it. */
745 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
746 && (old_tls_type
!= GOT_TLS_GD
|| tls_type
!= GOT_TLS_IE
))
748 if (old_tls_type
== GOT_TLS_IE
&& tls_type
== GOT_TLS_GD
)
749 tls_type
= old_tls_type
;
752 (*_bfd_error_handler
)
753 (_("%B: %s' accessed both as normal and thread local symbol"),
754 abfd
, h
? h
->root
.root
.string
: "<local>");
759 if (old_tls_type
!= tls_type
)
762 elf64_x86_64_hash_entry (h
)->tls_type
= tls_type
;
764 elf64_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
769 case R_X86_64_GOTOFF64
:
770 case R_X86_64_GOTPC32
:
772 if (htab
->sgot
== NULL
)
774 if (htab
->elf
.dynobj
== NULL
)
775 htab
->elf
.dynobj
= abfd
;
776 if (!create_got_section (htab
->elf
.dynobj
, info
))
782 /* This symbol requires a procedure linkage table entry. We
783 actually build the entry in adjust_dynamic_symbol,
784 because this might be a case of linking PIC code which is
785 never referenced by a dynamic object, in which case we
786 don't need to generate a procedure linkage table entry
789 /* If this is a local symbol, we resolve it directly without
790 creating a procedure linkage table entry. */
795 h
->plt
.refcount
+= 1;
802 /* Let's help debug shared library creation. These relocs
803 cannot be used in shared libs. Don't error out for
804 sections we don't care about, such as debug sections or
805 non-constant sections. */
807 && (sec
->flags
& SEC_ALLOC
) != 0
808 && (sec
->flags
& SEC_READONLY
) != 0)
810 (*_bfd_error_handler
)
811 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
813 x86_64_elf_howto_table
[r_type
].name
,
814 (h
) ? h
->root
.root
.string
: "a local symbol");
815 bfd_set_error (bfd_error_bad_value
);
825 if (h
!= NULL
&& !info
->shared
)
827 /* If this reloc is in a read-only section, we might
828 need a copy reloc. We can't check reliably at this
829 stage whether the section is read-only, as input
830 sections have not yet been mapped to output sections.
831 Tentatively set the flag for now, and correct in
832 adjust_dynamic_symbol. */
835 /* We may need a .plt entry if the function this reloc
836 refers to is in a shared lib. */
837 h
->plt
.refcount
+= 1;
838 if (r_type
!= R_X86_64_PC32
&& r_type
!= R_X86_64_PC64
)
839 h
->pointer_equality_needed
= 1;
842 /* If we are creating a shared library, and this is a reloc
843 against a global symbol, or a non PC relative reloc
844 against a local symbol, then we need to copy the reloc
845 into the shared library. However, if we are linking with
846 -Bsymbolic, we do not need to copy a reloc against a
847 global symbol which is defined in an object we are
848 including in the link (i.e., DEF_REGULAR is set). At
849 this point we have not seen all the input files, so it is
850 possible that DEF_REGULAR is not set now but will be set
851 later (it is never cleared). In case of a weak definition,
852 DEF_REGULAR may be cleared later by a strong definition in
853 a shared library. We account for that possibility below by
854 storing information in the relocs_copied field of the hash
855 table entry. A similar situation occurs when creating
856 shared libraries and symbol visibility changes render the
859 If on the other hand, we are creating an executable, we
860 may need to keep relocations for symbols satisfied by a
861 dynamic library if we manage to avoid copy relocs for the
864 && (sec
->flags
& SEC_ALLOC
) != 0
865 && (((r_type
!= R_X86_64_PC8
)
866 && (r_type
!= R_X86_64_PC16
)
867 && (r_type
!= R_X86_64_PC32
)
868 && (r_type
!= R_X86_64_PC64
))
871 || h
->root
.type
== bfd_link_hash_defweak
872 || !h
->def_regular
))))
873 || (ELIMINATE_COPY_RELOCS
875 && (sec
->flags
& SEC_ALLOC
) != 0
877 && (h
->root
.type
== bfd_link_hash_defweak
878 || !h
->def_regular
)))
880 struct elf64_x86_64_dyn_relocs
*p
;
881 struct elf64_x86_64_dyn_relocs
**head
;
883 /* We must copy these reloc types into the output file.
884 Create a reloc section in dynobj and make room for
891 name
= (bfd_elf_string_from_elf_section
893 elf_elfheader (abfd
)->e_shstrndx
,
894 elf_section_data (sec
)->rel_hdr
.sh_name
));
898 if (strncmp (name
, ".rela", 5) != 0
899 || strcmp (bfd_get_section_name (abfd
, sec
),
902 (*_bfd_error_handler
)
903 (_("%B: bad relocation section name `%s\'"),
907 if (htab
->elf
.dynobj
== NULL
)
908 htab
->elf
.dynobj
= abfd
;
910 dynobj
= htab
->elf
.dynobj
;
912 sreloc
= bfd_get_section_by_name (dynobj
, name
);
917 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
918 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
919 if ((sec
->flags
& SEC_ALLOC
) != 0)
920 flags
|= SEC_ALLOC
| SEC_LOAD
;
921 sreloc
= bfd_make_section_with_flags (dynobj
,
925 || ! bfd_set_section_alignment (dynobj
, sreloc
, 3))
928 elf_section_data (sec
)->sreloc
= sreloc
;
931 /* If this is a global symbol, we count the number of
932 relocations we need for this symbol. */
935 head
= &((struct elf64_x86_64_link_hash_entry
*) h
)->dyn_relocs
;
939 /* Track dynamic relocs needed for local syms too.
940 We really need local syms available to do this
944 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
949 head
= ((struct elf64_x86_64_dyn_relocs
**)
950 &elf_section_data (s
)->local_dynrel
);
954 if (p
== NULL
|| p
->sec
!= sec
)
956 bfd_size_type amt
= sizeof *p
;
957 p
= ((struct elf64_x86_64_dyn_relocs
*)
958 bfd_alloc (htab
->elf
.dynobj
, amt
));
969 if (r_type
== R_X86_64_PC8
970 || r_type
== R_X86_64_PC16
971 || r_type
== R_X86_64_PC32
972 || r_type
== R_X86_64_PC64
)
977 /* This relocation describes the C++ object vtable hierarchy.
978 Reconstruct it for later use during GC. */
979 case R_X86_64_GNU_VTINHERIT
:
980 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
984 /* This relocation describes which C++ vtable entries are actually
985 used. Record for later use during GC. */
986 case R_X86_64_GNU_VTENTRY
:
987 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
999 /* Return the section that should be marked against GC for a given
1003 elf64_x86_64_gc_mark_hook (asection
*sec
,
1004 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1005 Elf_Internal_Rela
*rel
,
1006 struct elf_link_hash_entry
*h
,
1007 Elf_Internal_Sym
*sym
)
1011 switch (ELF64_R_TYPE (rel
->r_info
))
1013 case R_X86_64_GNU_VTINHERIT
:
1014 case R_X86_64_GNU_VTENTRY
:
1018 switch (h
->root
.type
)
1020 case bfd_link_hash_defined
:
1021 case bfd_link_hash_defweak
:
1022 return h
->root
.u
.def
.section
;
1024 case bfd_link_hash_common
:
1025 return h
->root
.u
.c
.p
->section
;
1033 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
1038 /* Update the got entry reference counts for the section being removed. */
1041 elf64_x86_64_gc_sweep_hook (bfd
*abfd
, struct bfd_link_info
*info
,
1042 asection
*sec
, const Elf_Internal_Rela
*relocs
)
1044 Elf_Internal_Shdr
*symtab_hdr
;
1045 struct elf_link_hash_entry
**sym_hashes
;
1046 bfd_signed_vma
*local_got_refcounts
;
1047 const Elf_Internal_Rela
*rel
, *relend
;
1049 elf_section_data (sec
)->local_dynrel
= NULL
;
1051 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1052 sym_hashes
= elf_sym_hashes (abfd
);
1053 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1055 relend
= relocs
+ sec
->reloc_count
;
1056 for (rel
= relocs
; rel
< relend
; rel
++)
1058 unsigned long r_symndx
;
1059 unsigned int r_type
;
1060 struct elf_link_hash_entry
*h
= NULL
;
1062 r_symndx
= ELF64_R_SYM (rel
->r_info
);
1063 if (r_symndx
>= symtab_hdr
->sh_info
)
1065 struct elf64_x86_64_link_hash_entry
*eh
;
1066 struct elf64_x86_64_dyn_relocs
**pp
;
1067 struct elf64_x86_64_dyn_relocs
*p
;
1069 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1070 while (h
->root
.type
== bfd_link_hash_indirect
1071 || h
->root
.type
== bfd_link_hash_warning
)
1072 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1073 eh
= (struct elf64_x86_64_link_hash_entry
*) h
;
1075 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1078 /* Everything must go for SEC. */
1084 r_type
= ELF64_R_TYPE (rel
->r_info
);
1085 r_type
= elf64_x86_64_tls_transition (info
, r_type
, h
!= NULL
);
1088 case R_X86_64_TLSLD
:
1089 if (elf64_x86_64_hash_table (info
)->tls_ld_got
.refcount
> 0)
1090 elf64_x86_64_hash_table (info
)->tls_ld_got
.refcount
-= 1;
1093 case R_X86_64_TLSGD
:
1094 case R_X86_64_GOTTPOFF
:
1095 case R_X86_64_GOT32
:
1096 case R_X86_64_GOTPCREL
:
1099 if (h
->got
.refcount
> 0)
1100 h
->got
.refcount
-= 1;
1102 else if (local_got_refcounts
!= NULL
)
1104 if (local_got_refcounts
[r_symndx
] > 0)
1105 local_got_refcounts
[r_symndx
] -= 1;
1122 case R_X86_64_PLT32
:
1125 if (h
->plt
.refcount
> 0)
1126 h
->plt
.refcount
-= 1;
1138 /* Adjust a symbol defined by a dynamic object and referenced by a
1139 regular object. The current definition is in some section of the
1140 dynamic object, but we're not including those sections. We have to
1141 change the definition to something the rest of the link can
1145 elf64_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1146 struct elf_link_hash_entry
*h
)
1148 struct elf64_x86_64_link_hash_table
*htab
;
1150 unsigned int power_of_two
;
1152 /* If this is a function, put it in the procedure linkage table. We
1153 will fill in the contents of the procedure linkage table later,
1154 when we know the address of the .got section. */
1155 if (h
->type
== STT_FUNC
1158 if (h
->plt
.refcount
<= 0
1159 || SYMBOL_CALLS_LOCAL (info
, h
)
1160 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1161 && h
->root
.type
== bfd_link_hash_undefweak
))
1163 /* This case can occur if we saw a PLT32 reloc in an input
1164 file, but the symbol was never referred to by a dynamic
1165 object, or if all references were garbage collected. In
1166 such a case, we don't actually need to build a procedure
1167 linkage table, and we can just do a PC32 reloc instead. */
1168 h
->plt
.offset
= (bfd_vma
) -1;
1175 /* It's possible that we incorrectly decided a .plt reloc was
1176 needed for an R_X86_64_PC32 reloc to a non-function sym in
1177 check_relocs. We can't decide accurately between function and
1178 non-function syms in check-relocs; Objects loaded later in
1179 the link may change h->type. So fix it now. */
1180 h
->plt
.offset
= (bfd_vma
) -1;
1182 /* If this is a weak symbol, and there is a real definition, the
1183 processor independent code will have arranged for us to see the
1184 real definition first, and we can just use the same value. */
1185 if (h
->u
.weakdef
!= NULL
)
1187 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
1188 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
1189 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
1190 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
1191 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
1192 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
1196 /* This is a reference to a symbol defined by a dynamic object which
1197 is not a function. */
1199 /* If we are creating a shared library, we must presume that the
1200 only references to the symbol are via the global offset table.
1201 For such cases we need not do anything here; the relocations will
1202 be handled correctly by relocate_section. */
1206 /* If there are no references to this symbol that do not use the
1207 GOT, we don't need to generate a copy reloc. */
1208 if (!h
->non_got_ref
)
1211 /* If -z nocopyreloc was given, we won't generate them either. */
1212 if (info
->nocopyreloc
)
1218 if (ELIMINATE_COPY_RELOCS
)
1220 struct elf64_x86_64_link_hash_entry
* eh
;
1221 struct elf64_x86_64_dyn_relocs
*p
;
1223 eh
= (struct elf64_x86_64_link_hash_entry
*) h
;
1224 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1226 s
= p
->sec
->output_section
;
1227 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1231 /* If we didn't find any dynamic relocs in read-only sections, then
1232 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1240 /* We must allocate the symbol in our .dynbss section, which will
1241 become part of the .bss section of the executable. There will be
1242 an entry for this symbol in the .dynsym section. The dynamic
1243 object will contain position independent code, so all references
1244 from the dynamic object to this symbol will go through the global
1245 offset table. The dynamic linker will use the .dynsym entry to
1246 determine the address it must put in the global offset table, so
1247 both the dynamic object and the regular object will refer to the
1248 same memory location for the variable. */
1250 htab
= elf64_x86_64_hash_table (info
);
1252 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
1253 to copy the initial value out of the dynamic object and into the
1254 runtime process image. */
1255 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1257 htab
->srelbss
->size
+= sizeof (Elf64_External_Rela
);
1261 /* We need to figure out the alignment required for this symbol. I
1262 have no idea how ELF linkers handle this. 16-bytes is the size
1263 of the largest type that requires hard alignment -- long double. */
1264 /* FIXME: This is VERY ugly. Should be fixed for all architectures using
1266 power_of_two
= bfd_log2 (h
->size
);
1267 if (power_of_two
> 4)
1270 /* Apply the required alignment. */
1272 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
) (1 << power_of_two
));
1273 if (power_of_two
> bfd_get_section_alignment (htab
->elf
.dynobj
, s
))
1275 if (! bfd_set_section_alignment (htab
->elf
.dynobj
, s
, power_of_two
))
1279 /* Define the symbol as being at this point in the section. */
1280 h
->root
.u
.def
.section
= s
;
1281 h
->root
.u
.def
.value
= s
->size
;
1283 /* Increment the section size to make room for the symbol. */
1289 /* Allocate space in .plt, .got and associated reloc sections for
1293 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
1295 struct bfd_link_info
*info
;
1296 struct elf64_x86_64_link_hash_table
*htab
;
1297 struct elf64_x86_64_link_hash_entry
*eh
;
1298 struct elf64_x86_64_dyn_relocs
*p
;
1300 if (h
->root
.type
== bfd_link_hash_indirect
)
1303 if (h
->root
.type
== bfd_link_hash_warning
)
1304 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1306 info
= (struct bfd_link_info
*) inf
;
1307 htab
= elf64_x86_64_hash_table (info
);
1309 if (htab
->elf
.dynamic_sections_created
1310 && h
->plt
.refcount
> 0)
1312 /* Make sure this symbol is output as a dynamic symbol.
1313 Undefined weak syms won't yet be marked as dynamic. */
1314 if (h
->dynindx
== -1
1315 && !h
->forced_local
)
1317 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1322 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
1324 asection
*s
= htab
->splt
;
1326 /* If this is the first .plt entry, make room for the special
1329 s
->size
+= PLT_ENTRY_SIZE
;
1331 h
->plt
.offset
= s
->size
;
1333 /* If this symbol is not defined in a regular file, and we are
1334 not generating a shared library, then set the symbol to this
1335 location in the .plt. This is required to make function
1336 pointers compare as equal between the normal executable and
1337 the shared library. */
1341 h
->root
.u
.def
.section
= s
;
1342 h
->root
.u
.def
.value
= h
->plt
.offset
;
1345 /* Make room for this entry. */
1346 s
->size
+= PLT_ENTRY_SIZE
;
1348 /* We also need to make an entry in the .got.plt section, which
1349 will be placed in the .got section by the linker script. */
1350 htab
->sgotplt
->size
+= GOT_ENTRY_SIZE
;
1352 /* We also need to make an entry in the .rela.plt section. */
1353 htab
->srelplt
->size
+= sizeof (Elf64_External_Rela
);
1357 h
->plt
.offset
= (bfd_vma
) -1;
1363 h
->plt
.offset
= (bfd_vma
) -1;
1367 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
1368 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
1369 if (h
->got
.refcount
> 0
1372 && elf64_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
1373 h
->got
.offset
= (bfd_vma
) -1;
1374 else if (h
->got
.refcount
> 0)
1378 int tls_type
= elf64_x86_64_hash_entry (h
)->tls_type
;
1380 /* Make sure this symbol is output as a dynamic symbol.
1381 Undefined weak syms won't yet be marked as dynamic. */
1382 if (h
->dynindx
== -1
1383 && !h
->forced_local
)
1385 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1390 h
->got
.offset
= s
->size
;
1391 s
->size
+= GOT_ENTRY_SIZE
;
1392 /* R_X86_64_TLSGD needs 2 consecutive GOT slots. */
1393 if (tls_type
== GOT_TLS_GD
)
1394 s
->size
+= GOT_ENTRY_SIZE
;
1395 dyn
= htab
->elf
.dynamic_sections_created
;
1396 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
1398 R_X86_64_GOTTPOFF needs one dynamic relocation. */
1399 if ((tls_type
== GOT_TLS_GD
&& h
->dynindx
== -1)
1400 || tls_type
== GOT_TLS_IE
)
1401 htab
->srelgot
->size
+= sizeof (Elf64_External_Rela
);
1402 else if (tls_type
== GOT_TLS_GD
)
1403 htab
->srelgot
->size
+= 2 * sizeof (Elf64_External_Rela
);
1404 else if ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
1405 || h
->root
.type
!= bfd_link_hash_undefweak
)
1407 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
1408 htab
->srelgot
->size
+= sizeof (Elf64_External_Rela
);
1411 h
->got
.offset
= (bfd_vma
) -1;
1413 eh
= (struct elf64_x86_64_link_hash_entry
*) h
;
1414 if (eh
->dyn_relocs
== NULL
)
1417 /* In the shared -Bsymbolic case, discard space allocated for
1418 dynamic pc-relative relocs against symbols which turn out to be
1419 defined in regular objects. For the normal shared case, discard
1420 space for pc-relative relocs that have become local due to symbol
1421 visibility changes. */
1425 /* Relocs that use pc_count are those that appear on a call
1426 insn, or certain REL relocs that can generated via assembly.
1427 We want calls to protected symbols to resolve directly to the
1428 function rather than going via the plt. If people want
1429 function pointer comparisons to work as expected then they
1430 should avoid writing weird assembly. */
1431 if (SYMBOL_CALLS_LOCAL (info
, h
))
1433 struct elf64_x86_64_dyn_relocs
**pp
;
1435 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1437 p
->count
-= p
->pc_count
;
1446 /* Also discard relocs on undefined weak syms with non-default
1448 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1449 && h
->root
.type
== bfd_link_hash_undefweak
)
1450 eh
->dyn_relocs
= NULL
;
1452 else if (ELIMINATE_COPY_RELOCS
)
1454 /* For the non-shared case, discard space for relocs against
1455 symbols which turn out to need copy relocs or are not
1461 || (htab
->elf
.dynamic_sections_created
1462 && (h
->root
.type
== bfd_link_hash_undefweak
1463 || h
->root
.type
== bfd_link_hash_undefined
))))
1465 /* Make sure this symbol is output as a dynamic symbol.
1466 Undefined weak syms won't yet be marked as dynamic. */
1467 if (h
->dynindx
== -1
1468 && !h
->forced_local
)
1470 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1474 /* If that succeeded, we know we'll be keeping all the
1476 if (h
->dynindx
!= -1)
1480 eh
->dyn_relocs
= NULL
;
1485 /* Finally, allocate space. */
1486 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1488 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1489 sreloc
->size
+= p
->count
* sizeof (Elf64_External_Rela
);
1495 /* Find any dynamic relocs that apply to read-only sections. */
1498 readonly_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
1500 struct elf64_x86_64_link_hash_entry
*eh
;
1501 struct elf64_x86_64_dyn_relocs
*p
;
1503 if (h
->root
.type
== bfd_link_hash_warning
)
1504 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1506 eh
= (struct elf64_x86_64_link_hash_entry
*) h
;
1507 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1509 asection
*s
= p
->sec
->output_section
;
1511 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1513 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
1515 info
->flags
|= DF_TEXTREL
;
1517 /* Not an error, just cut short the traversal. */
1524 /* Set the sizes of the dynamic sections. */
1527 elf64_x86_64_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1528 struct bfd_link_info
*info
)
1530 struct elf64_x86_64_link_hash_table
*htab
;
1536 htab
= elf64_x86_64_hash_table (info
);
1537 dynobj
= htab
->elf
.dynobj
;
1541 if (htab
->elf
.dynamic_sections_created
)
1543 /* Set the contents of the .interp section to the interpreter. */
1544 if (info
->executable
)
1546 s
= bfd_get_section_by_name (dynobj
, ".interp");
1549 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1550 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1554 /* Set up .got offsets for local syms, and space for local dynamic
1556 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
1558 bfd_signed_vma
*local_got
;
1559 bfd_signed_vma
*end_local_got
;
1560 char *local_tls_type
;
1561 bfd_size_type locsymcount
;
1562 Elf_Internal_Shdr
*symtab_hdr
;
1565 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
1568 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1570 struct elf64_x86_64_dyn_relocs
*p
;
1572 for (p
= *((struct elf64_x86_64_dyn_relocs
**)
1573 &elf_section_data (s
)->local_dynrel
);
1577 if (!bfd_is_abs_section (p
->sec
)
1578 && bfd_is_abs_section (p
->sec
->output_section
))
1580 /* Input section has been discarded, either because
1581 it is a copy of a linkonce section or due to
1582 linker script /DISCARD/, so we'll be discarding
1585 else if (p
->count
!= 0)
1587 srel
= elf_section_data (p
->sec
)->sreloc
;
1588 srel
->size
+= p
->count
* sizeof (Elf64_External_Rela
);
1589 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1590 info
->flags
|= DF_TEXTREL
;
1596 local_got
= elf_local_got_refcounts (ibfd
);
1600 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1601 locsymcount
= symtab_hdr
->sh_info
;
1602 end_local_got
= local_got
+ locsymcount
;
1603 local_tls_type
= elf64_x86_64_local_got_tls_type (ibfd
);
1605 srel
= htab
->srelgot
;
1606 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
1610 *local_got
= s
->size
;
1611 s
->size
+= GOT_ENTRY_SIZE
;
1612 if (*local_tls_type
== GOT_TLS_GD
)
1613 s
->size
+= GOT_ENTRY_SIZE
;
1615 || *local_tls_type
== GOT_TLS_GD
1616 || *local_tls_type
== GOT_TLS_IE
)
1617 srel
->size
+= sizeof (Elf64_External_Rela
);
1620 *local_got
= (bfd_vma
) -1;
1624 if (htab
->tls_ld_got
.refcount
> 0)
1626 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
1628 htab
->tls_ld_got
.offset
= htab
->sgot
->size
;
1629 htab
->sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
1630 htab
->srelgot
->size
+= sizeof (Elf64_External_Rela
);
1633 htab
->tls_ld_got
.offset
= -1;
1635 /* Allocate global sym .plt and .got entries, and space for global
1636 sym dynamic relocs. */
1637 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, (PTR
) info
);
1639 /* We now have determined the sizes of the various dynamic sections.
1640 Allocate memory for them. */
1642 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1644 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1649 || s
== htab
->sgotplt
1650 || s
== htab
->sdynbss
)
1652 /* Strip this section if we don't need it; see the
1655 else if (strncmp (bfd_get_section_name (dynobj
, s
), ".rela", 5) == 0)
1657 if (s
->size
!= 0 && s
!= htab
->srelplt
)
1660 /* We use the reloc_count field as a counter if we need
1661 to copy relocs into the output file. */
1666 /* It's not one of our sections, so don't allocate space. */
1672 /* If we don't need this section, strip it from the
1673 output file. This is mostly to handle .rela.bss and
1674 .rela.plt. We must create both sections in
1675 create_dynamic_sections, because they must be created
1676 before the linker maps input sections to output
1677 sections. The linker does that before
1678 adjust_dynamic_symbol is called, and it is that
1679 function which decides whether anything needs to go
1680 into these sections. */
1682 s
->flags
|= SEC_EXCLUDE
;
1686 /* Allocate memory for the section contents. We use bfd_zalloc
1687 here in case unused entries are not reclaimed before the
1688 section's contents are written out. This should not happen,
1689 but this way if it does, we get a R_X86_64_NONE reloc instead
1691 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1692 if (s
->contents
== NULL
)
1696 if (htab
->elf
.dynamic_sections_created
)
1698 /* Add some entries to the .dynamic section. We fill in the
1699 values later, in elf64_x86_64_finish_dynamic_sections, but we
1700 must add the entries now so that we get the correct size for
1701 the .dynamic section. The DT_DEBUG entry is filled in by the
1702 dynamic linker and used by the debugger. */
1703 #define add_dynamic_entry(TAG, VAL) \
1704 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1706 if (info
->executable
)
1708 if (!add_dynamic_entry (DT_DEBUG
, 0))
1712 if (htab
->splt
->size
!= 0)
1714 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1715 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1716 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1717 || !add_dynamic_entry (DT_JMPREL
, 0))
1723 if (!add_dynamic_entry (DT_RELA
, 0)
1724 || !add_dynamic_entry (DT_RELASZ
, 0)
1725 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf64_External_Rela
)))
1728 /* If any dynamic relocs apply to a read-only section,
1729 then we need a DT_TEXTREL entry. */
1730 if ((info
->flags
& DF_TEXTREL
) == 0)
1731 elf_link_hash_traverse (&htab
->elf
, readonly_dynrelocs
,
1734 if ((info
->flags
& DF_TEXTREL
) != 0)
1736 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1741 #undef add_dynamic_entry
1746 /* Return the base VMA address which should be subtracted from real addresses
1747 when resolving @dtpoff relocation.
1748 This is PT_TLS segment p_vaddr. */
1751 dtpoff_base (struct bfd_link_info
*info
)
1753 /* If tls_sec is NULL, we should have signalled an error already. */
1754 if (elf_hash_table (info
)->tls_sec
== NULL
)
1756 return elf_hash_table (info
)->tls_sec
->vma
;
1759 /* Return the relocation value for @tpoff relocation
1760 if STT_TLS virtual address is ADDRESS. */
1763 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1765 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1767 /* If tls_segment is NULL, we should have signalled an error already. */
1768 if (htab
->tls_sec
== NULL
)
1770 return address
- htab
->tls_size
- htab
->tls_sec
->vma
;
1773 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
1777 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
1779 /* Opcode Instruction
1782 0x0f 0x8x conditional jump */
1784 && (contents
[offset
- 1] == 0xe8
1785 || contents
[offset
- 1] == 0xe9))
1787 && contents
[offset
- 2] == 0x0f
1788 && (contents
[offset
- 1] & 0xf0) == 0x80));
1791 /* Relocate an x86_64 ELF section. */
1794 elf64_x86_64_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
1795 bfd
*input_bfd
, asection
*input_section
,
1796 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
1797 Elf_Internal_Sym
*local_syms
,
1798 asection
**local_sections
)
1800 struct elf64_x86_64_link_hash_table
*htab
;
1801 Elf_Internal_Shdr
*symtab_hdr
;
1802 struct elf_link_hash_entry
**sym_hashes
;
1803 bfd_vma
*local_got_offsets
;
1804 Elf_Internal_Rela
*rel
;
1805 Elf_Internal_Rela
*relend
;
1807 if (info
->relocatable
)
1810 htab
= elf64_x86_64_hash_table (info
);
1811 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1812 sym_hashes
= elf_sym_hashes (input_bfd
);
1813 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1816 relend
= relocs
+ input_section
->reloc_count
;
1817 for (; rel
< relend
; rel
++)
1819 unsigned int r_type
;
1820 reloc_howto_type
*howto
;
1821 unsigned long r_symndx
;
1822 struct elf_link_hash_entry
*h
;
1823 Elf_Internal_Sym
*sym
;
1827 bfd_boolean unresolved_reloc
;
1828 bfd_reloc_status_type r
;
1831 r_type
= ELF64_R_TYPE (rel
->r_info
);
1832 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
1833 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
1836 if (r_type
>= R_X86_64_max
)
1838 bfd_set_error (bfd_error_bad_value
);
1842 howto
= x86_64_elf_howto_table
+ r_type
;
1843 r_symndx
= ELF64_R_SYM (rel
->r_info
);
1847 unresolved_reloc
= FALSE
;
1848 if (r_symndx
< symtab_hdr
->sh_info
)
1850 sym
= local_syms
+ r_symndx
;
1851 sec
= local_sections
[r_symndx
];
1853 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
1859 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1860 r_symndx
, symtab_hdr
, sym_hashes
,
1862 unresolved_reloc
, warned
);
1864 /* When generating a shared object, the relocations handled here are
1865 copied into the output file to be resolved at run time. */
1868 case R_X86_64_GOT32
:
1869 /* Relocation is to the entry for this symbol in the global
1871 case R_X86_64_GOTPCREL
:
1872 /* Use global offset table as symbol value. */
1873 if (htab
->sgot
== NULL
)
1880 off
= h
->got
.offset
;
1881 dyn
= htab
->elf
.dynamic_sections_created
;
1883 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
1885 && SYMBOL_REFERENCES_LOCAL (info
, h
))
1886 || (ELF_ST_VISIBILITY (h
->other
)
1887 && h
->root
.type
== bfd_link_hash_undefweak
))
1889 /* This is actually a static link, or it is a -Bsymbolic
1890 link and the symbol is defined locally, or the symbol
1891 was forced to be local because of a version file. We
1892 must initialize this entry in the global offset table.
1893 Since the offset must always be a multiple of 8, we
1894 use the least significant bit to record whether we
1895 have initialized it already.
1897 When doing a dynamic link, we create a .rela.got
1898 relocation entry to initialize the value. This is
1899 done in the finish_dynamic_symbol routine. */
1904 bfd_put_64 (output_bfd
, relocation
,
1905 htab
->sgot
->contents
+ off
);
1910 unresolved_reloc
= FALSE
;
1914 if (local_got_offsets
== NULL
)
1917 off
= local_got_offsets
[r_symndx
];
1919 /* The offset must always be a multiple of 8. We use
1920 the least significant bit to record whether we have
1921 already generated the necessary reloc. */
1926 bfd_put_64 (output_bfd
, relocation
,
1927 htab
->sgot
->contents
+ off
);
1932 Elf_Internal_Rela outrel
;
1935 /* We need to generate a R_X86_64_RELATIVE reloc
1936 for the dynamic linker. */
1941 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
1942 + htab
->sgot
->output_offset
1944 outrel
.r_info
= ELF64_R_INFO (0, R_X86_64_RELATIVE
);
1945 outrel
.r_addend
= relocation
;
1947 loc
+= s
->reloc_count
++ * sizeof (Elf64_External_Rela
);
1948 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
1951 local_got_offsets
[r_symndx
] |= 1;
1955 if (off
>= (bfd_vma
) -2)
1958 relocation
= htab
->sgot
->output_section
->vma
1959 + htab
->sgot
->output_offset
+ off
;
1960 if (r_type
!= R_X86_64_GOTPCREL
)
1961 relocation
-= htab
->sgotplt
->output_section
->vma
1962 - htab
->sgotplt
->output_offset
;
1966 case R_X86_64_GOTOFF64
:
1967 /* Relocation is relative to the start of the global offset
1970 /* Check to make sure it isn't a protected function symbol
1971 for shared library since it may not be local when used
1972 as function address. */
1976 && h
->type
== STT_FUNC
1977 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
1979 (*_bfd_error_handler
)
1980 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
1981 input_bfd
, h
->root
.root
.string
);
1982 bfd_set_error (bfd_error_bad_value
);
1986 /* Note that sgot is not involved in this
1987 calculation. We always want the start of .got.plt. If we
1988 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
1989 permitted by the ABI, we might have to change this
1991 relocation
-= htab
->sgotplt
->output_section
->vma
1992 + htab
->sgotplt
->output_offset
;
1995 case R_X86_64_GOTPC32
:
1996 /* Use global offset table as symbol value. */
1997 relocation
= htab
->sgotplt
->output_section
->vma
1998 + htab
->sgotplt
->output_offset
;
1999 unresolved_reloc
= FALSE
;
2002 case R_X86_64_PLT32
:
2003 /* Relocation is to the entry for this symbol in the
2004 procedure linkage table. */
2006 /* Resolve a PLT32 reloc against a local symbol directly,
2007 without using the procedure linkage table. */
2011 if (h
->plt
.offset
== (bfd_vma
) -1
2012 || htab
->splt
== NULL
)
2014 /* We didn't make a PLT entry for this symbol. This
2015 happens when statically linking PIC code, or when
2016 using -Bsymbolic. */
2020 relocation
= (htab
->splt
->output_section
->vma
2021 + htab
->splt
->output_offset
2023 unresolved_reloc
= FALSE
;
2030 && !SYMBOL_REFERENCES_LOCAL (info
, h
)
2031 && (input_section
->flags
& SEC_ALLOC
) != 0
2032 && (input_section
->flags
& SEC_READONLY
) != 0
2034 || r_type
!= R_X86_64_PC32
2035 || h
->type
!= STT_FUNC
2036 || ELF_ST_VISIBILITY (h
->other
) != STV_PROTECTED
2037 || !is_32bit_relative_branch (contents
,
2041 && r_type
== R_X86_64_PC32
2042 && h
->type
== STT_FUNC
2043 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
2044 (*_bfd_error_handler
)
2045 (_("%B: relocation R_X86_64_PC32 against protected function `%s' can not be used when making a shared object"),
2046 input_bfd
, h
->root
.root
.string
);
2048 (*_bfd_error_handler
)
2049 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
2050 input_bfd
, x86_64_elf_howto_table
[r_type
].name
,
2051 h
->root
.root
.string
);
2052 bfd_set_error (bfd_error_bad_value
);
2062 /* FIXME: The ABI says the linker should make sure the value is
2063 the same when it's zeroextended to 64 bit. */
2065 /* r_symndx will be zero only for relocs against symbols
2066 from removed linkonce sections, or sections discarded by
2069 || (input_section
->flags
& SEC_ALLOC
) == 0)
2074 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2075 || h
->root
.type
!= bfd_link_hash_undefweak
)
2076 && ((r_type
!= R_X86_64_PC8
2077 && r_type
!= R_X86_64_PC16
2078 && r_type
!= R_X86_64_PC32
2079 && r_type
!= R_X86_64_PC64
)
2080 || !SYMBOL_CALLS_LOCAL (info
, h
)))
2081 || (ELIMINATE_COPY_RELOCS
2088 || h
->root
.type
== bfd_link_hash_undefweak
2089 || h
->root
.type
== bfd_link_hash_undefined
)))
2091 Elf_Internal_Rela outrel
;
2093 bfd_boolean skip
, relocate
;
2096 /* When generating a shared object, these relocations
2097 are copied into the output file to be resolved at run
2103 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2105 if (outrel
.r_offset
== (bfd_vma
) -1)
2107 else if (outrel
.r_offset
== (bfd_vma
) -2)
2108 skip
= TRUE
, relocate
= TRUE
;
2110 outrel
.r_offset
+= (input_section
->output_section
->vma
2111 + input_section
->output_offset
);
2114 memset (&outrel
, 0, sizeof outrel
);
2116 /* h->dynindx may be -1 if this symbol was marked to
2120 && (r_type
== R_X86_64_PC8
2121 || r_type
== R_X86_64_PC16
2122 || r_type
== R_X86_64_PC32
2123 || r_type
== R_X86_64_PC64
2126 || !h
->def_regular
))
2128 outrel
.r_info
= ELF64_R_INFO (h
->dynindx
, r_type
);
2129 outrel
.r_addend
= rel
->r_addend
;
2133 /* This symbol is local, or marked to become local. */
2134 if (r_type
== R_X86_64_64
)
2137 outrel
.r_info
= ELF64_R_INFO (0, R_X86_64_RELATIVE
);
2138 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2144 if (bfd_is_abs_section (sec
))
2146 else if (sec
== NULL
|| sec
->owner
== NULL
)
2148 bfd_set_error (bfd_error_bad_value
);
2155 osec
= sec
->output_section
;
2156 sindx
= elf_section_data (osec
)->dynindx
;
2157 BFD_ASSERT (sindx
> 0);
2160 outrel
.r_info
= ELF64_R_INFO (sindx
, r_type
);
2161 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2165 sreloc
= elf_section_data (input_section
)->sreloc
;
2169 loc
= sreloc
->contents
;
2170 loc
+= sreloc
->reloc_count
++ * sizeof (Elf64_External_Rela
);
2171 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
2173 /* If this reloc is against an external symbol, we do
2174 not want to fiddle with the addend. Otherwise, we
2175 need to include the symbol value so that it becomes
2176 an addend for the dynamic reloc. */
2183 case R_X86_64_TLSGD
:
2184 case R_X86_64_GOTTPOFF
:
2185 r_type
= elf64_x86_64_tls_transition (info
, r_type
, h
== NULL
);
2186 tls_type
= GOT_UNKNOWN
;
2187 if (h
== NULL
&& local_got_offsets
)
2188 tls_type
= elf64_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
2191 tls_type
= elf64_x86_64_hash_entry (h
)->tls_type
;
2192 if (!info
->shared
&& h
->dynindx
== -1 && tls_type
== GOT_TLS_IE
)
2193 r_type
= R_X86_64_TPOFF32
;
2195 if (r_type
== R_X86_64_TLSGD
)
2197 if (tls_type
== GOT_TLS_IE
)
2198 r_type
= R_X86_64_GOTTPOFF
;
2201 if (r_type
== R_X86_64_TPOFF32
)
2203 BFD_ASSERT (! unresolved_reloc
);
2204 if (ELF64_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
2207 static unsigned char tlsgd
[8]
2208 = { 0x66, 0x48, 0x8d, 0x3d, 0x66, 0x66, 0x48, 0xe8 };
2210 /* GD->LE transition.
2211 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
2212 .word 0x6666; rex64; call __tls_get_addr@plt
2215 leaq foo@tpoff(%rax), %rax */
2216 BFD_ASSERT (rel
->r_offset
>= 4);
2217 for (i
= 0; i
< 4; i
++)
2218 BFD_ASSERT (bfd_get_8 (input_bfd
,
2219 contents
+ rel
->r_offset
- 4 + i
)
2221 BFD_ASSERT (rel
->r_offset
+ 12 <= input_section
->size
);
2222 for (i
= 0; i
< 4; i
++)
2223 BFD_ASSERT (bfd_get_8 (input_bfd
,
2224 contents
+ rel
->r_offset
+ 4 + i
)
2226 BFD_ASSERT (rel
+ 1 < relend
);
2227 BFD_ASSERT (ELF64_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
);
2228 memcpy (contents
+ rel
->r_offset
- 4,
2229 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
2231 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
2232 contents
+ rel
->r_offset
+ 8);
2233 /* Skip R_X86_64_PLT32. */
2239 unsigned int val
, type
, reg
;
2241 /* IE->LE transition:
2242 Originally it can be one of:
2243 movq foo@gottpoff(%rip), %reg
2244 addq foo@gottpoff(%rip), %reg
2247 leaq foo(%reg), %reg
2249 BFD_ASSERT (rel
->r_offset
>= 3);
2250 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 3);
2251 BFD_ASSERT (val
== 0x48 || val
== 0x4c);
2252 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
2253 BFD_ASSERT (type
== 0x8b || type
== 0x03);
2254 reg
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
2255 BFD_ASSERT ((reg
& 0xc7) == 5);
2257 BFD_ASSERT (rel
->r_offset
+ 4 <= input_section
->size
);
2262 bfd_put_8 (output_bfd
, 0x49,
2263 contents
+ rel
->r_offset
- 3);
2264 bfd_put_8 (output_bfd
, 0xc7,
2265 contents
+ rel
->r_offset
- 2);
2266 bfd_put_8 (output_bfd
, 0xc0 | reg
,
2267 contents
+ rel
->r_offset
- 1);
2271 /* addq -> addq - addressing with %rsp/%r12 is
2274 bfd_put_8 (output_bfd
, 0x49,
2275 contents
+ rel
->r_offset
- 3);
2276 bfd_put_8 (output_bfd
, 0x81,
2277 contents
+ rel
->r_offset
- 2);
2278 bfd_put_8 (output_bfd
, 0xc0 | reg
,
2279 contents
+ rel
->r_offset
- 1);
2285 bfd_put_8 (output_bfd
, 0x4d,
2286 contents
+ rel
->r_offset
- 3);
2287 bfd_put_8 (output_bfd
, 0x8d,
2288 contents
+ rel
->r_offset
- 2);
2289 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
2290 contents
+ rel
->r_offset
- 1);
2292 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
2293 contents
+ rel
->r_offset
);
2298 if (htab
->sgot
== NULL
)
2302 off
= h
->got
.offset
;
2305 if (local_got_offsets
== NULL
)
2308 off
= local_got_offsets
[r_symndx
];
2315 Elf_Internal_Rela outrel
;
2319 if (htab
->srelgot
== NULL
)
2322 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
2323 + htab
->sgot
->output_offset
+ off
);
2325 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
2326 if (r_type
== R_X86_64_TLSGD
)
2327 dr_type
= R_X86_64_DTPMOD64
;
2329 dr_type
= R_X86_64_TPOFF64
;
2331 bfd_put_64 (output_bfd
, 0, htab
->sgot
->contents
+ off
);
2332 outrel
.r_addend
= 0;
2333 if (dr_type
== R_X86_64_TPOFF64
&& indx
== 0)
2334 outrel
.r_addend
= relocation
- dtpoff_base (info
);
2335 outrel
.r_info
= ELF64_R_INFO (indx
, dr_type
);
2337 loc
= htab
->srelgot
->contents
;
2338 loc
+= htab
->srelgot
->reloc_count
++ * sizeof (Elf64_External_Rela
);
2339 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
2341 if (r_type
== R_X86_64_TLSGD
)
2345 BFD_ASSERT (! unresolved_reloc
);
2346 bfd_put_64 (output_bfd
,
2347 relocation
- dtpoff_base (info
),
2348 htab
->sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
2352 bfd_put_64 (output_bfd
, 0,
2353 htab
->sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
2354 outrel
.r_info
= ELF64_R_INFO (indx
,
2356 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
2357 htab
->srelgot
->reloc_count
++;
2358 loc
+= sizeof (Elf64_External_Rela
);
2359 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
2366 local_got_offsets
[r_symndx
] |= 1;
2369 if (off
>= (bfd_vma
) -2)
2371 if (r_type
== ELF64_R_TYPE (rel
->r_info
))
2373 relocation
= htab
->sgot
->output_section
->vma
2374 + htab
->sgot
->output_offset
+ off
;
2375 unresolved_reloc
= FALSE
;
2380 static unsigned char tlsgd
[8]
2381 = { 0x66, 0x48, 0x8d, 0x3d, 0x66, 0x66, 0x48, 0xe8 };
2383 /* GD->IE transition.
2384 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
2385 .word 0x6666; rex64; call __tls_get_addr@plt
2388 addq foo@gottpoff(%rip), %rax */
2389 BFD_ASSERT (rel
->r_offset
>= 4);
2390 for (i
= 0; i
< 4; i
++)
2391 BFD_ASSERT (bfd_get_8 (input_bfd
,
2392 contents
+ rel
->r_offset
- 4 + i
)
2394 BFD_ASSERT (rel
->r_offset
+ 12 <= input_section
->size
);
2395 for (i
= 0; i
< 4; i
++)
2396 BFD_ASSERT (bfd_get_8 (input_bfd
,
2397 contents
+ rel
->r_offset
+ 4 + i
)
2399 BFD_ASSERT (rel
+ 1 < relend
);
2400 BFD_ASSERT (ELF64_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
);
2401 memcpy (contents
+ rel
->r_offset
- 4,
2402 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
2405 relocation
= (htab
->sgot
->output_section
->vma
2406 + htab
->sgot
->output_offset
+ off
2408 - input_section
->output_section
->vma
2409 - input_section
->output_offset
2411 bfd_put_32 (output_bfd
, relocation
,
2412 contents
+ rel
->r_offset
+ 8);
2413 /* Skip R_X86_64_PLT32. */
2419 case R_X86_64_TLSLD
:
2422 /* LD->LE transition:
2424 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr@plt.
2426 .word 0x6666; .byte 0x66; movl %fs:0, %rax. */
2427 BFD_ASSERT (rel
->r_offset
>= 3);
2428 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 3)
2430 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2)
2432 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1)
2434 BFD_ASSERT (rel
->r_offset
+ 9 <= input_section
->size
);
2435 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
+ 4)
2437 BFD_ASSERT (rel
+ 1 < relend
);
2438 BFD_ASSERT (ELF64_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
);
2439 memcpy (contents
+ rel
->r_offset
- 3,
2440 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
2441 /* Skip R_X86_64_PLT32. */
2446 if (htab
->sgot
== NULL
)
2449 off
= htab
->tls_ld_got
.offset
;
2454 Elf_Internal_Rela outrel
;
2457 if (htab
->srelgot
== NULL
)
2460 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
2461 + htab
->sgot
->output_offset
+ off
);
2463 bfd_put_64 (output_bfd
, 0,
2464 htab
->sgot
->contents
+ off
);
2465 bfd_put_64 (output_bfd
, 0,
2466 htab
->sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
2467 outrel
.r_info
= ELF64_R_INFO (0, R_X86_64_DTPMOD64
);
2468 outrel
.r_addend
= 0;
2469 loc
= htab
->srelgot
->contents
;
2470 loc
+= htab
->srelgot
->reloc_count
++ * sizeof (Elf64_External_Rela
);
2471 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
2472 htab
->tls_ld_got
.offset
|= 1;
2474 relocation
= htab
->sgot
->output_section
->vma
2475 + htab
->sgot
->output_offset
+ off
;
2476 unresolved_reloc
= FALSE
;
2479 case R_X86_64_DTPOFF32
:
2480 if (info
->shared
|| (input_section
->flags
& SEC_CODE
) == 0)
2481 relocation
-= dtpoff_base (info
);
2483 relocation
= tpoff (info
, relocation
);
2486 case R_X86_64_TPOFF32
:
2487 BFD_ASSERT (! info
->shared
);
2488 relocation
= tpoff (info
, relocation
);
2495 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2496 because such sections are not SEC_ALLOC and thus ld.so will
2497 not process them. */
2498 if (unresolved_reloc
2499 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
2501 (*_bfd_error_handler
)
2502 (_("%B(%A+0x%lx): unresolvable relocation against symbol `%s'"),
2505 (long) rel
->r_offset
,
2506 h
->root
.root
.string
);
2508 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
2509 contents
, rel
->r_offset
,
2510 relocation
, rel
->r_addend
);
2512 if (r
!= bfd_reloc_ok
)
2517 name
= h
->root
.root
.string
;
2520 name
= bfd_elf_string_from_elf_section (input_bfd
,
2521 symtab_hdr
->sh_link
,
2526 name
= bfd_section_name (input_bfd
, sec
);
2529 if (r
== bfd_reloc_overflow
)
2532 && h
->root
.type
== bfd_link_hash_undefweak
2533 && howto
->pc_relative
)
2534 /* Ignore reloc overflow on branches to undefweak syms. */
2537 if (! ((*info
->callbacks
->reloc_overflow
)
2538 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
2539 (bfd_vma
) 0, input_bfd
, input_section
,
2545 (*_bfd_error_handler
)
2546 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
2547 input_bfd
, input_section
,
2548 (long) rel
->r_offset
, name
, (int) r
);
2557 /* Finish up dynamic symbol handling. We set the contents of various
2558 dynamic sections here. */
2561 elf64_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
2562 struct bfd_link_info
*info
,
2563 struct elf_link_hash_entry
*h
,
2564 Elf_Internal_Sym
*sym
)
2566 struct elf64_x86_64_link_hash_table
*htab
;
2568 htab
= elf64_x86_64_hash_table (info
);
2570 if (h
->plt
.offset
!= (bfd_vma
) -1)
2574 Elf_Internal_Rela rela
;
2577 /* This symbol has an entry in the procedure linkage table. Set
2579 if (h
->dynindx
== -1
2580 || htab
->splt
== NULL
2581 || htab
->sgotplt
== NULL
2582 || htab
->srelplt
== NULL
)
2585 /* Get the index in the procedure linkage table which
2586 corresponds to this symbol. This is the index of this symbol
2587 in all the symbols for which we are making plt entries. The
2588 first entry in the procedure linkage table is reserved. */
2589 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
2591 /* Get the offset into the .got table of the entry that
2592 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
2593 bytes. The first three are reserved for the dynamic linker. */
2594 got_offset
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
2596 /* Fill in the entry in the procedure linkage table. */
2597 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf64_x86_64_plt_entry
,
2600 /* Insert the relocation positions of the plt section. The magic
2601 numbers at the end of the statements are the positions of the
2602 relocations in the plt section. */
2603 /* Put offset for jmp *name@GOTPCREL(%rip), since the
2604 instruction uses 6 bytes, subtract this value. */
2605 bfd_put_32 (output_bfd
,
2606 (htab
->sgotplt
->output_section
->vma
2607 + htab
->sgotplt
->output_offset
2609 - htab
->splt
->output_section
->vma
2610 - htab
->splt
->output_offset
2613 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
2614 /* Put relocation index. */
2615 bfd_put_32 (output_bfd
, plt_index
,
2616 htab
->splt
->contents
+ h
->plt
.offset
+ 7);
2617 /* Put offset for jmp .PLT0. */
2618 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
2619 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
2621 /* Fill in the entry in the global offset table, initially this
2622 points to the pushq instruction in the PLT which is at offset 6. */
2623 bfd_put_64 (output_bfd
, (htab
->splt
->output_section
->vma
2624 + htab
->splt
->output_offset
2625 + h
->plt
.offset
+ 6),
2626 htab
->sgotplt
->contents
+ got_offset
);
2628 /* Fill in the entry in the .rela.plt section. */
2629 rela
.r_offset
= (htab
->sgotplt
->output_section
->vma
2630 + htab
->sgotplt
->output_offset
2632 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_X86_64_JUMP_SLOT
);
2634 loc
= htab
->srelplt
->contents
+ plt_index
* sizeof (Elf64_External_Rela
);
2635 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
2637 if (!h
->def_regular
)
2639 /* Mark the symbol as undefined, rather than as defined in
2640 the .plt section. Leave the value if there were any
2641 relocations where pointer equality matters (this is a clue
2642 for the dynamic linker, to make function pointer
2643 comparisons work between an application and shared
2644 library), otherwise set it to zero. If a function is only
2645 called from a binary, there is no need to slow down
2646 shared libraries because of that. */
2647 sym
->st_shndx
= SHN_UNDEF
;
2648 if (!h
->pointer_equality_needed
)
2653 if (h
->got
.offset
!= (bfd_vma
) -1
2654 && elf64_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_GD
2655 && elf64_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
)
2657 Elf_Internal_Rela rela
;
2660 /* This symbol has an entry in the global offset table. Set it
2662 if (htab
->sgot
== NULL
|| htab
->srelgot
== NULL
)
2665 rela
.r_offset
= (htab
->sgot
->output_section
->vma
2666 + htab
->sgot
->output_offset
2667 + (h
->got
.offset
&~ (bfd_vma
) 1));
2669 /* If this is a static link, or it is a -Bsymbolic link and the
2670 symbol is defined locally or was forced to be local because
2671 of a version file, we just want to emit a RELATIVE reloc.
2672 The entry in the global offset table will already have been
2673 initialized in the relocate_section function. */
2675 && SYMBOL_REFERENCES_LOCAL (info
, h
))
2677 BFD_ASSERT((h
->got
.offset
& 1) != 0);
2678 rela
.r_info
= ELF64_R_INFO (0, R_X86_64_RELATIVE
);
2679 rela
.r_addend
= (h
->root
.u
.def
.value
2680 + h
->root
.u
.def
.section
->output_section
->vma
2681 + h
->root
.u
.def
.section
->output_offset
);
2685 BFD_ASSERT((h
->got
.offset
& 1) == 0);
2686 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
2687 htab
->sgot
->contents
+ h
->got
.offset
);
2688 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_X86_64_GLOB_DAT
);
2692 loc
= htab
->srelgot
->contents
;
2693 loc
+= htab
->srelgot
->reloc_count
++ * sizeof (Elf64_External_Rela
);
2694 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
2699 Elf_Internal_Rela rela
;
2702 /* This symbol needs a copy reloc. Set it up. */
2704 if (h
->dynindx
== -1
2705 || (h
->root
.type
!= bfd_link_hash_defined
2706 && h
->root
.type
!= bfd_link_hash_defweak
)
2707 || htab
->srelbss
== NULL
)
2710 rela
.r_offset
= (h
->root
.u
.def
.value
2711 + h
->root
.u
.def
.section
->output_section
->vma
2712 + h
->root
.u
.def
.section
->output_offset
);
2713 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_X86_64_COPY
);
2715 loc
= htab
->srelbss
->contents
;
2716 loc
+= htab
->srelbss
->reloc_count
++ * sizeof (Elf64_External_Rela
);
2717 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
2720 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2721 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2722 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2723 sym
->st_shndx
= SHN_ABS
;
2728 /* Used to decide how to sort relocs in an optimal manner for the
2729 dynamic linker, before writing them out. */
2731 static enum elf_reloc_type_class
2732 elf64_x86_64_reloc_type_class (const Elf_Internal_Rela
*rela
)
2734 switch ((int) ELF64_R_TYPE (rela
->r_info
))
2736 case R_X86_64_RELATIVE
:
2737 return reloc_class_relative
;
2738 case R_X86_64_JUMP_SLOT
:
2739 return reloc_class_plt
;
2741 return reloc_class_copy
;
2743 return reloc_class_normal
;
2747 /* Finish up the dynamic sections. */
2750 elf64_x86_64_finish_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
2752 struct elf64_x86_64_link_hash_table
*htab
;
2756 htab
= elf64_x86_64_hash_table (info
);
2757 dynobj
= htab
->elf
.dynobj
;
2758 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2760 if (htab
->elf
.dynamic_sections_created
)
2762 Elf64_External_Dyn
*dyncon
, *dynconend
;
2764 if (sdyn
== NULL
|| htab
->sgot
== NULL
)
2767 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
2768 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
2769 for (; dyncon
< dynconend
; dyncon
++)
2771 Elf_Internal_Dyn dyn
;
2774 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2783 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2787 dyn
.d_un
.d_ptr
= htab
->srelplt
->output_section
->vma
;
2791 s
= htab
->srelplt
->output_section
;
2792 dyn
.d_un
.d_val
= s
->size
;
2796 /* The procedure linkage table relocs (DT_JMPREL) should
2797 not be included in the overall relocs (DT_RELA).
2798 Therefore, we override the DT_RELASZ entry here to
2799 make it not include the JMPREL relocs. Since the
2800 linker script arranges for .rela.plt to follow all
2801 other relocation sections, we don't have to worry
2802 about changing the DT_RELA entry. */
2803 if (htab
->srelplt
!= NULL
)
2805 s
= htab
->srelplt
->output_section
;
2806 dyn
.d_un
.d_val
-= s
->size
;
2811 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2814 /* Fill in the special first entry in the procedure linkage table. */
2815 if (htab
->splt
&& htab
->splt
->size
> 0)
2817 /* Fill in the first entry in the procedure linkage table. */
2818 memcpy (htab
->splt
->contents
, elf64_x86_64_plt0_entry
,
2820 /* Add offset for pushq GOT+8(%rip), since the instruction
2821 uses 6 bytes subtract this value. */
2822 bfd_put_32 (output_bfd
,
2823 (htab
->sgotplt
->output_section
->vma
2824 + htab
->sgotplt
->output_offset
2826 - htab
->splt
->output_section
->vma
2827 - htab
->splt
->output_offset
2829 htab
->splt
->contents
+ 2);
2830 /* Add offset for jmp *GOT+16(%rip). The 12 is the offset to
2831 the end of the instruction. */
2832 bfd_put_32 (output_bfd
,
2833 (htab
->sgotplt
->output_section
->vma
2834 + htab
->sgotplt
->output_offset
2836 - htab
->splt
->output_section
->vma
2837 - htab
->splt
->output_offset
2839 htab
->splt
->contents
+ 8);
2841 elf_section_data (htab
->splt
->output_section
)->this_hdr
.sh_entsize
=
2848 /* Fill in the first three entries in the global offset table. */
2849 if (htab
->sgotplt
->size
> 0)
2851 /* Set the first entry in the global offset table to the address of
2852 the dynamic section. */
2854 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
);
2856 bfd_put_64 (output_bfd
,
2857 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2858 htab
->sgotplt
->contents
);
2859 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
2860 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ GOT_ENTRY_SIZE
);
2861 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
2864 elf_section_data (htab
->sgotplt
->output_section
)->this_hdr
.sh_entsize
=
2868 if (htab
->sgot
&& htab
->sgot
->size
> 0)
2869 elf_section_data (htab
->sgot
->output_section
)->this_hdr
.sh_entsize
2875 /* Return address for Ith PLT stub in section PLT, for relocation REL
2876 or (bfd_vma) -1 if it should not be included. */
2879 elf64_x86_64_plt_sym_val (bfd_vma i
, const asection
*plt
,
2880 const arelent
*rel ATTRIBUTE_UNUSED
)
2882 return plt
->vma
+ (i
+ 1) * PLT_ENTRY_SIZE
;
2885 /* Handle an x86-64 specific section when reading an object file. This
2886 is called when elfcode.h finds a section with an unknown type. */
2889 elf64_x86_64_section_from_shdr (bfd
*abfd
,
2890 Elf_Internal_Shdr
*hdr
,
2894 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
2897 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2903 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_vec
2904 #define TARGET_LITTLE_NAME "elf64-x86-64"
2905 #define ELF_ARCH bfd_arch_i386
2906 #define ELF_MACHINE_CODE EM_X86_64
2907 #define ELF_MAXPAGESIZE 0x100000
2909 #define elf_backend_can_gc_sections 1
2910 #define elf_backend_can_refcount 1
2911 #define elf_backend_want_got_plt 1
2912 #define elf_backend_plt_readonly 1
2913 #define elf_backend_want_plt_sym 0
2914 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
2915 #define elf_backend_rela_normal 1
2917 #define elf_info_to_howto elf64_x86_64_info_to_howto
2919 #define bfd_elf64_bfd_link_hash_table_create \
2920 elf64_x86_64_link_hash_table_create
2921 #define bfd_elf64_bfd_reloc_type_lookup elf64_x86_64_reloc_type_lookup
2923 #define elf_backend_adjust_dynamic_symbol elf64_x86_64_adjust_dynamic_symbol
2924 #define elf_backend_check_relocs elf64_x86_64_check_relocs
2925 #define elf_backend_copy_indirect_symbol elf64_x86_64_copy_indirect_symbol
2926 #define elf_backend_create_dynamic_sections elf64_x86_64_create_dynamic_sections
2927 #define elf_backend_finish_dynamic_sections elf64_x86_64_finish_dynamic_sections
2928 #define elf_backend_finish_dynamic_symbol elf64_x86_64_finish_dynamic_symbol
2929 #define elf_backend_gc_mark_hook elf64_x86_64_gc_mark_hook
2930 #define elf_backend_gc_sweep_hook elf64_x86_64_gc_sweep_hook
2931 #define elf_backend_grok_prstatus elf64_x86_64_grok_prstatus
2932 #define elf_backend_grok_psinfo elf64_x86_64_grok_psinfo
2933 #define elf_backend_reloc_type_class elf64_x86_64_reloc_type_class
2934 #define elf_backend_relocate_section elf64_x86_64_relocate_section
2935 #define elf_backend_size_dynamic_sections elf64_x86_64_size_dynamic_sections
2936 #define elf_backend_plt_sym_val elf64_x86_64_plt_sym_val
2937 #define elf_backend_object_p elf64_x86_64_elf_object_p
2938 #define bfd_elf64_mkobject elf64_x86_64_mkobject
2940 #define elf_backend_section_from_shdr \
2941 elf64_x86_64_section_from_shdr
2943 #include "elf64-target.h"