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_signed
,
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_bitfield
,
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_signed
,
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 /* We have a gap in the reloc numbers here.
117 R_X86_64_standard counts the number up to this point, and
118 R_X86_64_vt_offset is the value to subtract from a reloc type of
119 R_X86_64_GNU_VT* to form an index into this table. */
120 #define R_X86_64_standard (R_X86_64_GOTPC32 + 1)
121 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
123 /* GNU extension to record C++ vtable hierarchy. */
124 HOWTO (R_X86_64_GNU_VTINHERIT
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
125 NULL
, "R_X86_64_GNU_VTINHERIT", FALSE
, 0, 0, FALSE
),
127 /* GNU extension to record C++ vtable member usage. */
128 HOWTO (R_X86_64_GNU_VTENTRY
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
129 _bfd_elf_rel_vtable_reloc_fn
, "R_X86_64_GNU_VTENTRY", FALSE
, 0, 0,
133 /* Map BFD relocs to the x86_64 elf relocs. */
136 bfd_reloc_code_real_type bfd_reloc_val
;
137 unsigned char elf_reloc_val
;
140 static const struct elf_reloc_map x86_64_reloc_map
[] =
142 { BFD_RELOC_NONE
, R_X86_64_NONE
, },
143 { BFD_RELOC_64
, R_X86_64_64
, },
144 { BFD_RELOC_32_PCREL
, R_X86_64_PC32
, },
145 { BFD_RELOC_X86_64_GOT32
, R_X86_64_GOT32
,},
146 { BFD_RELOC_X86_64_PLT32
, R_X86_64_PLT32
,},
147 { BFD_RELOC_X86_64_COPY
, R_X86_64_COPY
, },
148 { BFD_RELOC_X86_64_GLOB_DAT
, R_X86_64_GLOB_DAT
, },
149 { BFD_RELOC_X86_64_JUMP_SLOT
, R_X86_64_JUMP_SLOT
, },
150 { BFD_RELOC_X86_64_RELATIVE
, R_X86_64_RELATIVE
, },
151 { BFD_RELOC_X86_64_GOTPCREL
, R_X86_64_GOTPCREL
, },
152 { BFD_RELOC_32
, R_X86_64_32
, },
153 { BFD_RELOC_X86_64_32S
, R_X86_64_32S
, },
154 { BFD_RELOC_16
, R_X86_64_16
, },
155 { BFD_RELOC_16_PCREL
, R_X86_64_PC16
, },
156 { BFD_RELOC_8
, R_X86_64_8
, },
157 { BFD_RELOC_8_PCREL
, R_X86_64_PC8
, },
158 { BFD_RELOC_X86_64_DTPMOD64
, R_X86_64_DTPMOD64
, },
159 { BFD_RELOC_X86_64_DTPOFF64
, R_X86_64_DTPOFF64
, },
160 { BFD_RELOC_X86_64_TPOFF64
, R_X86_64_TPOFF64
, },
161 { BFD_RELOC_X86_64_TLSGD
, R_X86_64_TLSGD
, },
162 { BFD_RELOC_X86_64_TLSLD
, R_X86_64_TLSLD
, },
163 { BFD_RELOC_X86_64_DTPOFF32
, R_X86_64_DTPOFF32
, },
164 { BFD_RELOC_X86_64_GOTTPOFF
, R_X86_64_GOTTPOFF
, },
165 { BFD_RELOC_X86_64_TPOFF32
, R_X86_64_TPOFF32
, },
166 { BFD_RELOC_64_PCREL
, R_X86_64_PC64
, },
167 { BFD_RELOC_X86_64_GOTOFF64
, R_X86_64_GOTOFF64
, },
168 { BFD_RELOC_X86_64_GOTPC32
, R_X86_64_GOTPC32
, },
169 { BFD_RELOC_VTABLE_INHERIT
, R_X86_64_GNU_VTINHERIT
, },
170 { BFD_RELOC_VTABLE_ENTRY
, R_X86_64_GNU_VTENTRY
, },
174 /* Given a BFD reloc type, return a HOWTO structure. */
175 static reloc_howto_type
*
176 elf64_x86_64_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
177 bfd_reloc_code_real_type code
)
181 for (i
= 0; i
< sizeof (x86_64_reloc_map
) / sizeof (struct elf_reloc_map
);
184 if (x86_64_reloc_map
[i
].bfd_reloc_val
== code
)
185 return &x86_64_elf_howto_table
[i
];
190 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
193 elf64_x86_64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
194 Elf_Internal_Rela
*dst
)
198 r_type
= ELF64_R_TYPE (dst
->r_info
);
199 if (r_type
< (unsigned int) R_X86_64_GNU_VTINHERIT
200 || r_type
>= (unsigned int) R_X86_64_max
)
202 if (r_type
>= (unsigned int) R_X86_64_standard
)
204 (*_bfd_error_handler
) (_("%B: invalid relocation type %d"),
206 r_type
= R_X86_64_NONE
;
211 i
= r_type
- (unsigned int) R_X86_64_vt_offset
;
212 cache_ptr
->howto
= &x86_64_elf_howto_table
[i
];
213 BFD_ASSERT (r_type
== cache_ptr
->howto
->type
);
216 /* Support for core dump NOTE sections. */
218 elf64_x86_64_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
223 switch (note
->descsz
)
228 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
230 elf_tdata (abfd
)->core_signal
231 = bfd_get_16 (abfd
, note
->descdata
+ 12);
234 elf_tdata (abfd
)->core_pid
235 = bfd_get_32 (abfd
, note
->descdata
+ 32);
244 /* Make a ".reg/999" section. */
245 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
246 size
, note
->descpos
+ offset
);
250 elf64_x86_64_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
252 switch (note
->descsz
)
257 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
258 elf_tdata (abfd
)->core_program
259 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
260 elf_tdata (abfd
)->core_command
261 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
264 /* Note that for some reason, a spurious space is tacked
265 onto the end of the args in some (at least one anyway)
266 implementations, so strip it off if it exists. */
269 char *command
= elf_tdata (abfd
)->core_command
;
270 int n
= strlen (command
);
272 if (0 < n
&& command
[n
- 1] == ' ')
273 command
[n
- 1] = '\0';
279 /* Functions for the x86-64 ELF linker. */
281 /* The name of the dynamic interpreter. This is put in the .interp
284 #define ELF_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
286 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
287 copying dynamic variables from a shared lib into an app's dynbss
288 section, and instead use a dynamic relocation to point into the
290 #define ELIMINATE_COPY_RELOCS 1
292 /* The size in bytes of an entry in the global offset table. */
294 #define GOT_ENTRY_SIZE 8
296 /* The size in bytes of an entry in the procedure linkage table. */
298 #define PLT_ENTRY_SIZE 16
300 /* The first entry in a procedure linkage table looks like this. See the
301 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
303 static const bfd_byte elf64_x86_64_plt0_entry
[PLT_ENTRY_SIZE
] =
305 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
306 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
307 0x90, 0x90, 0x90, 0x90 /* pad out to 16 bytes with nops. */
310 /* Subsequent entries in a procedure linkage table look like this. */
312 static const bfd_byte elf64_x86_64_plt_entry
[PLT_ENTRY_SIZE
] =
314 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
315 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
316 0x68, /* pushq immediate */
317 0, 0, 0, 0, /* replaced with index into relocation table. */
318 0xe9, /* jmp relative */
319 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
322 /* The x86-64 linker needs to keep track of the number of relocs that
323 it decides to copy as dynamic relocs in check_relocs for each symbol.
324 This is so that it can later discard them if they are found to be
325 unnecessary. We store the information in a field extending the
326 regular ELF linker hash table. */
328 struct elf64_x86_64_dyn_relocs
331 struct elf64_x86_64_dyn_relocs
*next
;
333 /* The input section of the reloc. */
336 /* Total number of relocs copied for the input section. */
339 /* Number of pc-relative relocs copied for the input section. */
340 bfd_size_type pc_count
;
343 /* x86-64 ELF linker hash entry. */
345 struct elf64_x86_64_link_hash_entry
347 struct elf_link_hash_entry elf
;
349 /* Track dynamic relocs copied for this symbol. */
350 struct elf64_x86_64_dyn_relocs
*dyn_relocs
;
352 #define GOT_UNKNOWN 0
356 unsigned char tls_type
;
359 #define elf64_x86_64_hash_entry(ent) \
360 ((struct elf64_x86_64_link_hash_entry *)(ent))
362 struct elf64_x86_64_obj_tdata
364 struct elf_obj_tdata root
;
366 /* tls_type for each local got entry. */
367 char *local_got_tls_type
;
370 #define elf64_x86_64_tdata(abfd) \
371 ((struct elf64_x86_64_obj_tdata *) (abfd)->tdata.any)
373 #define elf64_x86_64_local_got_tls_type(abfd) \
374 (elf64_x86_64_tdata (abfd)->local_got_tls_type)
377 /* x86-64 ELF linker hash table. */
379 struct elf64_x86_64_link_hash_table
381 struct elf_link_hash_table elf
;
383 /* Short-cuts to get to dynamic linker sections. */
393 bfd_signed_vma refcount
;
397 /* Small local sym to section mapping cache. */
398 struct sym_sec_cache sym_sec
;
401 /* Get the x86-64 ELF linker hash table from a link_info structure. */
403 #define elf64_x86_64_hash_table(p) \
404 ((struct elf64_x86_64_link_hash_table *) ((p)->hash))
406 /* Create an entry in an x86-64 ELF linker hash table. */
408 static struct bfd_hash_entry
*
409 link_hash_newfunc (struct bfd_hash_entry
*entry
, struct bfd_hash_table
*table
,
412 /* Allocate the structure if it has not already been allocated by a
416 entry
= bfd_hash_allocate (table
,
417 sizeof (struct elf64_x86_64_link_hash_entry
));
422 /* Call the allocation method of the superclass. */
423 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
426 struct elf64_x86_64_link_hash_entry
*eh
;
428 eh
= (struct elf64_x86_64_link_hash_entry
*) entry
;
429 eh
->dyn_relocs
= NULL
;
430 eh
->tls_type
= GOT_UNKNOWN
;
436 /* Create an X86-64 ELF linker hash table. */
438 static struct bfd_link_hash_table
*
439 elf64_x86_64_link_hash_table_create (bfd
*abfd
)
441 struct elf64_x86_64_link_hash_table
*ret
;
442 bfd_size_type amt
= sizeof (struct elf64_x86_64_link_hash_table
);
444 ret
= (struct elf64_x86_64_link_hash_table
*) bfd_malloc (amt
);
448 if (! _bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
))
461 ret
->sym_sec
.abfd
= NULL
;
462 ret
->tls_ld_got
.refcount
= 0;
464 return &ret
->elf
.root
;
467 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
468 shortcuts to them in our hash table. */
471 create_got_section (bfd
*dynobj
, struct bfd_link_info
*info
)
473 struct elf64_x86_64_link_hash_table
*htab
;
475 if (! _bfd_elf_create_got_section (dynobj
, info
))
478 htab
= elf64_x86_64_hash_table (info
);
479 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
480 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
481 if (!htab
->sgot
|| !htab
->sgotplt
)
484 htab
->srelgot
= bfd_make_section_with_flags (dynobj
, ".rela.got",
485 (SEC_ALLOC
| SEC_LOAD
490 if (htab
->srelgot
== NULL
491 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 3))
496 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
497 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
501 elf64_x86_64_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
503 struct elf64_x86_64_link_hash_table
*htab
;
505 htab
= elf64_x86_64_hash_table (info
);
506 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
509 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
512 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
513 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rela.plt");
514 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
516 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rela.bss");
518 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
519 || (!info
->shared
&& !htab
->srelbss
))
525 /* Copy the extra info we tack onto an elf_link_hash_entry. */
528 elf64_x86_64_copy_indirect_symbol (const struct elf_backend_data
*bed
,
529 struct elf_link_hash_entry
*dir
,
530 struct elf_link_hash_entry
*ind
)
532 struct elf64_x86_64_link_hash_entry
*edir
, *eind
;
534 edir
= (struct elf64_x86_64_link_hash_entry
*) dir
;
535 eind
= (struct elf64_x86_64_link_hash_entry
*) ind
;
537 if (eind
->dyn_relocs
!= NULL
)
539 if (edir
->dyn_relocs
!= NULL
)
541 struct elf64_x86_64_dyn_relocs
**pp
;
542 struct elf64_x86_64_dyn_relocs
*p
;
544 if (ind
->root
.type
== bfd_link_hash_indirect
)
547 /* Add reloc counts against the weak sym to the strong sym
548 list. Merge any entries against the same section. */
549 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
551 struct elf64_x86_64_dyn_relocs
*q
;
553 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
554 if (q
->sec
== p
->sec
)
556 q
->pc_count
+= p
->pc_count
;
557 q
->count
+= p
->count
;
564 *pp
= edir
->dyn_relocs
;
567 edir
->dyn_relocs
= eind
->dyn_relocs
;
568 eind
->dyn_relocs
= NULL
;
571 if (ind
->root
.type
== bfd_link_hash_indirect
572 && dir
->got
.refcount
<= 0)
574 edir
->tls_type
= eind
->tls_type
;
575 eind
->tls_type
= GOT_UNKNOWN
;
578 if (ELIMINATE_COPY_RELOCS
579 && ind
->root
.type
!= bfd_link_hash_indirect
580 && dir
->dynamic_adjusted
)
582 /* If called to transfer flags for a weakdef during processing
583 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
584 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
585 dir
->ref_dynamic
|= ind
->ref_dynamic
;
586 dir
->ref_regular
|= ind
->ref_regular
;
587 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
588 dir
->needs_plt
|= ind
->needs_plt
;
589 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
592 _bfd_elf_link_hash_copy_indirect (bed
, dir
, ind
);
596 elf64_x86_64_mkobject (bfd
*abfd
)
598 bfd_size_type amt
= sizeof (struct elf64_x86_64_obj_tdata
);
599 abfd
->tdata
.any
= bfd_zalloc (abfd
, amt
);
600 if (abfd
->tdata
.any
== NULL
)
606 elf64_x86_64_elf_object_p (bfd
*abfd
)
608 /* Set the right machine number for an x86-64 elf64 file. */
609 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
614 elf64_x86_64_tls_transition (struct bfd_link_info
*info
, int r_type
, int is_local
)
622 case R_X86_64_GOTTPOFF
:
624 return R_X86_64_TPOFF32
;
625 return R_X86_64_GOTTPOFF
;
627 return R_X86_64_TPOFF32
;
633 /* Look through the relocs for a section during the first phase, and
634 calculate needed space in the global offset table, procedure
635 linkage table, and dynamic reloc sections. */
638 elf64_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
639 const Elf_Internal_Rela
*relocs
)
641 struct elf64_x86_64_link_hash_table
*htab
;
642 Elf_Internal_Shdr
*symtab_hdr
;
643 struct elf_link_hash_entry
**sym_hashes
;
644 const Elf_Internal_Rela
*rel
;
645 const Elf_Internal_Rela
*rel_end
;
648 if (info
->relocatable
)
651 htab
= elf64_x86_64_hash_table (info
);
652 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
653 sym_hashes
= elf_sym_hashes (abfd
);
657 rel_end
= relocs
+ sec
->reloc_count
;
658 for (rel
= relocs
; rel
< rel_end
; rel
++)
661 unsigned long r_symndx
;
662 struct elf_link_hash_entry
*h
;
664 r_symndx
= ELF64_R_SYM (rel
->r_info
);
665 r_type
= ELF64_R_TYPE (rel
->r_info
);
667 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
669 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
674 if (r_symndx
< symtab_hdr
->sh_info
)
678 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
679 while (h
->root
.type
== bfd_link_hash_indirect
680 || h
->root
.type
== bfd_link_hash_warning
)
681 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
684 r_type
= elf64_x86_64_tls_transition (info
, r_type
, h
== NULL
);
688 htab
->tls_ld_got
.refcount
+= 1;
691 case R_X86_64_TPOFF32
:
694 (*_bfd_error_handler
)
695 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
697 x86_64_elf_howto_table
[r_type
].name
,
698 (h
) ? h
->root
.root
.string
: "a local symbol");
699 bfd_set_error (bfd_error_bad_value
);
704 case R_X86_64_GOTTPOFF
:
706 info
->flags
|= DF_STATIC_TLS
;
710 case R_X86_64_GOTPCREL
:
712 /* This symbol requires a global offset table entry. */
714 int tls_type
, old_tls_type
;
718 default: tls_type
= GOT_NORMAL
; break;
719 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
720 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
725 h
->got
.refcount
+= 1;
726 old_tls_type
= elf64_x86_64_hash_entry (h
)->tls_type
;
730 bfd_signed_vma
*local_got_refcounts
;
732 /* This is a global offset table entry for a local symbol. */
733 local_got_refcounts
= elf_local_got_refcounts (abfd
);
734 if (local_got_refcounts
== NULL
)
738 size
= symtab_hdr
->sh_info
;
739 size
*= sizeof (bfd_signed_vma
) + sizeof (char);
740 local_got_refcounts
= ((bfd_signed_vma
*)
741 bfd_zalloc (abfd
, size
));
742 if (local_got_refcounts
== NULL
)
744 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
745 elf64_x86_64_local_got_tls_type (abfd
)
746 = (char *) (local_got_refcounts
+ symtab_hdr
->sh_info
);
748 local_got_refcounts
[r_symndx
] += 1;
750 = elf64_x86_64_local_got_tls_type (abfd
) [r_symndx
];
753 /* If a TLS symbol is accessed using IE at least once,
754 there is no point to use dynamic model for it. */
755 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
756 && (old_tls_type
!= GOT_TLS_GD
|| tls_type
!= GOT_TLS_IE
))
758 if (old_tls_type
== GOT_TLS_IE
&& tls_type
== GOT_TLS_GD
)
759 tls_type
= old_tls_type
;
762 (*_bfd_error_handler
)
763 (_("%B: %s' accessed both as normal and thread local symbol"),
764 abfd
, h
? h
->root
.root
.string
: "<local>");
769 if (old_tls_type
!= tls_type
)
772 elf64_x86_64_hash_entry (h
)->tls_type
= tls_type
;
774 elf64_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
779 case R_X86_64_GOTOFF64
:
780 case R_X86_64_GOTPC32
:
782 if (htab
->sgot
== NULL
)
784 if (htab
->elf
.dynobj
== NULL
)
785 htab
->elf
.dynobj
= abfd
;
786 if (!create_got_section (htab
->elf
.dynobj
, info
))
792 /* This symbol requires a procedure linkage table entry. We
793 actually build the entry in adjust_dynamic_symbol,
794 because this might be a case of linking PIC code which is
795 never referenced by a dynamic object, in which case we
796 don't need to generate a procedure linkage table entry
799 /* If this is a local symbol, we resolve it directly without
800 creating a procedure linkage table entry. */
805 h
->plt
.refcount
+= 1;
812 /* Let's help debug shared library creation. These relocs
813 cannot be used in shared libs. Don't error out for
814 sections we don't care about, such as debug sections or
815 non-constant sections. */
817 && (sec
->flags
& SEC_ALLOC
) != 0
818 && (sec
->flags
& SEC_READONLY
) != 0)
820 (*_bfd_error_handler
)
821 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
823 x86_64_elf_howto_table
[r_type
].name
,
824 (h
) ? h
->root
.root
.string
: "a local symbol");
825 bfd_set_error (bfd_error_bad_value
);
835 if (h
!= NULL
&& !info
->shared
)
837 /* If this reloc is in a read-only section, we might
838 need a copy reloc. We can't check reliably at this
839 stage whether the section is read-only, as input
840 sections have not yet been mapped to output sections.
841 Tentatively set the flag for now, and correct in
842 adjust_dynamic_symbol. */
845 /* We may need a .plt entry if the function this reloc
846 refers to is in a shared lib. */
847 h
->plt
.refcount
+= 1;
848 if (r_type
!= R_X86_64_PC32
&& r_type
!= R_X86_64_PC64
)
849 h
->pointer_equality_needed
= 1;
852 /* If we are creating a shared library, and this is a reloc
853 against a global symbol, or a non PC relative reloc
854 against a local symbol, then we need to copy the reloc
855 into the shared library. However, if we are linking with
856 -Bsymbolic, we do not need to copy a reloc against a
857 global symbol which is defined in an object we are
858 including in the link (i.e., DEF_REGULAR is set). At
859 this point we have not seen all the input files, so it is
860 possible that DEF_REGULAR is not set now but will be set
861 later (it is never cleared). In case of a weak definition,
862 DEF_REGULAR may be cleared later by a strong definition in
863 a shared library. We account for that possibility below by
864 storing information in the relocs_copied field of the hash
865 table entry. A similar situation occurs when creating
866 shared libraries and symbol visibility changes render the
869 If on the other hand, we are creating an executable, we
870 may need to keep relocations for symbols satisfied by a
871 dynamic library if we manage to avoid copy relocs for the
874 && (sec
->flags
& SEC_ALLOC
) != 0
875 && (((r_type
!= R_X86_64_PC8
)
876 && (r_type
!= R_X86_64_PC16
)
877 && (r_type
!= R_X86_64_PC32
)
878 && (r_type
!= R_X86_64_PC64
))
881 || h
->root
.type
== bfd_link_hash_defweak
882 || !h
->def_regular
))))
883 || (ELIMINATE_COPY_RELOCS
885 && (sec
->flags
& SEC_ALLOC
) != 0
887 && (h
->root
.type
== bfd_link_hash_defweak
888 || !h
->def_regular
)))
890 struct elf64_x86_64_dyn_relocs
*p
;
891 struct elf64_x86_64_dyn_relocs
**head
;
893 /* We must copy these reloc types into the output file.
894 Create a reloc section in dynobj and make room for
901 name
= (bfd_elf_string_from_elf_section
903 elf_elfheader (abfd
)->e_shstrndx
,
904 elf_section_data (sec
)->rel_hdr
.sh_name
));
908 if (strncmp (name
, ".rela", 5) != 0
909 || strcmp (bfd_get_section_name (abfd
, sec
),
912 (*_bfd_error_handler
)
913 (_("%B: bad relocation section name `%s\'"),
917 if (htab
->elf
.dynobj
== NULL
)
918 htab
->elf
.dynobj
= abfd
;
920 dynobj
= htab
->elf
.dynobj
;
922 sreloc
= bfd_get_section_by_name (dynobj
, name
);
927 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
928 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
929 if ((sec
->flags
& SEC_ALLOC
) != 0)
930 flags
|= SEC_ALLOC
| SEC_LOAD
;
931 sreloc
= bfd_make_section_with_flags (dynobj
,
935 || ! bfd_set_section_alignment (dynobj
, sreloc
, 3))
938 elf_section_data (sec
)->sreloc
= sreloc
;
941 /* If this is a global symbol, we count the number of
942 relocations we need for this symbol. */
945 head
= &((struct elf64_x86_64_link_hash_entry
*) h
)->dyn_relocs
;
949 /* Track dynamic relocs needed for local syms too.
950 We really need local syms available to do this
954 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
959 head
= ((struct elf64_x86_64_dyn_relocs
**)
960 &elf_section_data (s
)->local_dynrel
);
964 if (p
== NULL
|| p
->sec
!= sec
)
966 bfd_size_type amt
= sizeof *p
;
967 p
= ((struct elf64_x86_64_dyn_relocs
*)
968 bfd_alloc (htab
->elf
.dynobj
, amt
));
979 if (r_type
== R_X86_64_PC8
980 || r_type
== R_X86_64_PC16
981 || r_type
== R_X86_64_PC32
982 || r_type
== R_X86_64_PC64
)
987 /* This relocation describes the C++ object vtable hierarchy.
988 Reconstruct it for later use during GC. */
989 case R_X86_64_GNU_VTINHERIT
:
990 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
994 /* This relocation describes which C++ vtable entries are actually
995 used. Record for later use during GC. */
996 case R_X86_64_GNU_VTENTRY
:
997 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1009 /* Return the section that should be marked against GC for a given
1013 elf64_x86_64_gc_mark_hook (asection
*sec
,
1014 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1015 Elf_Internal_Rela
*rel
,
1016 struct elf_link_hash_entry
*h
,
1017 Elf_Internal_Sym
*sym
)
1021 switch (ELF64_R_TYPE (rel
->r_info
))
1023 case R_X86_64_GNU_VTINHERIT
:
1024 case R_X86_64_GNU_VTENTRY
:
1028 switch (h
->root
.type
)
1030 case bfd_link_hash_defined
:
1031 case bfd_link_hash_defweak
:
1032 return h
->root
.u
.def
.section
;
1034 case bfd_link_hash_common
:
1035 return h
->root
.u
.c
.p
->section
;
1043 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
1048 /* Update the got entry reference counts for the section being removed. */
1051 elf64_x86_64_gc_sweep_hook (bfd
*abfd
, struct bfd_link_info
*info
,
1052 asection
*sec
, const Elf_Internal_Rela
*relocs
)
1054 Elf_Internal_Shdr
*symtab_hdr
;
1055 struct elf_link_hash_entry
**sym_hashes
;
1056 bfd_signed_vma
*local_got_refcounts
;
1057 const Elf_Internal_Rela
*rel
, *relend
;
1059 elf_section_data (sec
)->local_dynrel
= NULL
;
1061 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1062 sym_hashes
= elf_sym_hashes (abfd
);
1063 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1065 relend
= relocs
+ sec
->reloc_count
;
1066 for (rel
= relocs
; rel
< relend
; rel
++)
1068 unsigned long r_symndx
;
1069 unsigned int r_type
;
1070 struct elf_link_hash_entry
*h
= NULL
;
1072 r_symndx
= ELF64_R_SYM (rel
->r_info
);
1073 if (r_symndx
>= symtab_hdr
->sh_info
)
1075 struct elf64_x86_64_link_hash_entry
*eh
;
1076 struct elf64_x86_64_dyn_relocs
**pp
;
1077 struct elf64_x86_64_dyn_relocs
*p
;
1079 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1080 while (h
->root
.type
== bfd_link_hash_indirect
1081 || h
->root
.type
== bfd_link_hash_warning
)
1082 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1083 eh
= (struct elf64_x86_64_link_hash_entry
*) h
;
1085 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1088 /* Everything must go for SEC. */
1094 r_type
= ELF64_R_TYPE (rel
->r_info
);
1095 r_type
= elf64_x86_64_tls_transition (info
, r_type
, h
!= NULL
);
1098 case R_X86_64_TLSLD
:
1099 if (elf64_x86_64_hash_table (info
)->tls_ld_got
.refcount
> 0)
1100 elf64_x86_64_hash_table (info
)->tls_ld_got
.refcount
-= 1;
1103 case R_X86_64_TLSGD
:
1104 case R_X86_64_GOTTPOFF
:
1105 case R_X86_64_GOT32
:
1106 case R_X86_64_GOTPCREL
:
1109 if (h
->got
.refcount
> 0)
1110 h
->got
.refcount
-= 1;
1112 else if (local_got_refcounts
!= NULL
)
1114 if (local_got_refcounts
[r_symndx
] > 0)
1115 local_got_refcounts
[r_symndx
] -= 1;
1132 case R_X86_64_PLT32
:
1135 if (h
->plt
.refcount
> 0)
1136 h
->plt
.refcount
-= 1;
1148 /* Adjust a symbol defined by a dynamic object and referenced by a
1149 regular object. The current definition is in some section of the
1150 dynamic object, but we're not including those sections. We have to
1151 change the definition to something the rest of the link can
1155 elf64_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1156 struct elf_link_hash_entry
*h
)
1158 struct elf64_x86_64_link_hash_table
*htab
;
1160 unsigned int power_of_two
;
1162 /* If this is a function, put it in the procedure linkage table. We
1163 will fill in the contents of the procedure linkage table later,
1164 when we know the address of the .got section. */
1165 if (h
->type
== STT_FUNC
1168 if (h
->plt
.refcount
<= 0
1169 || SYMBOL_CALLS_LOCAL (info
, h
)
1170 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1171 && h
->root
.type
== bfd_link_hash_undefweak
))
1173 /* This case can occur if we saw a PLT32 reloc in an input
1174 file, but the symbol was never referred to by a dynamic
1175 object, or if all references were garbage collected. In
1176 such a case, we don't actually need to build a procedure
1177 linkage table, and we can just do a PC32 reloc instead. */
1178 h
->plt
.offset
= (bfd_vma
) -1;
1185 /* It's possible that we incorrectly decided a .plt reloc was
1186 needed for an R_X86_64_PC32 reloc to a non-function sym in
1187 check_relocs. We can't decide accurately between function and
1188 non-function syms in check-relocs; Objects loaded later in
1189 the link may change h->type. So fix it now. */
1190 h
->plt
.offset
= (bfd_vma
) -1;
1192 /* If this is a weak symbol, and there is a real definition, the
1193 processor independent code will have arranged for us to see the
1194 real definition first, and we can just use the same value. */
1195 if (h
->u
.weakdef
!= NULL
)
1197 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
1198 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
1199 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
1200 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
1201 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
1202 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
1206 /* This is a reference to a symbol defined by a dynamic object which
1207 is not a function. */
1209 /* If we are creating a shared library, we must presume that the
1210 only references to the symbol are via the global offset table.
1211 For such cases we need not do anything here; the relocations will
1212 be handled correctly by relocate_section. */
1216 /* If there are no references to this symbol that do not use the
1217 GOT, we don't need to generate a copy reloc. */
1218 if (!h
->non_got_ref
)
1221 /* If -z nocopyreloc was given, we won't generate them either. */
1222 if (info
->nocopyreloc
)
1228 if (ELIMINATE_COPY_RELOCS
)
1230 struct elf64_x86_64_link_hash_entry
* eh
;
1231 struct elf64_x86_64_dyn_relocs
*p
;
1233 eh
= (struct elf64_x86_64_link_hash_entry
*) h
;
1234 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1236 s
= p
->sec
->output_section
;
1237 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1241 /* If we didn't find any dynamic relocs in read-only sections, then
1242 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1250 /* We must allocate the symbol in our .dynbss section, which will
1251 become part of the .bss section of the executable. There will be
1252 an entry for this symbol in the .dynsym section. The dynamic
1253 object will contain position independent code, so all references
1254 from the dynamic object to this symbol will go through the global
1255 offset table. The dynamic linker will use the .dynsym entry to
1256 determine the address it must put in the global offset table, so
1257 both the dynamic object and the regular object will refer to the
1258 same memory location for the variable. */
1260 htab
= elf64_x86_64_hash_table (info
);
1262 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
1263 to copy the initial value out of the dynamic object and into the
1264 runtime process image. */
1265 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1267 htab
->srelbss
->size
+= sizeof (Elf64_External_Rela
);
1271 /* We need to figure out the alignment required for this symbol. I
1272 have no idea how ELF linkers handle this. 16-bytes is the size
1273 of the largest type that requires hard alignment -- long double. */
1274 /* FIXME: This is VERY ugly. Should be fixed for all architectures using
1276 power_of_two
= bfd_log2 (h
->size
);
1277 if (power_of_two
> 4)
1280 /* Apply the required alignment. */
1282 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
) (1 << power_of_two
));
1283 if (power_of_two
> bfd_get_section_alignment (htab
->elf
.dynobj
, s
))
1285 if (! bfd_set_section_alignment (htab
->elf
.dynobj
, s
, power_of_two
))
1289 /* Define the symbol as being at this point in the section. */
1290 h
->root
.u
.def
.section
= s
;
1291 h
->root
.u
.def
.value
= s
->size
;
1293 /* Increment the section size to make room for the symbol. */
1299 /* Allocate space in .plt, .got and associated reloc sections for
1303 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
1305 struct bfd_link_info
*info
;
1306 struct elf64_x86_64_link_hash_table
*htab
;
1307 struct elf64_x86_64_link_hash_entry
*eh
;
1308 struct elf64_x86_64_dyn_relocs
*p
;
1310 if (h
->root
.type
== bfd_link_hash_indirect
)
1313 if (h
->root
.type
== bfd_link_hash_warning
)
1314 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1316 info
= (struct bfd_link_info
*) inf
;
1317 htab
= elf64_x86_64_hash_table (info
);
1319 if (htab
->elf
.dynamic_sections_created
1320 && h
->plt
.refcount
> 0)
1322 /* Make sure this symbol is output as a dynamic symbol.
1323 Undefined weak syms won't yet be marked as dynamic. */
1324 if (h
->dynindx
== -1
1325 && !h
->forced_local
)
1327 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1332 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
1334 asection
*s
= htab
->splt
;
1336 /* If this is the first .plt entry, make room for the special
1339 s
->size
+= PLT_ENTRY_SIZE
;
1341 h
->plt
.offset
= s
->size
;
1343 /* If this symbol is not defined in a regular file, and we are
1344 not generating a shared library, then set the symbol to this
1345 location in the .plt. This is required to make function
1346 pointers compare as equal between the normal executable and
1347 the shared library. */
1351 h
->root
.u
.def
.section
= s
;
1352 h
->root
.u
.def
.value
= h
->plt
.offset
;
1355 /* Make room for this entry. */
1356 s
->size
+= PLT_ENTRY_SIZE
;
1358 /* We also need to make an entry in the .got.plt section, which
1359 will be placed in the .got section by the linker script. */
1360 htab
->sgotplt
->size
+= GOT_ENTRY_SIZE
;
1362 /* We also need to make an entry in the .rela.plt section. */
1363 htab
->srelplt
->size
+= sizeof (Elf64_External_Rela
);
1367 h
->plt
.offset
= (bfd_vma
) -1;
1373 h
->plt
.offset
= (bfd_vma
) -1;
1377 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
1378 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
1379 if (h
->got
.refcount
> 0
1382 && elf64_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
1383 h
->got
.offset
= (bfd_vma
) -1;
1384 else if (h
->got
.refcount
> 0)
1388 int tls_type
= elf64_x86_64_hash_entry (h
)->tls_type
;
1390 /* Make sure this symbol is output as a dynamic symbol.
1391 Undefined weak syms won't yet be marked as dynamic. */
1392 if (h
->dynindx
== -1
1393 && !h
->forced_local
)
1395 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1400 h
->got
.offset
= s
->size
;
1401 s
->size
+= GOT_ENTRY_SIZE
;
1402 /* R_X86_64_TLSGD needs 2 consecutive GOT slots. */
1403 if (tls_type
== GOT_TLS_GD
)
1404 s
->size
+= GOT_ENTRY_SIZE
;
1405 dyn
= htab
->elf
.dynamic_sections_created
;
1406 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
1408 R_X86_64_GOTTPOFF needs one dynamic relocation. */
1409 if ((tls_type
== GOT_TLS_GD
&& h
->dynindx
== -1)
1410 || tls_type
== GOT_TLS_IE
)
1411 htab
->srelgot
->size
+= sizeof (Elf64_External_Rela
);
1412 else if (tls_type
== GOT_TLS_GD
)
1413 htab
->srelgot
->size
+= 2 * sizeof (Elf64_External_Rela
);
1414 else if ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
1415 || h
->root
.type
!= bfd_link_hash_undefweak
)
1417 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
1418 htab
->srelgot
->size
+= sizeof (Elf64_External_Rela
);
1421 h
->got
.offset
= (bfd_vma
) -1;
1423 eh
= (struct elf64_x86_64_link_hash_entry
*) h
;
1424 if (eh
->dyn_relocs
== NULL
)
1427 /* In the shared -Bsymbolic case, discard space allocated for
1428 dynamic pc-relative relocs against symbols which turn out to be
1429 defined in regular objects. For the normal shared case, discard
1430 space for pc-relative relocs that have become local due to symbol
1431 visibility changes. */
1435 /* Relocs that use pc_count are those that appear on a call
1436 insn, or certain REL relocs that can generated via assembly.
1437 We want calls to protected symbols to resolve directly to the
1438 function rather than going via the plt. If people want
1439 function pointer comparisons to work as expected then they
1440 should avoid writing weird assembly. */
1441 if (SYMBOL_CALLS_LOCAL (info
, h
))
1443 struct elf64_x86_64_dyn_relocs
**pp
;
1445 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1447 p
->count
-= p
->pc_count
;
1456 /* Also discard relocs on undefined weak syms with non-default
1458 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1459 && h
->root
.type
== bfd_link_hash_undefweak
)
1460 eh
->dyn_relocs
= NULL
;
1462 else if (ELIMINATE_COPY_RELOCS
)
1464 /* For the non-shared case, discard space for relocs against
1465 symbols which turn out to need copy relocs or are not
1471 || (htab
->elf
.dynamic_sections_created
1472 && (h
->root
.type
== bfd_link_hash_undefweak
1473 || h
->root
.type
== bfd_link_hash_undefined
))))
1475 /* Make sure this symbol is output as a dynamic symbol.
1476 Undefined weak syms won't yet be marked as dynamic. */
1477 if (h
->dynindx
== -1
1478 && !h
->forced_local
)
1480 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1484 /* If that succeeded, we know we'll be keeping all the
1486 if (h
->dynindx
!= -1)
1490 eh
->dyn_relocs
= NULL
;
1495 /* Finally, allocate space. */
1496 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1498 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1499 sreloc
->size
+= p
->count
* sizeof (Elf64_External_Rela
);
1505 /* Find any dynamic relocs that apply to read-only sections. */
1508 readonly_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
1510 struct elf64_x86_64_link_hash_entry
*eh
;
1511 struct elf64_x86_64_dyn_relocs
*p
;
1513 if (h
->root
.type
== bfd_link_hash_warning
)
1514 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1516 eh
= (struct elf64_x86_64_link_hash_entry
*) h
;
1517 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1519 asection
*s
= p
->sec
->output_section
;
1521 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1523 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
1525 info
->flags
|= DF_TEXTREL
;
1527 /* Not an error, just cut short the traversal. */
1534 /* Set the sizes of the dynamic sections. */
1537 elf64_x86_64_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1538 struct bfd_link_info
*info
)
1540 struct elf64_x86_64_link_hash_table
*htab
;
1546 htab
= elf64_x86_64_hash_table (info
);
1547 dynobj
= htab
->elf
.dynobj
;
1551 if (htab
->elf
.dynamic_sections_created
)
1553 /* Set the contents of the .interp section to the interpreter. */
1554 if (info
->executable
)
1556 s
= bfd_get_section_by_name (dynobj
, ".interp");
1559 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1560 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1564 /* Set up .got offsets for local syms, and space for local dynamic
1566 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
1568 bfd_signed_vma
*local_got
;
1569 bfd_signed_vma
*end_local_got
;
1570 char *local_tls_type
;
1571 bfd_size_type locsymcount
;
1572 Elf_Internal_Shdr
*symtab_hdr
;
1575 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
1578 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1580 struct elf64_x86_64_dyn_relocs
*p
;
1582 for (p
= *((struct elf64_x86_64_dyn_relocs
**)
1583 &elf_section_data (s
)->local_dynrel
);
1587 if (!bfd_is_abs_section (p
->sec
)
1588 && bfd_is_abs_section (p
->sec
->output_section
))
1590 /* Input section has been discarded, either because
1591 it is a copy of a linkonce section or due to
1592 linker script /DISCARD/, so we'll be discarding
1595 else if (p
->count
!= 0)
1597 srel
= elf_section_data (p
->sec
)->sreloc
;
1598 srel
->size
+= p
->count
* sizeof (Elf64_External_Rela
);
1599 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1600 info
->flags
|= DF_TEXTREL
;
1606 local_got
= elf_local_got_refcounts (ibfd
);
1610 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1611 locsymcount
= symtab_hdr
->sh_info
;
1612 end_local_got
= local_got
+ locsymcount
;
1613 local_tls_type
= elf64_x86_64_local_got_tls_type (ibfd
);
1615 srel
= htab
->srelgot
;
1616 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
1620 *local_got
= s
->size
;
1621 s
->size
+= GOT_ENTRY_SIZE
;
1622 if (*local_tls_type
== GOT_TLS_GD
)
1623 s
->size
+= GOT_ENTRY_SIZE
;
1625 || *local_tls_type
== GOT_TLS_GD
1626 || *local_tls_type
== GOT_TLS_IE
)
1627 srel
->size
+= sizeof (Elf64_External_Rela
);
1630 *local_got
= (bfd_vma
) -1;
1634 if (htab
->tls_ld_got
.refcount
> 0)
1636 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
1638 htab
->tls_ld_got
.offset
= htab
->sgot
->size
;
1639 htab
->sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
1640 htab
->srelgot
->size
+= sizeof (Elf64_External_Rela
);
1643 htab
->tls_ld_got
.offset
= -1;
1645 /* Allocate global sym .plt and .got entries, and space for global
1646 sym dynamic relocs. */
1647 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, (PTR
) info
);
1649 /* We now have determined the sizes of the various dynamic sections.
1650 Allocate memory for them. */
1652 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1654 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1659 || s
== htab
->sgotplt
1660 || s
== htab
->sdynbss
)
1662 /* Strip this section if we don't need it; see the
1665 else if (strncmp (bfd_get_section_name (dynobj
, s
), ".rela", 5) == 0)
1667 if (s
->size
!= 0 && s
!= htab
->srelplt
)
1670 /* We use the reloc_count field as a counter if we need
1671 to copy relocs into the output file. */
1676 /* It's not one of our sections, so don't allocate space. */
1682 /* If we don't need this section, strip it from the
1683 output file. This is mostly to handle .rela.bss and
1684 .rela.plt. We must create both sections in
1685 create_dynamic_sections, because they must be created
1686 before the linker maps input sections to output
1687 sections. The linker does that before
1688 adjust_dynamic_symbol is called, and it is that
1689 function which decides whether anything needs to go
1690 into these sections. */
1692 s
->flags
|= SEC_EXCLUDE
;
1696 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
1699 /* Allocate memory for the section contents. We use bfd_zalloc
1700 here in case unused entries are not reclaimed before the
1701 section's contents are written out. This should not happen,
1702 but this way if it does, we get a R_X86_64_NONE reloc instead
1704 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1705 if (s
->contents
== NULL
)
1709 if (htab
->elf
.dynamic_sections_created
)
1711 /* Add some entries to the .dynamic section. We fill in the
1712 values later, in elf64_x86_64_finish_dynamic_sections, but we
1713 must add the entries now so that we get the correct size for
1714 the .dynamic section. The DT_DEBUG entry is filled in by the
1715 dynamic linker and used by the debugger. */
1716 #define add_dynamic_entry(TAG, VAL) \
1717 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1719 if (info
->executable
)
1721 if (!add_dynamic_entry (DT_DEBUG
, 0))
1725 if (htab
->splt
->size
!= 0)
1727 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1728 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1729 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1730 || !add_dynamic_entry (DT_JMPREL
, 0))
1736 if (!add_dynamic_entry (DT_RELA
, 0)
1737 || !add_dynamic_entry (DT_RELASZ
, 0)
1738 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf64_External_Rela
)))
1741 /* If any dynamic relocs apply to a read-only section,
1742 then we need a DT_TEXTREL entry. */
1743 if ((info
->flags
& DF_TEXTREL
) == 0)
1744 elf_link_hash_traverse (&htab
->elf
, readonly_dynrelocs
,
1747 if ((info
->flags
& DF_TEXTREL
) != 0)
1749 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1754 #undef add_dynamic_entry
1759 /* Return the base VMA address which should be subtracted from real addresses
1760 when resolving @dtpoff relocation.
1761 This is PT_TLS segment p_vaddr. */
1764 dtpoff_base (struct bfd_link_info
*info
)
1766 /* If tls_sec is NULL, we should have signalled an error already. */
1767 if (elf_hash_table (info
)->tls_sec
== NULL
)
1769 return elf_hash_table (info
)->tls_sec
->vma
;
1772 /* Return the relocation value for @tpoff relocation
1773 if STT_TLS virtual address is ADDRESS. */
1776 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1778 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1780 /* If tls_segment is NULL, we should have signalled an error already. */
1781 if (htab
->tls_sec
== NULL
)
1783 return address
- htab
->tls_size
- htab
->tls_sec
->vma
;
1786 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
1790 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
1792 /* Opcode Instruction
1795 0x0f 0x8x conditional jump */
1797 && (contents
[offset
- 1] == 0xe8
1798 || contents
[offset
- 1] == 0xe9))
1800 && contents
[offset
- 2] == 0x0f
1801 && (contents
[offset
- 1] & 0xf0) == 0x80));
1804 /* Relocate an x86_64 ELF section. */
1807 elf64_x86_64_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
1808 bfd
*input_bfd
, asection
*input_section
,
1809 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
1810 Elf_Internal_Sym
*local_syms
,
1811 asection
**local_sections
)
1813 struct elf64_x86_64_link_hash_table
*htab
;
1814 Elf_Internal_Shdr
*symtab_hdr
;
1815 struct elf_link_hash_entry
**sym_hashes
;
1816 bfd_vma
*local_got_offsets
;
1817 Elf_Internal_Rela
*rel
;
1818 Elf_Internal_Rela
*relend
;
1820 if (info
->relocatable
)
1823 htab
= elf64_x86_64_hash_table (info
);
1824 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1825 sym_hashes
= elf_sym_hashes (input_bfd
);
1826 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1829 relend
= relocs
+ input_section
->reloc_count
;
1830 for (; rel
< relend
; rel
++)
1832 unsigned int r_type
;
1833 reloc_howto_type
*howto
;
1834 unsigned long r_symndx
;
1835 struct elf_link_hash_entry
*h
;
1836 Elf_Internal_Sym
*sym
;
1840 bfd_boolean unresolved_reloc
;
1841 bfd_reloc_status_type r
;
1844 r_type
= ELF64_R_TYPE (rel
->r_info
);
1845 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
1846 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
1849 if (r_type
>= R_X86_64_max
)
1851 bfd_set_error (bfd_error_bad_value
);
1855 howto
= x86_64_elf_howto_table
+ r_type
;
1856 r_symndx
= ELF64_R_SYM (rel
->r_info
);
1860 unresolved_reloc
= FALSE
;
1861 if (r_symndx
< symtab_hdr
->sh_info
)
1863 sym
= local_syms
+ r_symndx
;
1864 sec
= local_sections
[r_symndx
];
1866 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
1872 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1873 r_symndx
, symtab_hdr
, sym_hashes
,
1875 unresolved_reloc
, warned
);
1877 /* When generating a shared object, the relocations handled here are
1878 copied into the output file to be resolved at run time. */
1881 case R_X86_64_GOT32
:
1882 /* Relocation is to the entry for this symbol in the global
1884 case R_X86_64_GOTPCREL
:
1885 /* Use global offset table as symbol value. */
1886 if (htab
->sgot
== NULL
)
1893 off
= h
->got
.offset
;
1894 dyn
= htab
->elf
.dynamic_sections_created
;
1896 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
1898 && SYMBOL_REFERENCES_LOCAL (info
, h
))
1899 || (ELF_ST_VISIBILITY (h
->other
)
1900 && h
->root
.type
== bfd_link_hash_undefweak
))
1902 /* This is actually a static link, or it is a -Bsymbolic
1903 link and the symbol is defined locally, or the symbol
1904 was forced to be local because of a version file. We
1905 must initialize this entry in the global offset table.
1906 Since the offset must always be a multiple of 8, we
1907 use the least significant bit to record whether we
1908 have initialized it already.
1910 When doing a dynamic link, we create a .rela.got
1911 relocation entry to initialize the value. This is
1912 done in the finish_dynamic_symbol routine. */
1917 bfd_put_64 (output_bfd
, relocation
,
1918 htab
->sgot
->contents
+ off
);
1923 unresolved_reloc
= FALSE
;
1927 if (local_got_offsets
== NULL
)
1930 off
= local_got_offsets
[r_symndx
];
1932 /* The offset must always be a multiple of 8. We use
1933 the least significant bit to record whether we have
1934 already generated the necessary reloc. */
1939 bfd_put_64 (output_bfd
, relocation
,
1940 htab
->sgot
->contents
+ off
);
1945 Elf_Internal_Rela outrel
;
1948 /* We need to generate a R_X86_64_RELATIVE reloc
1949 for the dynamic linker. */
1954 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
1955 + htab
->sgot
->output_offset
1957 outrel
.r_info
= ELF64_R_INFO (0, R_X86_64_RELATIVE
);
1958 outrel
.r_addend
= relocation
;
1960 loc
+= s
->reloc_count
++ * sizeof (Elf64_External_Rela
);
1961 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
1964 local_got_offsets
[r_symndx
] |= 1;
1968 if (off
>= (bfd_vma
) -2)
1971 relocation
= htab
->sgot
->output_section
->vma
1972 + htab
->sgot
->output_offset
+ off
;
1973 if (r_type
!= R_X86_64_GOTPCREL
)
1974 relocation
-= htab
->sgotplt
->output_section
->vma
1975 - htab
->sgotplt
->output_offset
;
1979 case R_X86_64_GOTOFF64
:
1980 /* Relocation is relative to the start of the global offset
1983 /* Check to make sure it isn't a protected function symbol
1984 for shared library since it may not be local when used
1985 as function address. */
1989 && h
->type
== STT_FUNC
1990 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
1992 (*_bfd_error_handler
)
1993 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
1994 input_bfd
, h
->root
.root
.string
);
1995 bfd_set_error (bfd_error_bad_value
);
1999 /* Note that sgot is not involved in this
2000 calculation. We always want the start of .got.plt. If we
2001 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
2002 permitted by the ABI, we might have to change this
2004 relocation
-= htab
->sgotplt
->output_section
->vma
2005 + htab
->sgotplt
->output_offset
;
2008 case R_X86_64_GOTPC32
:
2009 /* Use global offset table as symbol value. */
2010 relocation
= htab
->sgotplt
->output_section
->vma
2011 + htab
->sgotplt
->output_offset
;
2012 unresolved_reloc
= FALSE
;
2015 case R_X86_64_PLT32
:
2016 /* Relocation is to the entry for this symbol in the
2017 procedure linkage table. */
2019 /* Resolve a PLT32 reloc against a local symbol directly,
2020 without using the procedure linkage table. */
2024 if (h
->plt
.offset
== (bfd_vma
) -1
2025 || htab
->splt
== NULL
)
2027 /* We didn't make a PLT entry for this symbol. This
2028 happens when statically linking PIC code, or when
2029 using -Bsymbolic. */
2033 relocation
= (htab
->splt
->output_section
->vma
2034 + htab
->splt
->output_offset
2036 unresolved_reloc
= FALSE
;
2043 && !SYMBOL_REFERENCES_LOCAL (info
, h
)
2044 && (input_section
->flags
& SEC_ALLOC
) != 0
2045 && (input_section
->flags
& SEC_READONLY
) != 0
2047 || r_type
!= R_X86_64_PC32
2048 || h
->type
!= STT_FUNC
2049 || ELF_ST_VISIBILITY (h
->other
) != STV_PROTECTED
2050 || !is_32bit_relative_branch (contents
,
2054 && r_type
== R_X86_64_PC32
2055 && h
->type
== STT_FUNC
2056 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
2057 (*_bfd_error_handler
)
2058 (_("%B: relocation R_X86_64_PC32 against protected function `%s' can not be used when making a shared object"),
2059 input_bfd
, h
->root
.root
.string
);
2061 (*_bfd_error_handler
)
2062 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
2063 input_bfd
, x86_64_elf_howto_table
[r_type
].name
,
2064 h
->root
.root
.string
);
2065 bfd_set_error (bfd_error_bad_value
);
2075 /* FIXME: The ABI says the linker should make sure the value is
2076 the same when it's zeroextended to 64 bit. */
2078 /* r_symndx will be zero only for relocs against symbols
2079 from removed linkonce sections, or sections discarded by
2082 || (input_section
->flags
& SEC_ALLOC
) == 0)
2087 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2088 || h
->root
.type
!= bfd_link_hash_undefweak
)
2089 && ((r_type
!= R_X86_64_PC8
2090 && r_type
!= R_X86_64_PC16
2091 && r_type
!= R_X86_64_PC32
2092 && r_type
!= R_X86_64_PC64
)
2093 || !SYMBOL_CALLS_LOCAL (info
, h
)))
2094 || (ELIMINATE_COPY_RELOCS
2101 || h
->root
.type
== bfd_link_hash_undefweak
2102 || h
->root
.type
== bfd_link_hash_undefined
)))
2104 Elf_Internal_Rela outrel
;
2106 bfd_boolean skip
, relocate
;
2109 /* When generating a shared object, these relocations
2110 are copied into the output file to be resolved at run
2116 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2118 if (outrel
.r_offset
== (bfd_vma
) -1)
2120 else if (outrel
.r_offset
== (bfd_vma
) -2)
2121 skip
= TRUE
, relocate
= TRUE
;
2123 outrel
.r_offset
+= (input_section
->output_section
->vma
2124 + input_section
->output_offset
);
2127 memset (&outrel
, 0, sizeof outrel
);
2129 /* h->dynindx may be -1 if this symbol was marked to
2133 && (r_type
== R_X86_64_PC8
2134 || r_type
== R_X86_64_PC16
2135 || r_type
== R_X86_64_PC32
2136 || r_type
== R_X86_64_PC64
2139 || !h
->def_regular
))
2141 outrel
.r_info
= ELF64_R_INFO (h
->dynindx
, r_type
);
2142 outrel
.r_addend
= rel
->r_addend
;
2146 /* This symbol is local, or marked to become local. */
2147 if (r_type
== R_X86_64_64
)
2150 outrel
.r_info
= ELF64_R_INFO (0, R_X86_64_RELATIVE
);
2151 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2157 if (bfd_is_abs_section (sec
))
2159 else if (sec
== NULL
|| sec
->owner
== NULL
)
2161 bfd_set_error (bfd_error_bad_value
);
2168 osec
= sec
->output_section
;
2169 sindx
= elf_section_data (osec
)->dynindx
;
2170 BFD_ASSERT (sindx
> 0);
2173 outrel
.r_info
= ELF64_R_INFO (sindx
, r_type
);
2174 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2178 sreloc
= elf_section_data (input_section
)->sreloc
;
2182 loc
= sreloc
->contents
;
2183 loc
+= sreloc
->reloc_count
++ * sizeof (Elf64_External_Rela
);
2184 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
2186 /* If this reloc is against an external symbol, we do
2187 not want to fiddle with the addend. Otherwise, we
2188 need to include the symbol value so that it becomes
2189 an addend for the dynamic reloc. */
2196 case R_X86_64_TLSGD
:
2197 case R_X86_64_GOTTPOFF
:
2198 r_type
= elf64_x86_64_tls_transition (info
, r_type
, h
== NULL
);
2199 tls_type
= GOT_UNKNOWN
;
2200 if (h
== NULL
&& local_got_offsets
)
2201 tls_type
= elf64_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
2204 tls_type
= elf64_x86_64_hash_entry (h
)->tls_type
;
2205 if (!info
->shared
&& h
->dynindx
== -1 && tls_type
== GOT_TLS_IE
)
2206 r_type
= R_X86_64_TPOFF32
;
2208 if (r_type
== R_X86_64_TLSGD
)
2210 if (tls_type
== GOT_TLS_IE
)
2211 r_type
= R_X86_64_GOTTPOFF
;
2214 if (r_type
== R_X86_64_TPOFF32
)
2216 BFD_ASSERT (! unresolved_reloc
);
2217 if (ELF64_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
2220 static unsigned char tlsgd
[8]
2221 = { 0x66, 0x48, 0x8d, 0x3d, 0x66, 0x66, 0x48, 0xe8 };
2223 /* GD->LE transition.
2224 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
2225 .word 0x6666; rex64; call __tls_get_addr@plt
2228 leaq foo@tpoff(%rax), %rax */
2229 BFD_ASSERT (rel
->r_offset
>= 4);
2230 for (i
= 0; i
< 4; i
++)
2231 BFD_ASSERT (bfd_get_8 (input_bfd
,
2232 contents
+ rel
->r_offset
- 4 + i
)
2234 BFD_ASSERT (rel
->r_offset
+ 12 <= input_section
->size
);
2235 for (i
= 0; i
< 4; i
++)
2236 BFD_ASSERT (bfd_get_8 (input_bfd
,
2237 contents
+ rel
->r_offset
+ 4 + i
)
2239 BFD_ASSERT (rel
+ 1 < relend
);
2240 BFD_ASSERT (ELF64_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
);
2241 memcpy (contents
+ rel
->r_offset
- 4,
2242 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
2244 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
2245 contents
+ rel
->r_offset
+ 8);
2246 /* Skip R_X86_64_PLT32. */
2252 unsigned int val
, type
, reg
;
2254 /* IE->LE transition:
2255 Originally it can be one of:
2256 movq foo@gottpoff(%rip), %reg
2257 addq foo@gottpoff(%rip), %reg
2260 leaq foo(%reg), %reg
2262 BFD_ASSERT (rel
->r_offset
>= 3);
2263 val
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 3);
2264 BFD_ASSERT (val
== 0x48 || val
== 0x4c);
2265 type
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2);
2266 BFD_ASSERT (type
== 0x8b || type
== 0x03);
2267 reg
= bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1);
2268 BFD_ASSERT ((reg
& 0xc7) == 5);
2270 BFD_ASSERT (rel
->r_offset
+ 4 <= input_section
->size
);
2275 bfd_put_8 (output_bfd
, 0x49,
2276 contents
+ rel
->r_offset
- 3);
2277 bfd_put_8 (output_bfd
, 0xc7,
2278 contents
+ rel
->r_offset
- 2);
2279 bfd_put_8 (output_bfd
, 0xc0 | reg
,
2280 contents
+ rel
->r_offset
- 1);
2284 /* addq -> addq - addressing with %rsp/%r12 is
2287 bfd_put_8 (output_bfd
, 0x49,
2288 contents
+ rel
->r_offset
- 3);
2289 bfd_put_8 (output_bfd
, 0x81,
2290 contents
+ rel
->r_offset
- 2);
2291 bfd_put_8 (output_bfd
, 0xc0 | reg
,
2292 contents
+ rel
->r_offset
- 1);
2298 bfd_put_8 (output_bfd
, 0x4d,
2299 contents
+ rel
->r_offset
- 3);
2300 bfd_put_8 (output_bfd
, 0x8d,
2301 contents
+ rel
->r_offset
- 2);
2302 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
2303 contents
+ rel
->r_offset
- 1);
2305 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
2306 contents
+ rel
->r_offset
);
2311 if (htab
->sgot
== NULL
)
2315 off
= h
->got
.offset
;
2318 if (local_got_offsets
== NULL
)
2321 off
= local_got_offsets
[r_symndx
];
2328 Elf_Internal_Rela outrel
;
2332 if (htab
->srelgot
== NULL
)
2335 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
2336 + htab
->sgot
->output_offset
+ off
);
2338 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
2339 if (r_type
== R_X86_64_TLSGD
)
2340 dr_type
= R_X86_64_DTPMOD64
;
2342 dr_type
= R_X86_64_TPOFF64
;
2344 bfd_put_64 (output_bfd
, 0, htab
->sgot
->contents
+ off
);
2345 outrel
.r_addend
= 0;
2346 if (dr_type
== R_X86_64_TPOFF64
&& indx
== 0)
2347 outrel
.r_addend
= relocation
- dtpoff_base (info
);
2348 outrel
.r_info
= ELF64_R_INFO (indx
, dr_type
);
2350 loc
= htab
->srelgot
->contents
;
2351 loc
+= htab
->srelgot
->reloc_count
++ * sizeof (Elf64_External_Rela
);
2352 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
2354 if (r_type
== R_X86_64_TLSGD
)
2358 BFD_ASSERT (! unresolved_reloc
);
2359 bfd_put_64 (output_bfd
,
2360 relocation
- dtpoff_base (info
),
2361 htab
->sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
2365 bfd_put_64 (output_bfd
, 0,
2366 htab
->sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
2367 outrel
.r_info
= ELF64_R_INFO (indx
,
2369 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
2370 htab
->srelgot
->reloc_count
++;
2371 loc
+= sizeof (Elf64_External_Rela
);
2372 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
2379 local_got_offsets
[r_symndx
] |= 1;
2382 if (off
>= (bfd_vma
) -2)
2384 if (r_type
== ELF64_R_TYPE (rel
->r_info
))
2386 relocation
= htab
->sgot
->output_section
->vma
2387 + htab
->sgot
->output_offset
+ off
;
2388 unresolved_reloc
= FALSE
;
2393 static unsigned char tlsgd
[8]
2394 = { 0x66, 0x48, 0x8d, 0x3d, 0x66, 0x66, 0x48, 0xe8 };
2396 /* GD->IE transition.
2397 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
2398 .word 0x6666; rex64; call __tls_get_addr@plt
2401 addq foo@gottpoff(%rip), %rax */
2402 BFD_ASSERT (rel
->r_offset
>= 4);
2403 for (i
= 0; i
< 4; i
++)
2404 BFD_ASSERT (bfd_get_8 (input_bfd
,
2405 contents
+ rel
->r_offset
- 4 + i
)
2407 BFD_ASSERT (rel
->r_offset
+ 12 <= input_section
->size
);
2408 for (i
= 0; i
< 4; i
++)
2409 BFD_ASSERT (bfd_get_8 (input_bfd
,
2410 contents
+ rel
->r_offset
+ 4 + i
)
2412 BFD_ASSERT (rel
+ 1 < relend
);
2413 BFD_ASSERT (ELF64_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
);
2414 memcpy (contents
+ rel
->r_offset
- 4,
2415 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
2418 relocation
= (htab
->sgot
->output_section
->vma
2419 + htab
->sgot
->output_offset
+ off
2421 - input_section
->output_section
->vma
2422 - input_section
->output_offset
2424 bfd_put_32 (output_bfd
, relocation
,
2425 contents
+ rel
->r_offset
+ 8);
2426 /* Skip R_X86_64_PLT32. */
2432 case R_X86_64_TLSLD
:
2435 /* LD->LE transition:
2437 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr@plt.
2439 .word 0x6666; .byte 0x66; movl %fs:0, %rax. */
2440 BFD_ASSERT (rel
->r_offset
>= 3);
2441 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 3)
2443 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 2)
2445 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
- 1)
2447 BFD_ASSERT (rel
->r_offset
+ 9 <= input_section
->size
);
2448 BFD_ASSERT (bfd_get_8 (input_bfd
, contents
+ rel
->r_offset
+ 4)
2450 BFD_ASSERT (rel
+ 1 < relend
);
2451 BFD_ASSERT (ELF64_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
);
2452 memcpy (contents
+ rel
->r_offset
- 3,
2453 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
2454 /* Skip R_X86_64_PLT32. */
2459 if (htab
->sgot
== NULL
)
2462 off
= htab
->tls_ld_got
.offset
;
2467 Elf_Internal_Rela outrel
;
2470 if (htab
->srelgot
== NULL
)
2473 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
2474 + htab
->sgot
->output_offset
+ off
);
2476 bfd_put_64 (output_bfd
, 0,
2477 htab
->sgot
->contents
+ off
);
2478 bfd_put_64 (output_bfd
, 0,
2479 htab
->sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
2480 outrel
.r_info
= ELF64_R_INFO (0, R_X86_64_DTPMOD64
);
2481 outrel
.r_addend
= 0;
2482 loc
= htab
->srelgot
->contents
;
2483 loc
+= htab
->srelgot
->reloc_count
++ * sizeof (Elf64_External_Rela
);
2484 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
2485 htab
->tls_ld_got
.offset
|= 1;
2487 relocation
= htab
->sgot
->output_section
->vma
2488 + htab
->sgot
->output_offset
+ off
;
2489 unresolved_reloc
= FALSE
;
2492 case R_X86_64_DTPOFF32
:
2493 if (info
->shared
|| (input_section
->flags
& SEC_CODE
) == 0)
2494 relocation
-= dtpoff_base (info
);
2496 relocation
= tpoff (info
, relocation
);
2499 case R_X86_64_TPOFF32
:
2500 BFD_ASSERT (! info
->shared
);
2501 relocation
= tpoff (info
, relocation
);
2508 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2509 because such sections are not SEC_ALLOC and thus ld.so will
2510 not process them. */
2511 if (unresolved_reloc
2512 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
2514 (*_bfd_error_handler
)
2515 (_("%B(%A+0x%lx): unresolvable relocation against symbol `%s'"),
2518 (long) rel
->r_offset
,
2519 h
->root
.root
.string
);
2521 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
2522 contents
, rel
->r_offset
,
2523 relocation
, rel
->r_addend
);
2525 if (r
!= bfd_reloc_ok
)
2530 name
= h
->root
.root
.string
;
2533 name
= bfd_elf_string_from_elf_section (input_bfd
,
2534 symtab_hdr
->sh_link
,
2539 name
= bfd_section_name (input_bfd
, sec
);
2542 if (r
== bfd_reloc_overflow
)
2545 && h
->root
.type
== bfd_link_hash_undefweak
2546 && howto
->pc_relative
)
2547 /* Ignore reloc overflow on branches to undefweak syms. */
2550 if (! ((*info
->callbacks
->reloc_overflow
)
2551 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
2552 (bfd_vma
) 0, input_bfd
, input_section
,
2558 (*_bfd_error_handler
)
2559 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
2560 input_bfd
, input_section
,
2561 (long) rel
->r_offset
, name
, (int) r
);
2570 /* Finish up dynamic symbol handling. We set the contents of various
2571 dynamic sections here. */
2574 elf64_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
2575 struct bfd_link_info
*info
,
2576 struct elf_link_hash_entry
*h
,
2577 Elf_Internal_Sym
*sym
)
2579 struct elf64_x86_64_link_hash_table
*htab
;
2581 htab
= elf64_x86_64_hash_table (info
);
2583 if (h
->plt
.offset
!= (bfd_vma
) -1)
2587 Elf_Internal_Rela rela
;
2590 /* This symbol has an entry in the procedure linkage table. Set
2592 if (h
->dynindx
== -1
2593 || htab
->splt
== NULL
2594 || htab
->sgotplt
== NULL
2595 || htab
->srelplt
== NULL
)
2598 /* Get the index in the procedure linkage table which
2599 corresponds to this symbol. This is the index of this symbol
2600 in all the symbols for which we are making plt entries. The
2601 first entry in the procedure linkage table is reserved. */
2602 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
2604 /* Get the offset into the .got table of the entry that
2605 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
2606 bytes. The first three are reserved for the dynamic linker. */
2607 got_offset
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
2609 /* Fill in the entry in the procedure linkage table. */
2610 memcpy (htab
->splt
->contents
+ h
->plt
.offset
, elf64_x86_64_plt_entry
,
2613 /* Insert the relocation positions of the plt section. The magic
2614 numbers at the end of the statements are the positions of the
2615 relocations in the plt section. */
2616 /* Put offset for jmp *name@GOTPCREL(%rip), since the
2617 instruction uses 6 bytes, subtract this value. */
2618 bfd_put_32 (output_bfd
,
2619 (htab
->sgotplt
->output_section
->vma
2620 + htab
->sgotplt
->output_offset
2622 - htab
->splt
->output_section
->vma
2623 - htab
->splt
->output_offset
2626 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
2627 /* Put relocation index. */
2628 bfd_put_32 (output_bfd
, plt_index
,
2629 htab
->splt
->contents
+ h
->plt
.offset
+ 7);
2630 /* Put offset for jmp .PLT0. */
2631 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
2632 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
2634 /* Fill in the entry in the global offset table, initially this
2635 points to the pushq instruction in the PLT which is at offset 6. */
2636 bfd_put_64 (output_bfd
, (htab
->splt
->output_section
->vma
2637 + htab
->splt
->output_offset
2638 + h
->plt
.offset
+ 6),
2639 htab
->sgotplt
->contents
+ got_offset
);
2641 /* Fill in the entry in the .rela.plt section. */
2642 rela
.r_offset
= (htab
->sgotplt
->output_section
->vma
2643 + htab
->sgotplt
->output_offset
2645 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_X86_64_JUMP_SLOT
);
2647 loc
= htab
->srelplt
->contents
+ plt_index
* sizeof (Elf64_External_Rela
);
2648 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
2650 if (!h
->def_regular
)
2652 /* Mark the symbol as undefined, rather than as defined in
2653 the .plt section. Leave the value if there were any
2654 relocations where pointer equality matters (this is a clue
2655 for the dynamic linker, to make function pointer
2656 comparisons work between an application and shared
2657 library), otherwise set it to zero. If a function is only
2658 called from a binary, there is no need to slow down
2659 shared libraries because of that. */
2660 sym
->st_shndx
= SHN_UNDEF
;
2661 if (!h
->pointer_equality_needed
)
2666 if (h
->got
.offset
!= (bfd_vma
) -1
2667 && elf64_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_GD
2668 && elf64_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
)
2670 Elf_Internal_Rela rela
;
2673 /* This symbol has an entry in the global offset table. Set it
2675 if (htab
->sgot
== NULL
|| htab
->srelgot
== NULL
)
2678 rela
.r_offset
= (htab
->sgot
->output_section
->vma
2679 + htab
->sgot
->output_offset
2680 + (h
->got
.offset
&~ (bfd_vma
) 1));
2682 /* If this is a static link, or it is a -Bsymbolic link and the
2683 symbol is defined locally or was forced to be local because
2684 of a version file, we just want to emit a RELATIVE reloc.
2685 The entry in the global offset table will already have been
2686 initialized in the relocate_section function. */
2688 && SYMBOL_REFERENCES_LOCAL (info
, h
))
2690 BFD_ASSERT((h
->got
.offset
& 1) != 0);
2691 rela
.r_info
= ELF64_R_INFO (0, R_X86_64_RELATIVE
);
2692 rela
.r_addend
= (h
->root
.u
.def
.value
2693 + h
->root
.u
.def
.section
->output_section
->vma
2694 + h
->root
.u
.def
.section
->output_offset
);
2698 BFD_ASSERT((h
->got
.offset
& 1) == 0);
2699 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
2700 htab
->sgot
->contents
+ h
->got
.offset
);
2701 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_X86_64_GLOB_DAT
);
2705 loc
= htab
->srelgot
->contents
;
2706 loc
+= htab
->srelgot
->reloc_count
++ * sizeof (Elf64_External_Rela
);
2707 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
2712 Elf_Internal_Rela rela
;
2715 /* This symbol needs a copy reloc. Set it up. */
2717 if (h
->dynindx
== -1
2718 || (h
->root
.type
!= bfd_link_hash_defined
2719 && h
->root
.type
!= bfd_link_hash_defweak
)
2720 || htab
->srelbss
== NULL
)
2723 rela
.r_offset
= (h
->root
.u
.def
.value
2724 + h
->root
.u
.def
.section
->output_section
->vma
2725 + h
->root
.u
.def
.section
->output_offset
);
2726 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_X86_64_COPY
);
2728 loc
= htab
->srelbss
->contents
;
2729 loc
+= htab
->srelbss
->reloc_count
++ * sizeof (Elf64_External_Rela
);
2730 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
2733 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2734 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2735 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2736 sym
->st_shndx
= SHN_ABS
;
2741 /* Used to decide how to sort relocs in an optimal manner for the
2742 dynamic linker, before writing them out. */
2744 static enum elf_reloc_type_class
2745 elf64_x86_64_reloc_type_class (const Elf_Internal_Rela
*rela
)
2747 switch ((int) ELF64_R_TYPE (rela
->r_info
))
2749 case R_X86_64_RELATIVE
:
2750 return reloc_class_relative
;
2751 case R_X86_64_JUMP_SLOT
:
2752 return reloc_class_plt
;
2754 return reloc_class_copy
;
2756 return reloc_class_normal
;
2760 /* Finish up the dynamic sections. */
2763 elf64_x86_64_finish_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
2765 struct elf64_x86_64_link_hash_table
*htab
;
2769 htab
= elf64_x86_64_hash_table (info
);
2770 dynobj
= htab
->elf
.dynobj
;
2771 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2773 if (htab
->elf
.dynamic_sections_created
)
2775 Elf64_External_Dyn
*dyncon
, *dynconend
;
2777 if (sdyn
== NULL
|| htab
->sgot
== NULL
)
2780 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
2781 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
2782 for (; dyncon
< dynconend
; dyncon
++)
2784 Elf_Internal_Dyn dyn
;
2787 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2796 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2800 dyn
.d_un
.d_ptr
= htab
->srelplt
->output_section
->vma
;
2804 s
= htab
->srelplt
->output_section
;
2805 dyn
.d_un
.d_val
= s
->size
;
2809 /* The procedure linkage table relocs (DT_JMPREL) should
2810 not be included in the overall relocs (DT_RELA).
2811 Therefore, we override the DT_RELASZ entry here to
2812 make it not include the JMPREL relocs. Since the
2813 linker script arranges for .rela.plt to follow all
2814 other relocation sections, we don't have to worry
2815 about changing the DT_RELA entry. */
2816 if (htab
->srelplt
!= NULL
)
2818 s
= htab
->srelplt
->output_section
;
2819 dyn
.d_un
.d_val
-= s
->size
;
2824 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2827 /* Fill in the special first entry in the procedure linkage table. */
2828 if (htab
->splt
&& htab
->splt
->size
> 0)
2830 /* Fill in the first entry in the procedure linkage table. */
2831 memcpy (htab
->splt
->contents
, elf64_x86_64_plt0_entry
,
2833 /* Add offset for pushq GOT+8(%rip), since the instruction
2834 uses 6 bytes subtract this value. */
2835 bfd_put_32 (output_bfd
,
2836 (htab
->sgotplt
->output_section
->vma
2837 + htab
->sgotplt
->output_offset
2839 - htab
->splt
->output_section
->vma
2840 - htab
->splt
->output_offset
2842 htab
->splt
->contents
+ 2);
2843 /* Add offset for jmp *GOT+16(%rip). The 12 is the offset to
2844 the end of the instruction. */
2845 bfd_put_32 (output_bfd
,
2846 (htab
->sgotplt
->output_section
->vma
2847 + htab
->sgotplt
->output_offset
2849 - htab
->splt
->output_section
->vma
2850 - htab
->splt
->output_offset
2852 htab
->splt
->contents
+ 8);
2854 elf_section_data (htab
->splt
->output_section
)->this_hdr
.sh_entsize
=
2861 /* Fill in the first three entries in the global offset table. */
2862 if (htab
->sgotplt
->size
> 0)
2864 /* Set the first entry in the global offset table to the address of
2865 the dynamic section. */
2867 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
);
2869 bfd_put_64 (output_bfd
,
2870 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2871 htab
->sgotplt
->contents
);
2872 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
2873 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ GOT_ENTRY_SIZE
);
2874 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
2877 elf_section_data (htab
->sgotplt
->output_section
)->this_hdr
.sh_entsize
=
2881 if (htab
->sgot
&& htab
->sgot
->size
> 0)
2882 elf_section_data (htab
->sgot
->output_section
)->this_hdr
.sh_entsize
2888 /* Return address for Ith PLT stub in section PLT, for relocation REL
2889 or (bfd_vma) -1 if it should not be included. */
2892 elf64_x86_64_plt_sym_val (bfd_vma i
, const asection
*plt
,
2893 const arelent
*rel ATTRIBUTE_UNUSED
)
2895 return plt
->vma
+ (i
+ 1) * PLT_ENTRY_SIZE
;
2898 /* Handle an x86-64 specific section when reading an object file. This
2899 is called when elfcode.h finds a section with an unknown type. */
2902 elf64_x86_64_section_from_shdr (bfd
*abfd
,
2903 Elf_Internal_Shdr
*hdr
,
2907 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
2910 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2916 /* Hook called by the linker routine which adds symbols from an object
2917 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
2921 elf64_x86_64_add_symbol_hook (bfd
*abfd
,
2922 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2923 Elf_Internal_Sym
*sym
,
2924 const char **namep ATTRIBUTE_UNUSED
,
2925 flagword
*flagsp ATTRIBUTE_UNUSED
,
2926 asection
**secp
, bfd_vma
*valp
)
2930 switch (sym
->st_shndx
)
2932 case SHN_X86_64_LCOMMON
:
2933 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
2936 lcomm
= bfd_make_section_with_flags (abfd
,
2940 | SEC_LINKER_CREATED
));
2943 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
2946 *valp
= sym
->st_size
;
2953 /* Given a BFD section, try to locate the corresponding ELF section
2957 elf64_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
2958 asection
*sec
, int *index
)
2960 if (sec
== &_bfd_elf_large_com_section
)
2962 *index
= SHN_X86_64_LCOMMON
;
2968 /* Process a symbol. */
2971 elf64_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
2974 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
2976 switch (elfsym
->internal_elf_sym
.st_shndx
)
2978 case SHN_X86_64_LCOMMON
:
2979 asym
->section
= &_bfd_elf_large_com_section
;
2980 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
2981 /* Common symbol doesn't set BSF_GLOBAL. */
2982 asym
->flags
&= ~BSF_GLOBAL
;
2988 elf64_x86_64_common_definition (Elf_Internal_Sym
*sym
)
2990 return (sym
->st_shndx
== SHN_COMMON
2991 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
2995 elf64_x86_64_common_section_index (asection
*sec
)
2997 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
3000 return SHN_X86_64_LCOMMON
;
3004 elf64_x86_64_common_section (asection
*sec
)
3006 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
3007 return bfd_com_section_ptr
;
3009 return &_bfd_elf_large_com_section
;
3013 elf64_x86_64_merge_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3014 struct elf_link_hash_entry
**sym_hash ATTRIBUTE_UNUSED
,
3015 struct elf_link_hash_entry
*h
,
3016 Elf_Internal_Sym
*sym
,
3017 asection
**psec ATTRIBUTE_UNUSED
,
3018 bfd_vma
*pvalue ATTRIBUTE_UNUSED
,
3019 unsigned int *pold_alignment ATTRIBUTE_UNUSED
,
3020 bfd_boolean
*skip ATTRIBUTE_UNUSED
,
3021 bfd_boolean
*override ATTRIBUTE_UNUSED
,
3022 bfd_boolean
*type_change_ok ATTRIBUTE_UNUSED
,
3023 bfd_boolean
*size_change_ok ATTRIBUTE_UNUSED
,
3024 bfd_boolean
*newdef ATTRIBUTE_UNUSED
,
3025 bfd_boolean
*newdyn
,
3026 bfd_boolean
*newdyncommon ATTRIBUTE_UNUSED
,
3027 bfd_boolean
*newweak ATTRIBUTE_UNUSED
,
3028 bfd
*abfd ATTRIBUTE_UNUSED
,
3030 bfd_boolean
*olddef ATTRIBUTE_UNUSED
,
3031 bfd_boolean
*olddyn
,
3032 bfd_boolean
*olddyncommon ATTRIBUTE_UNUSED
,
3033 bfd_boolean
*oldweak ATTRIBUTE_UNUSED
,
3034 bfd
*oldbfd ATTRIBUTE_UNUSED
,
3037 /* A normal common symbol and a large common symbol result in a
3038 normal common symbol. If we see the normal symbol first, we
3039 do nothing since the first one will be used. If we see the
3040 large common symbol first, we need to change the large common
3041 symbol to the normal common symbol. */
3043 && h
->root
.type
== bfd_link_hash_common
3045 && bfd_is_com_section (*sec
)
3047 && sym
->st_shndx
== SHN_COMMON
3048 && (elf_section_flags (*oldsec
) & SHF_X86_64_LARGE
) != 0)
3050 h
->root
.u
.c
.p
->section
= bfd_make_section_old_way (abfd
,
3052 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
3059 elf64_x86_64_additional_program_headers (bfd
*abfd
)
3064 /* Check to see if we need a large readonly segment. */
3065 s
= bfd_get_section_by_name (abfd
, ".lrodata");
3066 if (s
&& (s
->flags
& SEC_LOAD
))
3069 /* Check to see if we need a large data segment. Since .lbss sections
3070 is placed right after the .bss section, there should be no need for
3071 a large data segment just because of .lbss. */
3072 s
= bfd_get_section_by_name (abfd
, ".ldata");
3073 if (s
&& (s
->flags
& SEC_LOAD
))
3079 static const struct bfd_elf_special_section
3080 elf64_x86_64_special_sections
[]=
3082 { ".gnu.linkonce.lb", 16, -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
3083 { ".gnu.linkonce.lr", 16, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
3084 { ".gnu.linkonce.lt", 16, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
3085 { ".lbss", 5, -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
3086 { ".ldata", 6, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
3087 { ".lrodata", 8, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
3088 { NULL
, 0, 0, 0, 0 }
3091 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_vec
3092 #define TARGET_LITTLE_NAME "elf64-x86-64"
3093 #define ELF_ARCH bfd_arch_i386
3094 #define ELF_MACHINE_CODE EM_X86_64
3095 #define ELF_MAXPAGESIZE 0x100000
3097 #define elf_backend_can_gc_sections 1
3098 #define elf_backend_can_refcount 1
3099 #define elf_backend_want_got_plt 1
3100 #define elf_backend_plt_readonly 1
3101 #define elf_backend_want_plt_sym 0
3102 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
3103 #define elf_backend_rela_normal 1
3105 #define elf_info_to_howto elf64_x86_64_info_to_howto
3107 #define bfd_elf64_bfd_link_hash_table_create \
3108 elf64_x86_64_link_hash_table_create
3109 #define bfd_elf64_bfd_reloc_type_lookup elf64_x86_64_reloc_type_lookup
3111 #define elf_backend_adjust_dynamic_symbol elf64_x86_64_adjust_dynamic_symbol
3112 #define elf_backend_check_relocs elf64_x86_64_check_relocs
3113 #define elf_backend_copy_indirect_symbol elf64_x86_64_copy_indirect_symbol
3114 #define elf_backend_create_dynamic_sections elf64_x86_64_create_dynamic_sections
3115 #define elf_backend_finish_dynamic_sections elf64_x86_64_finish_dynamic_sections
3116 #define elf_backend_finish_dynamic_symbol elf64_x86_64_finish_dynamic_symbol
3117 #define elf_backend_gc_mark_hook elf64_x86_64_gc_mark_hook
3118 #define elf_backend_gc_sweep_hook elf64_x86_64_gc_sweep_hook
3119 #define elf_backend_grok_prstatus elf64_x86_64_grok_prstatus
3120 #define elf_backend_grok_psinfo elf64_x86_64_grok_psinfo
3121 #define elf_backend_reloc_type_class elf64_x86_64_reloc_type_class
3122 #define elf_backend_relocate_section elf64_x86_64_relocate_section
3123 #define elf_backend_size_dynamic_sections elf64_x86_64_size_dynamic_sections
3124 #define elf_backend_plt_sym_val elf64_x86_64_plt_sym_val
3125 #define elf_backend_object_p elf64_x86_64_elf_object_p
3126 #define bfd_elf64_mkobject elf64_x86_64_mkobject
3128 #define elf_backend_section_from_shdr \
3129 elf64_x86_64_section_from_shdr
3131 #define elf_backend_section_from_bfd_section \
3132 elf64_x86_64_elf_section_from_bfd_section
3133 #define elf_backend_add_symbol_hook \
3134 elf64_x86_64_add_symbol_hook
3135 #define elf_backend_symbol_processing \
3136 elf64_x86_64_symbol_processing
3137 #define elf_backend_common_section_index \
3138 elf64_x86_64_common_section_index
3139 #define elf_backend_common_section \
3140 elf64_x86_64_common_section
3141 #define elf_backend_common_definition \
3142 elf64_x86_64_common_definition
3143 #define elf_backend_merge_symbol \
3144 elf64_x86_64_merge_symbol
3145 #define elf_backend_special_sections \
3146 elf64_x86_64_special_sections
3147 #define elf_backend_additional_program_headers \
3148 elf64_x86_64_additional_program_headers
3150 #include "elf64-target.h"