1 /* X86-64 specific support for ELF
2 Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
4 Free Software Foundation, Inc.
5 Contributed by Jan Hubicka <jh@suse.cz>.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
29 #include "bfd_stdint.h"
33 #include "elf/x86-64.h"
35 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
36 #define MINUS_ONE (~ (bfd_vma) 0)
38 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
39 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
40 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
41 since they are the same. */
43 #define ABI_64_P(abfd) \
44 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
46 /* The relocation "howto" table. Order of fields:
47 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
48 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
49 static reloc_howto_type x86_64_elf_howto_table
[] =
51 HOWTO(R_X86_64_NONE
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
52 bfd_elf_generic_reloc
, "R_X86_64_NONE", FALSE
, 0x00000000, 0x00000000,
54 HOWTO(R_X86_64_64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
55 bfd_elf_generic_reloc
, "R_X86_64_64", FALSE
, MINUS_ONE
, MINUS_ONE
,
57 HOWTO(R_X86_64_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
58 bfd_elf_generic_reloc
, "R_X86_64_PC32", FALSE
, 0xffffffff, 0xffffffff,
60 HOWTO(R_X86_64_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
61 bfd_elf_generic_reloc
, "R_X86_64_GOT32", FALSE
, 0xffffffff, 0xffffffff,
63 HOWTO(R_X86_64_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
64 bfd_elf_generic_reloc
, "R_X86_64_PLT32", FALSE
, 0xffffffff, 0xffffffff,
66 HOWTO(R_X86_64_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
67 bfd_elf_generic_reloc
, "R_X86_64_COPY", FALSE
, 0xffffffff, 0xffffffff,
69 HOWTO(R_X86_64_GLOB_DAT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
70 bfd_elf_generic_reloc
, "R_X86_64_GLOB_DAT", FALSE
, MINUS_ONE
,
72 HOWTO(R_X86_64_JUMP_SLOT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
73 bfd_elf_generic_reloc
, "R_X86_64_JUMP_SLOT", FALSE
, MINUS_ONE
,
75 HOWTO(R_X86_64_RELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
76 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE", FALSE
, MINUS_ONE
,
78 HOWTO(R_X86_64_GOTPCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
79 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL", FALSE
, 0xffffffff,
81 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
82 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
84 HOWTO(R_X86_64_32S
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
85 bfd_elf_generic_reloc
, "R_X86_64_32S", FALSE
, 0xffffffff, 0xffffffff,
87 HOWTO(R_X86_64_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
88 bfd_elf_generic_reloc
, "R_X86_64_16", FALSE
, 0xffff, 0xffff, FALSE
),
89 HOWTO(R_X86_64_PC16
,0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
90 bfd_elf_generic_reloc
, "R_X86_64_PC16", FALSE
, 0xffff, 0xffff, TRUE
),
91 HOWTO(R_X86_64_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
92 bfd_elf_generic_reloc
, "R_X86_64_8", FALSE
, 0xff, 0xff, FALSE
),
93 HOWTO(R_X86_64_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
94 bfd_elf_generic_reloc
, "R_X86_64_PC8", FALSE
, 0xff, 0xff, TRUE
),
95 HOWTO(R_X86_64_DTPMOD64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
96 bfd_elf_generic_reloc
, "R_X86_64_DTPMOD64", FALSE
, MINUS_ONE
,
98 HOWTO(R_X86_64_DTPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
99 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF64", FALSE
, MINUS_ONE
,
101 HOWTO(R_X86_64_TPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
102 bfd_elf_generic_reloc
, "R_X86_64_TPOFF64", FALSE
, MINUS_ONE
,
104 HOWTO(R_X86_64_TLSGD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
105 bfd_elf_generic_reloc
, "R_X86_64_TLSGD", FALSE
, 0xffffffff,
107 HOWTO(R_X86_64_TLSLD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
108 bfd_elf_generic_reloc
, "R_X86_64_TLSLD", FALSE
, 0xffffffff,
110 HOWTO(R_X86_64_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
111 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF32", FALSE
, 0xffffffff,
113 HOWTO(R_X86_64_GOTTPOFF
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
114 bfd_elf_generic_reloc
, "R_X86_64_GOTTPOFF", FALSE
, 0xffffffff,
116 HOWTO(R_X86_64_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
117 bfd_elf_generic_reloc
, "R_X86_64_TPOFF32", FALSE
, 0xffffffff,
119 HOWTO(R_X86_64_PC64
, 0, 4, 64, TRUE
, 0, complain_overflow_bitfield
,
120 bfd_elf_generic_reloc
, "R_X86_64_PC64", FALSE
, MINUS_ONE
, MINUS_ONE
,
122 HOWTO(R_X86_64_GOTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
123 bfd_elf_generic_reloc
, "R_X86_64_GOTOFF64",
124 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
125 HOWTO(R_X86_64_GOTPC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
126 bfd_elf_generic_reloc
, "R_X86_64_GOTPC32",
127 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
128 HOWTO(R_X86_64_GOT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
129 bfd_elf_generic_reloc
, "R_X86_64_GOT64", FALSE
, MINUS_ONE
, MINUS_ONE
,
131 HOWTO(R_X86_64_GOTPCREL64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
132 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL64", FALSE
, MINUS_ONE
,
134 HOWTO(R_X86_64_GOTPC64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
135 bfd_elf_generic_reloc
, "R_X86_64_GOTPC64",
136 FALSE
, MINUS_ONE
, MINUS_ONE
, TRUE
),
137 HOWTO(R_X86_64_GOTPLT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
138 bfd_elf_generic_reloc
, "R_X86_64_GOTPLT64", FALSE
, MINUS_ONE
,
140 HOWTO(R_X86_64_PLTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
141 bfd_elf_generic_reloc
, "R_X86_64_PLTOFF64", FALSE
, MINUS_ONE
,
145 HOWTO(R_X86_64_GOTPC32_TLSDESC
, 0, 2, 32, TRUE
, 0,
146 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
147 "R_X86_64_GOTPC32_TLSDESC",
148 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
149 HOWTO(R_X86_64_TLSDESC_CALL
, 0, 0, 0, FALSE
, 0,
150 complain_overflow_dont
, bfd_elf_generic_reloc
,
151 "R_X86_64_TLSDESC_CALL",
153 HOWTO(R_X86_64_TLSDESC
, 0, 4, 64, FALSE
, 0,
154 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
156 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
157 HOWTO(R_X86_64_IRELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
158 bfd_elf_generic_reloc
, "R_X86_64_IRELATIVE", FALSE
, MINUS_ONE
,
161 /* We have a gap in the reloc numbers here.
162 R_X86_64_standard counts the number up to this point, and
163 R_X86_64_vt_offset is the value to subtract from a reloc type of
164 R_X86_64_GNU_VT* to form an index into this table. */
165 #define R_X86_64_standard (R_X86_64_IRELATIVE + 1)
166 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
168 /* GNU extension to record C++ vtable hierarchy. */
169 HOWTO (R_X86_64_GNU_VTINHERIT
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
170 NULL
, "R_X86_64_GNU_VTINHERIT", FALSE
, 0, 0, FALSE
),
172 /* GNU extension to record C++ vtable member usage. */
173 HOWTO (R_X86_64_GNU_VTENTRY
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
174 _bfd_elf_rel_vtable_reloc_fn
, "R_X86_64_GNU_VTENTRY", FALSE
, 0, 0,
178 #define IS_X86_64_PCREL_TYPE(TYPE) \
179 ( ((TYPE) == R_X86_64_PC8) \
180 || ((TYPE) == R_X86_64_PC16) \
181 || ((TYPE) == R_X86_64_PC32) \
182 || ((TYPE) == R_X86_64_PC64))
184 /* Map BFD relocs to the x86_64 elf relocs. */
187 bfd_reloc_code_real_type bfd_reloc_val
;
188 unsigned char elf_reloc_val
;
191 static const struct elf_reloc_map x86_64_reloc_map
[] =
193 { BFD_RELOC_NONE
, R_X86_64_NONE
, },
194 { BFD_RELOC_64
, R_X86_64_64
, },
195 { BFD_RELOC_32_PCREL
, R_X86_64_PC32
, },
196 { BFD_RELOC_X86_64_GOT32
, R_X86_64_GOT32
,},
197 { BFD_RELOC_X86_64_PLT32
, R_X86_64_PLT32
,},
198 { BFD_RELOC_X86_64_COPY
, R_X86_64_COPY
, },
199 { BFD_RELOC_X86_64_GLOB_DAT
, R_X86_64_GLOB_DAT
, },
200 { BFD_RELOC_X86_64_JUMP_SLOT
, R_X86_64_JUMP_SLOT
, },
201 { BFD_RELOC_X86_64_RELATIVE
, R_X86_64_RELATIVE
, },
202 { BFD_RELOC_X86_64_GOTPCREL
, R_X86_64_GOTPCREL
, },
203 { BFD_RELOC_32
, R_X86_64_32
, },
204 { BFD_RELOC_X86_64_32S
, R_X86_64_32S
, },
205 { BFD_RELOC_16
, R_X86_64_16
, },
206 { BFD_RELOC_16_PCREL
, R_X86_64_PC16
, },
207 { BFD_RELOC_8
, R_X86_64_8
, },
208 { BFD_RELOC_8_PCREL
, R_X86_64_PC8
, },
209 { BFD_RELOC_X86_64_DTPMOD64
, R_X86_64_DTPMOD64
, },
210 { BFD_RELOC_X86_64_DTPOFF64
, R_X86_64_DTPOFF64
, },
211 { BFD_RELOC_X86_64_TPOFF64
, R_X86_64_TPOFF64
, },
212 { BFD_RELOC_X86_64_TLSGD
, R_X86_64_TLSGD
, },
213 { BFD_RELOC_X86_64_TLSLD
, R_X86_64_TLSLD
, },
214 { BFD_RELOC_X86_64_DTPOFF32
, R_X86_64_DTPOFF32
, },
215 { BFD_RELOC_X86_64_GOTTPOFF
, R_X86_64_GOTTPOFF
, },
216 { BFD_RELOC_X86_64_TPOFF32
, R_X86_64_TPOFF32
, },
217 { BFD_RELOC_64_PCREL
, R_X86_64_PC64
, },
218 { BFD_RELOC_X86_64_GOTOFF64
, R_X86_64_GOTOFF64
, },
219 { BFD_RELOC_X86_64_GOTPC32
, R_X86_64_GOTPC32
, },
220 { BFD_RELOC_X86_64_GOT64
, R_X86_64_GOT64
, },
221 { BFD_RELOC_X86_64_GOTPCREL64
,R_X86_64_GOTPCREL64
, },
222 { BFD_RELOC_X86_64_GOTPC64
, R_X86_64_GOTPC64
, },
223 { BFD_RELOC_X86_64_GOTPLT64
, R_X86_64_GOTPLT64
, },
224 { BFD_RELOC_X86_64_PLTOFF64
, R_X86_64_PLTOFF64
, },
225 { BFD_RELOC_X86_64_GOTPC32_TLSDESC
, R_X86_64_GOTPC32_TLSDESC
, },
226 { BFD_RELOC_X86_64_TLSDESC_CALL
, R_X86_64_TLSDESC_CALL
, },
227 { BFD_RELOC_X86_64_TLSDESC
, R_X86_64_TLSDESC
, },
228 { BFD_RELOC_X86_64_IRELATIVE
, R_X86_64_IRELATIVE
, },
229 { BFD_RELOC_VTABLE_INHERIT
, R_X86_64_GNU_VTINHERIT
, },
230 { BFD_RELOC_VTABLE_ENTRY
, R_X86_64_GNU_VTENTRY
, },
233 static reloc_howto_type
*
234 elf_x86_64_rtype_to_howto (bfd
*abfd
, unsigned r_type
)
238 if (r_type
< (unsigned int) R_X86_64_GNU_VTINHERIT
239 || r_type
>= (unsigned int) R_X86_64_max
)
241 if (r_type
>= (unsigned int) R_X86_64_standard
)
243 (*_bfd_error_handler
) (_("%B: invalid relocation type %d"),
245 r_type
= R_X86_64_NONE
;
250 i
= r_type
- (unsigned int) R_X86_64_vt_offset
;
251 BFD_ASSERT (x86_64_elf_howto_table
[i
].type
== r_type
);
252 return &x86_64_elf_howto_table
[i
];
255 /* Given a BFD reloc type, return a HOWTO structure. */
256 static reloc_howto_type
*
257 elf_x86_64_reloc_type_lookup (bfd
*abfd
,
258 bfd_reloc_code_real_type code
)
262 for (i
= 0; i
< sizeof (x86_64_reloc_map
) / sizeof (struct elf_reloc_map
);
265 if (x86_64_reloc_map
[i
].bfd_reloc_val
== code
)
266 return elf_x86_64_rtype_to_howto (abfd
,
267 x86_64_reloc_map
[i
].elf_reloc_val
);
272 static reloc_howto_type
*
273 elf_x86_64_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
279 i
< (sizeof (x86_64_elf_howto_table
)
280 / sizeof (x86_64_elf_howto_table
[0]));
282 if (x86_64_elf_howto_table
[i
].name
!= NULL
283 && strcasecmp (x86_64_elf_howto_table
[i
].name
, r_name
) == 0)
284 return &x86_64_elf_howto_table
[i
];
289 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
292 elf_x86_64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
293 Elf_Internal_Rela
*dst
)
297 r_type
= ELF32_R_TYPE (dst
->r_info
);
298 cache_ptr
->howto
= elf_x86_64_rtype_to_howto (abfd
, r_type
);
299 BFD_ASSERT (r_type
== cache_ptr
->howto
->type
);
302 /* Support for core dump NOTE sections. */
304 elf_x86_64_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
309 switch (note
->descsz
)
314 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
316 elf_tdata (abfd
)->core_signal
317 = bfd_get_16 (abfd
, note
->descdata
+ 12);
320 elf_tdata (abfd
)->core_lwpid
321 = bfd_get_32 (abfd
, note
->descdata
+ 32);
330 /* Make a ".reg/999" section. */
331 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
332 size
, note
->descpos
+ offset
);
336 elf_x86_64_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
338 switch (note
->descsz
)
343 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
344 elf_tdata (abfd
)->core_pid
345 = bfd_get_32 (abfd
, note
->descdata
+ 24);
346 elf_tdata (abfd
)->core_program
347 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
348 elf_tdata (abfd
)->core_command
349 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
352 /* Note that for some reason, a spurious space is tacked
353 onto the end of the args in some (at least one anyway)
354 implementations, so strip it off if it exists. */
357 char *command
= elf_tdata (abfd
)->core_command
;
358 int n
= strlen (command
);
360 if (0 < n
&& command
[n
- 1] == ' ')
361 command
[n
- 1] = '\0';
367 /* Functions for the x86-64 ELF linker. */
369 /* The name of the dynamic interpreter. This is put in the .interp
372 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
373 #define ELF32_DYNAMIC_INTERPRETER "/lib/ld32.so.1"
375 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
376 copying dynamic variables from a shared lib into an app's dynbss
377 section, and instead use a dynamic relocation to point into the
379 #define ELIMINATE_COPY_RELOCS 1
381 /* The size in bytes of an entry in the global offset table. */
383 #define GOT_ENTRY_SIZE 8
385 /* The size in bytes of an entry in the procedure linkage table. */
387 #define PLT_ENTRY_SIZE 16
389 /* The first entry in a procedure linkage table looks like this. See the
390 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
392 static const bfd_byte elf_x86_64_plt0_entry
[PLT_ENTRY_SIZE
] =
394 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
395 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
396 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
399 /* Subsequent entries in a procedure linkage table look like this. */
401 static const bfd_byte elf_x86_64_plt_entry
[PLT_ENTRY_SIZE
] =
403 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
404 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
405 0x68, /* pushq immediate */
406 0, 0, 0, 0, /* replaced with index into relocation table. */
407 0xe9, /* jmp relative */
408 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
411 /* x86-64 ELF linker hash entry. */
413 struct elf_x86_64_link_hash_entry
415 struct elf_link_hash_entry elf
;
417 /* Track dynamic relocs copied for this symbol. */
418 struct elf_dyn_relocs
*dyn_relocs
;
420 #define GOT_UNKNOWN 0
424 #define GOT_TLS_GDESC 4
425 #define GOT_TLS_GD_BOTH_P(type) \
426 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
427 #define GOT_TLS_GD_P(type) \
428 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
429 #define GOT_TLS_GDESC_P(type) \
430 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
431 #define GOT_TLS_GD_ANY_P(type) \
432 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
433 unsigned char tls_type
;
435 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
436 starting at the end of the jump table. */
440 #define elf_x86_64_hash_entry(ent) \
441 ((struct elf_x86_64_link_hash_entry *)(ent))
443 struct elf_x86_64_obj_tdata
445 struct elf_obj_tdata root
;
447 /* tls_type for each local got entry. */
448 char *local_got_tls_type
;
450 /* GOTPLT entries for TLS descriptors. */
451 bfd_vma
*local_tlsdesc_gotent
;
454 #define elf_x86_64_tdata(abfd) \
455 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
457 #define elf_x86_64_local_got_tls_type(abfd) \
458 (elf_x86_64_tdata (abfd)->local_got_tls_type)
460 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
461 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
463 #define is_x86_64_elf(bfd) \
464 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
465 && elf_tdata (bfd) != NULL \
466 && elf_object_id (bfd) == X86_64_ELF_DATA)
469 elf_x86_64_mkobject (bfd
*abfd
)
471 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_x86_64_obj_tdata
),
475 /* x86-64 ELF linker hash table. */
477 struct elf_x86_64_link_hash_table
479 struct elf_link_hash_table elf
;
481 /* Short-cuts to get to dynamic linker sections. */
487 bfd_signed_vma refcount
;
491 /* The amount of space used by the jump slots in the GOT. */
492 bfd_vma sgotplt_jump_table_size
;
494 /* Small local sym cache. */
495 struct sym_cache sym_cache
;
497 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
498 bfd_vma (*r_sym
) (bfd_vma
);
499 unsigned int pointer_r_type
;
500 const char *dynamic_interpreter
;
501 int dynamic_interpreter_size
;
503 /* _TLS_MODULE_BASE_ symbol. */
504 struct bfd_link_hash_entry
*tls_module_base
;
506 /* Used by local STT_GNU_IFUNC symbols. */
507 htab_t loc_hash_table
;
508 void * loc_hash_memory
;
510 /* The offset into splt of the PLT entry for the TLS descriptor
511 resolver. Special values are 0, if not necessary (or not found
512 to be necessary yet), and -1 if needed but not determined
515 /* The offset into sgot of the GOT entry used by the PLT entry
520 /* Get the x86-64 ELF linker hash table from a link_info structure. */
522 #define elf_x86_64_hash_table(p) \
523 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
524 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
526 #define elf_x86_64_compute_jump_table_size(htab) \
527 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
529 /* Create an entry in an x86-64 ELF linker hash table. */
531 static struct bfd_hash_entry
*
532 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
533 struct bfd_hash_table
*table
,
536 /* Allocate the structure if it has not already been allocated by a
540 entry
= (struct bfd_hash_entry
*)
541 bfd_hash_allocate (table
,
542 sizeof (struct elf_x86_64_link_hash_entry
));
547 /* Call the allocation method of the superclass. */
548 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
551 struct elf_x86_64_link_hash_entry
*eh
;
553 eh
= (struct elf_x86_64_link_hash_entry
*) entry
;
554 eh
->dyn_relocs
= NULL
;
555 eh
->tls_type
= GOT_UNKNOWN
;
556 eh
->tlsdesc_got
= (bfd_vma
) -1;
562 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
563 for local symbol so that we can handle local STT_GNU_IFUNC symbols
564 as global symbol. We reuse indx and dynstr_index for local symbol
565 hash since they aren't used by global symbols in this backend. */
568 elf_x86_64_local_htab_hash (const void *ptr
)
570 struct elf_link_hash_entry
*h
571 = (struct elf_link_hash_entry
*) ptr
;
572 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
575 /* Compare local hash entries. */
578 elf_x86_64_local_htab_eq (const void *ptr1
, const void *ptr2
)
580 struct elf_link_hash_entry
*h1
581 = (struct elf_link_hash_entry
*) ptr1
;
582 struct elf_link_hash_entry
*h2
583 = (struct elf_link_hash_entry
*) ptr2
;
585 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
588 /* Find and/or create a hash entry for local symbol. */
590 static struct elf_link_hash_entry
*
591 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table
*htab
,
592 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
595 struct elf_x86_64_link_hash_entry e
, *ret
;
596 asection
*sec
= abfd
->sections
;
597 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
598 htab
->r_sym (rel
->r_info
));
601 e
.elf
.indx
= sec
->id
;
602 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
603 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
604 create
? INSERT
: NO_INSERT
);
611 ret
= (struct elf_x86_64_link_hash_entry
*) *slot
;
615 ret
= (struct elf_x86_64_link_hash_entry
*)
616 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
617 sizeof (struct elf_x86_64_link_hash_entry
));
620 memset (ret
, 0, sizeof (*ret
));
621 ret
->elf
.indx
= sec
->id
;
622 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
623 ret
->elf
.dynindx
= -1;
629 /* Create an X86-64 ELF linker hash table. */
631 static struct bfd_link_hash_table
*
632 elf_x86_64_link_hash_table_create (bfd
*abfd
)
634 struct elf_x86_64_link_hash_table
*ret
;
635 bfd_size_type amt
= sizeof (struct elf_x86_64_link_hash_table
);
637 ret
= (struct elf_x86_64_link_hash_table
*) bfd_malloc (amt
);
641 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
642 elf_x86_64_link_hash_newfunc
,
643 sizeof (struct elf_x86_64_link_hash_entry
),
652 ret
->sym_cache
.abfd
= NULL
;
653 ret
->tlsdesc_plt
= 0;
654 ret
->tlsdesc_got
= 0;
655 ret
->tls_ld_got
.refcount
= 0;
656 ret
->sgotplt_jump_table_size
= 0;
657 ret
->tls_module_base
= NULL
;
661 ret
->r_info
= elf64_r_info
;
662 ret
->r_sym
= elf64_r_sym
;
663 ret
->pointer_r_type
= R_X86_64_64
;
664 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
665 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
669 ret
->r_info
= elf32_r_info
;
670 ret
->r_sym
= elf32_r_sym
;
671 ret
->pointer_r_type
= R_X86_64_32
;
672 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
673 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
676 ret
->loc_hash_table
= htab_try_create (1024,
677 elf_x86_64_local_htab_hash
,
678 elf_x86_64_local_htab_eq
,
680 ret
->loc_hash_memory
= objalloc_create ();
681 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
687 return &ret
->elf
.root
;
690 /* Destroy an X86-64 ELF linker hash table. */
693 elf_x86_64_link_hash_table_free (struct bfd_link_hash_table
*hash
)
695 struct elf_x86_64_link_hash_table
*htab
696 = (struct elf_x86_64_link_hash_table
*) hash
;
698 if (htab
->loc_hash_table
)
699 htab_delete (htab
->loc_hash_table
);
700 if (htab
->loc_hash_memory
)
701 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
702 _bfd_generic_link_hash_table_free (hash
);
705 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
706 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
710 elf_x86_64_create_dynamic_sections (bfd
*dynobj
,
711 struct bfd_link_info
*info
)
713 struct elf_x86_64_link_hash_table
*htab
;
715 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
718 htab
= elf_x86_64_hash_table (info
);
722 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
724 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rela.bss");
727 || (!info
->shared
&& !htab
->srelbss
))
733 /* Copy the extra info we tack onto an elf_link_hash_entry. */
736 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
737 struct elf_link_hash_entry
*dir
,
738 struct elf_link_hash_entry
*ind
)
740 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
742 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
743 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
745 if (eind
->dyn_relocs
!= NULL
)
747 if (edir
->dyn_relocs
!= NULL
)
749 struct elf_dyn_relocs
**pp
;
750 struct elf_dyn_relocs
*p
;
752 /* Add reloc counts against the indirect sym to the direct sym
753 list. Merge any entries against the same section. */
754 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
756 struct elf_dyn_relocs
*q
;
758 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
759 if (q
->sec
== p
->sec
)
761 q
->pc_count
+= p
->pc_count
;
762 q
->count
+= p
->count
;
769 *pp
= edir
->dyn_relocs
;
772 edir
->dyn_relocs
= eind
->dyn_relocs
;
773 eind
->dyn_relocs
= NULL
;
776 if (ind
->root
.type
== bfd_link_hash_indirect
777 && dir
->got
.refcount
<= 0)
779 edir
->tls_type
= eind
->tls_type
;
780 eind
->tls_type
= GOT_UNKNOWN
;
783 if (ELIMINATE_COPY_RELOCS
784 && ind
->root
.type
!= bfd_link_hash_indirect
785 && dir
->dynamic_adjusted
)
787 /* If called to transfer flags for a weakdef during processing
788 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
789 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
790 dir
->ref_dynamic
|= ind
->ref_dynamic
;
791 dir
->ref_regular
|= ind
->ref_regular
;
792 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
793 dir
->needs_plt
|= ind
->needs_plt
;
794 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
797 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
801 elf64_x86_64_elf_object_p (bfd
*abfd
)
803 /* Set the right machine number for an x86-64 elf64 file. */
804 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
822 /* Return TRUE if the TLS access code sequence support transition
826 elf_x86_64_check_tls_transition (bfd
*abfd
,
827 struct bfd_link_info
*info
,
830 Elf_Internal_Shdr
*symtab_hdr
,
831 struct elf_link_hash_entry
**sym_hashes
,
833 const Elf_Internal_Rela
*rel
,
834 const Elf_Internal_Rela
*relend
)
837 unsigned long r_symndx
;
838 struct elf_link_hash_entry
*h
;
840 struct elf_x86_64_link_hash_table
*htab
;
842 /* Get the section contents. */
843 if (contents
== NULL
)
845 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
846 contents
= elf_section_data (sec
)->this_hdr
.contents
;
849 /* FIXME: How to better handle error condition? */
850 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
853 /* Cache the section contents for elf_link_input_bfd. */
854 elf_section_data (sec
)->this_hdr
.contents
= contents
;
858 htab
= elf_x86_64_hash_table (info
);
859 offset
= rel
->r_offset
;
864 if ((rel
+ 1) >= relend
)
867 if (r_type
== R_X86_64_TLSGD
)
869 /* Check transition from GD access model. For 64bit, only
870 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
871 .word 0x6666; rex64; call __tls_get_addr
872 can transit to different access model. For 32bit, only
873 leaq foo@tlsgd(%rip), %rdi
874 .word 0x6666; rex64; call __tls_get_addr
875 can transit to different access model. */
877 static x86_64_opcode32 call
= { { 0x66, 0x66, 0x48, 0xe8 } };
878 if ((offset
+ 12) > sec
->size
879 || bfd_get_32 (abfd
, contents
+ offset
+ 4) != call
.i
)
884 static x86_64_opcode32 leaq
= { { 0x66, 0x48, 0x8d, 0x3d } };
886 || bfd_get_32 (abfd
, contents
+ offset
- 4) != leaq
.i
)
891 static x86_64_opcode16 lea
= { { 0x8d, 0x3d } };
893 || bfd_get_8 (abfd
, contents
+ offset
- 3) != 0x48
894 || bfd_get_16 (abfd
, contents
+ offset
- 2) != lea
.i
)
900 /* Check transition from LD access model. Only
901 leaq foo@tlsld(%rip), %rdi;
903 can transit to different access model. */
905 static x86_64_opcode32 ld
= { { 0x48, 0x8d, 0x3d, 0xe8 } };
908 if (offset
< 3 || (offset
+ 9) > sec
->size
)
911 op
.i
= bfd_get_32 (abfd
, contents
+ offset
- 3);
912 op
.c
[3] = bfd_get_8 (abfd
, contents
+ offset
+ 4);
917 r_symndx
= htab
->r_sym (rel
[1].r_info
);
918 if (r_symndx
< symtab_hdr
->sh_info
)
921 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
922 /* Use strncmp to check __tls_get_addr since __tls_get_addr
925 && h
->root
.root
.string
!= NULL
926 && (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
927 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
)
928 && (strncmp (h
->root
.root
.string
,
929 "__tls_get_addr", 14) == 0));
931 case R_X86_64_GOTTPOFF
:
932 /* Check transition from IE access model:
933 mov foo@gottpoff(%rip), %reg
934 add foo@gottpoff(%rip), %reg
937 /* Check REX prefix first. */
938 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
940 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
941 if (val
!= 0x48 && val
!= 0x4c)
943 /* X32 may have 0x44 REX prefix or no REX prefix. */
950 /* X32 may not have any REX prefix. */
953 if (offset
< 2 || (offset
+ 3) > sec
->size
)
957 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
958 if (val
!= 0x8b && val
!= 0x03)
961 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
962 return (val
& 0xc7) == 5;
964 case R_X86_64_GOTPC32_TLSDESC
:
965 /* Check transition from GDesc access model:
966 leaq x@tlsdesc(%rip), %rax
968 Make sure it's a leaq adding rip to a 32-bit offset
969 into any register, although it's probably almost always
972 if (offset
< 3 || (offset
+ 4) > sec
->size
)
975 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
976 if ((val
& 0xfb) != 0x48)
979 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
982 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
983 return (val
& 0xc7) == 0x05;
985 case R_X86_64_TLSDESC_CALL
:
986 /* Check transition from GDesc access model:
987 call *x@tlsdesc(%rax)
989 if (offset
+ 2 <= sec
->size
)
991 /* Make sure that it's a call *x@tlsdesc(%rax). */
992 static x86_64_opcode16 call
= { { 0xff, 0x10 } };
993 return bfd_get_16 (abfd
, contents
+ offset
) == call
.i
;
1003 /* Return TRUE if the TLS access transition is OK or no transition
1004 will be performed. Update R_TYPE if there is a transition. */
1007 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1008 asection
*sec
, bfd_byte
*contents
,
1009 Elf_Internal_Shdr
*symtab_hdr
,
1010 struct elf_link_hash_entry
**sym_hashes
,
1011 unsigned int *r_type
, int tls_type
,
1012 const Elf_Internal_Rela
*rel
,
1013 const Elf_Internal_Rela
*relend
,
1014 struct elf_link_hash_entry
*h
,
1015 unsigned long r_symndx
)
1017 unsigned int from_type
= *r_type
;
1018 unsigned int to_type
= from_type
;
1019 bfd_boolean check
= TRUE
;
1021 /* Skip TLS transition for functions. */
1023 && (h
->type
== STT_FUNC
1024 || h
->type
== STT_GNU_IFUNC
))
1029 case R_X86_64_TLSGD
:
1030 case R_X86_64_GOTPC32_TLSDESC
:
1031 case R_X86_64_TLSDESC_CALL
:
1032 case R_X86_64_GOTTPOFF
:
1033 if (info
->executable
)
1036 to_type
= R_X86_64_TPOFF32
;
1038 to_type
= R_X86_64_GOTTPOFF
;
1041 /* When we are called from elf_x86_64_relocate_section,
1042 CONTENTS isn't NULL and there may be additional transitions
1043 based on TLS_TYPE. */
1044 if (contents
!= NULL
)
1046 unsigned int new_to_type
= to_type
;
1048 if (info
->executable
1051 && tls_type
== GOT_TLS_IE
)
1052 new_to_type
= R_X86_64_TPOFF32
;
1054 if (to_type
== R_X86_64_TLSGD
1055 || to_type
== R_X86_64_GOTPC32_TLSDESC
1056 || to_type
== R_X86_64_TLSDESC_CALL
)
1058 if (tls_type
== GOT_TLS_IE
)
1059 new_to_type
= R_X86_64_GOTTPOFF
;
1062 /* We checked the transition before when we were called from
1063 elf_x86_64_check_relocs. We only want to check the new
1064 transition which hasn't been checked before. */
1065 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1066 to_type
= new_to_type
;
1071 case R_X86_64_TLSLD
:
1072 if (info
->executable
)
1073 to_type
= R_X86_64_TPOFF32
;
1080 /* Return TRUE if there is no transition. */
1081 if (from_type
== to_type
)
1084 /* Check if the transition can be performed. */
1086 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1087 symtab_hdr
, sym_hashes
,
1088 from_type
, rel
, relend
))
1090 reloc_howto_type
*from
, *to
;
1093 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1094 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1097 name
= h
->root
.root
.string
;
1100 struct elf_x86_64_link_hash_table
*htab
;
1102 htab
= elf_x86_64_hash_table (info
);
1107 Elf_Internal_Sym
*isym
;
1109 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1111 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1115 (*_bfd_error_handler
)
1116 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1117 "in section `%A' failed"),
1118 abfd
, sec
, from
->name
, to
->name
, name
,
1119 (unsigned long) rel
->r_offset
);
1120 bfd_set_error (bfd_error_bad_value
);
1128 /* Look through the relocs for a section during the first phase, and
1129 calculate needed space in the global offset table, procedure
1130 linkage table, and dynamic reloc sections. */
1133 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1135 const Elf_Internal_Rela
*relocs
)
1137 struct elf_x86_64_link_hash_table
*htab
;
1138 Elf_Internal_Shdr
*symtab_hdr
;
1139 struct elf_link_hash_entry
**sym_hashes
;
1140 const Elf_Internal_Rela
*rel
;
1141 const Elf_Internal_Rela
*rel_end
;
1144 if (info
->relocatable
)
1147 BFD_ASSERT (is_x86_64_elf (abfd
));
1149 htab
= elf_x86_64_hash_table (info
);
1153 symtab_hdr
= &elf_symtab_hdr (abfd
);
1154 sym_hashes
= elf_sym_hashes (abfd
);
1158 rel_end
= relocs
+ sec
->reloc_count
;
1159 for (rel
= relocs
; rel
< rel_end
; rel
++)
1161 unsigned int r_type
;
1162 unsigned long r_symndx
;
1163 struct elf_link_hash_entry
*h
;
1164 Elf_Internal_Sym
*isym
;
1167 r_symndx
= htab
->r_sym (rel
->r_info
);
1168 r_type
= ELF32_R_TYPE (rel
->r_info
);
1170 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1172 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1177 if (r_symndx
< symtab_hdr
->sh_info
)
1179 /* A local symbol. */
1180 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1185 /* Check relocation against local STT_GNU_IFUNC symbol. */
1186 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1188 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
1193 /* Fake a STT_GNU_IFUNC symbol. */
1194 h
->type
= STT_GNU_IFUNC
;
1197 h
->forced_local
= 1;
1198 h
->root
.type
= bfd_link_hash_defined
;
1206 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1207 while (h
->root
.type
== bfd_link_hash_indirect
1208 || h
->root
.type
== bfd_link_hash_warning
)
1209 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1212 /* Check invalid x32 relocations. */
1213 if (!ABI_64_P (abfd
))
1220 /* Allow R_X86_64_64 relocations in SEC_DEBUGGING sections
1221 when building shared libraries. */
1223 && !info
->executable
1224 && (sec
->flags
& SEC_DEBUGGING
) != 0)
1227 case R_X86_64_DTPOFF64
:
1228 case R_X86_64_TPOFF64
:
1230 case R_X86_64_GOTOFF64
:
1231 case R_X86_64_GOT64
:
1232 case R_X86_64_GOTPCREL64
:
1233 case R_X86_64_GOTPC64
:
1234 case R_X86_64_GOTPLT64
:
1235 case R_X86_64_PLTOFF64
:
1238 name
= h
->root
.root
.string
;
1240 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1242 (*_bfd_error_handler
)
1243 (_("%B: relocation %s against symbol `%s' isn't "
1244 "supported in x32 mode"), abfd
,
1245 x86_64_elf_howto_table
[r_type
].name
, name
);
1246 bfd_set_error (bfd_error_bad_value
);
1254 /* Create the ifunc sections for static executables. If we
1255 never see an indirect function symbol nor we are building
1256 a static executable, those sections will be empty and
1257 won't appear in output. */
1268 case R_X86_64_PLT32
:
1269 case R_X86_64_GOTPCREL
:
1270 case R_X86_64_GOTPCREL64
:
1271 if (htab
->elf
.dynobj
== NULL
)
1272 htab
->elf
.dynobj
= abfd
;
1273 if (!_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
, info
))
1278 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
1279 it here if it is defined in a non-shared object. */
1280 if (h
->type
== STT_GNU_IFUNC
1283 /* It is referenced by a non-shared object. */
1287 /* STT_GNU_IFUNC symbol must go through PLT. */
1288 h
->plt
.refcount
+= 1;
1290 /* STT_GNU_IFUNC needs dynamic sections. */
1291 if (htab
->elf
.dynobj
== NULL
)
1292 htab
->elf
.dynobj
= abfd
;
1297 if (h
->root
.root
.string
)
1298 name
= h
->root
.root
.string
;
1300 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1302 (*_bfd_error_handler
)
1303 (_("%B: relocation %s against STT_GNU_IFUNC "
1304 "symbol `%s' isn't handled by %s"), abfd
,
1305 x86_64_elf_howto_table
[r_type
].name
,
1306 name
, __FUNCTION__
);
1307 bfd_set_error (bfd_error_bad_value
);
1311 if (ABI_64_P (abfd
))
1315 h
->pointer_equality_needed
= 1;
1318 /* We must copy these reloc types into the output
1319 file. Create a reloc section in dynobj and
1320 make room for this reloc. */
1321 sreloc
= _bfd_elf_create_ifunc_dyn_reloc
1322 (abfd
, info
, sec
, sreloc
,
1323 &((struct elf_x86_64_link_hash_entry
*) h
)->dyn_relocs
);
1334 if (r_type
!= R_X86_64_PC32
1335 && r_type
!= R_X86_64_PC64
)
1336 h
->pointer_equality_needed
= 1;
1339 case R_X86_64_PLT32
:
1342 case R_X86_64_GOTPCREL
:
1343 case R_X86_64_GOTPCREL64
:
1344 h
->got
.refcount
+= 1;
1345 if (htab
->elf
.sgot
== NULL
1346 && !_bfd_elf_create_got_section (htab
->elf
.dynobj
,
1356 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
1357 symtab_hdr
, sym_hashes
,
1358 &r_type
, GOT_UNKNOWN
,
1359 rel
, rel_end
, h
, r_symndx
))
1364 case R_X86_64_TLSLD
:
1365 htab
->tls_ld_got
.refcount
+= 1;
1368 case R_X86_64_TPOFF32
:
1369 if (!info
->executable
&& ABI_64_P (abfd
))
1372 name
= h
->root
.root
.string
;
1374 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1376 (*_bfd_error_handler
)
1377 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1379 x86_64_elf_howto_table
[r_type
].name
, name
);
1380 bfd_set_error (bfd_error_bad_value
);
1385 case R_X86_64_GOTTPOFF
:
1386 if (!info
->executable
)
1387 info
->flags
|= DF_STATIC_TLS
;
1390 case R_X86_64_GOT32
:
1391 case R_X86_64_GOTPCREL
:
1392 case R_X86_64_TLSGD
:
1393 case R_X86_64_GOT64
:
1394 case R_X86_64_GOTPCREL64
:
1395 case R_X86_64_GOTPLT64
:
1396 case R_X86_64_GOTPC32_TLSDESC
:
1397 case R_X86_64_TLSDESC_CALL
:
1398 /* This symbol requires a global offset table entry. */
1400 int tls_type
, old_tls_type
;
1404 default: tls_type
= GOT_NORMAL
; break;
1405 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
1406 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
1407 case R_X86_64_GOTPC32_TLSDESC
:
1408 case R_X86_64_TLSDESC_CALL
:
1409 tls_type
= GOT_TLS_GDESC
; break;
1414 if (r_type
== R_X86_64_GOTPLT64
)
1416 /* This relocation indicates that we also need
1417 a PLT entry, as this is a function. We don't need
1418 a PLT entry for local symbols. */
1420 h
->plt
.refcount
+= 1;
1422 h
->got
.refcount
+= 1;
1423 old_tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
1427 bfd_signed_vma
*local_got_refcounts
;
1429 /* This is a global offset table entry for a local symbol. */
1430 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1431 if (local_got_refcounts
== NULL
)
1435 size
= symtab_hdr
->sh_info
;
1436 size
*= sizeof (bfd_signed_vma
)
1437 + sizeof (bfd_vma
) + sizeof (char);
1438 local_got_refcounts
= ((bfd_signed_vma
*)
1439 bfd_zalloc (abfd
, size
));
1440 if (local_got_refcounts
== NULL
)
1442 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1443 elf_x86_64_local_tlsdesc_gotent (abfd
)
1444 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1445 elf_x86_64_local_got_tls_type (abfd
)
1446 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1448 local_got_refcounts
[r_symndx
] += 1;
1450 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
1453 /* If a TLS symbol is accessed using IE at least once,
1454 there is no point to use dynamic model for it. */
1455 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1456 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1457 || tls_type
!= GOT_TLS_IE
))
1459 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
1460 tls_type
= old_tls_type
;
1461 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1462 && GOT_TLS_GD_ANY_P (tls_type
))
1463 tls_type
|= old_tls_type
;
1467 name
= h
->root
.root
.string
;
1469 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
1471 (*_bfd_error_handler
)
1472 (_("%B: '%s' accessed both as normal and thread local symbol"),
1478 if (old_tls_type
!= tls_type
)
1481 elf_x86_64_hash_entry (h
)->tls_type
= tls_type
;
1483 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1488 case R_X86_64_GOTOFF64
:
1489 case R_X86_64_GOTPC32
:
1490 case R_X86_64_GOTPC64
:
1492 if (htab
->elf
.sgot
== NULL
)
1494 if (htab
->elf
.dynobj
== NULL
)
1495 htab
->elf
.dynobj
= abfd
;
1496 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
1502 case R_X86_64_PLT32
:
1503 /* This symbol requires a procedure linkage table entry. We
1504 actually build the entry in adjust_dynamic_symbol,
1505 because this might be a case of linking PIC code which is
1506 never referenced by a dynamic object, in which case we
1507 don't need to generate a procedure linkage table entry
1510 /* If this is a local symbol, we resolve it directly without
1511 creating a procedure linkage table entry. */
1516 h
->plt
.refcount
+= 1;
1519 case R_X86_64_PLTOFF64
:
1520 /* This tries to form the 'address' of a function relative
1521 to GOT. For global symbols we need a PLT entry. */
1525 h
->plt
.refcount
+= 1;
1530 if (!ABI_64_P (abfd
))
1535 /* Let's help debug shared library creation. These relocs
1536 cannot be used in shared libs. Don't error out for
1537 sections we don't care about, such as debug sections or
1538 non-constant sections. */
1540 && (sec
->flags
& SEC_ALLOC
) != 0
1541 && (sec
->flags
& SEC_READONLY
) != 0)
1544 name
= h
->root
.root
.string
;
1546 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1547 (*_bfd_error_handler
)
1548 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1549 abfd
, x86_64_elf_howto_table
[r_type
].name
, name
);
1550 bfd_set_error (bfd_error_bad_value
);
1561 if (h
!= NULL
&& info
->executable
)
1563 /* If this reloc is in a read-only section, we might
1564 need a copy reloc. We can't check reliably at this
1565 stage whether the section is read-only, as input
1566 sections have not yet been mapped to output sections.
1567 Tentatively set the flag for now, and correct in
1568 adjust_dynamic_symbol. */
1571 /* We may need a .plt entry if the function this reloc
1572 refers to is in a shared lib. */
1573 h
->plt
.refcount
+= 1;
1574 if (r_type
!= R_X86_64_PC32
&& r_type
!= R_X86_64_PC64
)
1575 h
->pointer_equality_needed
= 1;
1578 /* If we are creating a shared library, and this is a reloc
1579 against a global symbol, or a non PC relative reloc
1580 against a local symbol, then we need to copy the reloc
1581 into the shared library. However, if we are linking with
1582 -Bsymbolic, we do not need to copy a reloc against a
1583 global symbol which is defined in an object we are
1584 including in the link (i.e., DEF_REGULAR is set). At
1585 this point we have not seen all the input files, so it is
1586 possible that DEF_REGULAR is not set now but will be set
1587 later (it is never cleared). In case of a weak definition,
1588 DEF_REGULAR may be cleared later by a strong definition in
1589 a shared library. We account for that possibility below by
1590 storing information in the relocs_copied field of the hash
1591 table entry. A similar situation occurs when creating
1592 shared libraries and symbol visibility changes render the
1595 If on the other hand, we are creating an executable, we
1596 may need to keep relocations for symbols satisfied by a
1597 dynamic library if we manage to avoid copy relocs for the
1600 && (sec
->flags
& SEC_ALLOC
) != 0
1601 && (! IS_X86_64_PCREL_TYPE (r_type
)
1603 && (! SYMBOLIC_BIND (info
, h
)
1604 || h
->root
.type
== bfd_link_hash_defweak
1605 || !h
->def_regular
))))
1606 || (ELIMINATE_COPY_RELOCS
1608 && (sec
->flags
& SEC_ALLOC
) != 0
1610 && (h
->root
.type
== bfd_link_hash_defweak
1611 || !h
->def_regular
)))
1613 struct elf_dyn_relocs
*p
;
1614 struct elf_dyn_relocs
**head
;
1616 /* We must copy these reloc types into the output file.
1617 Create a reloc section in dynobj and make room for
1621 if (htab
->elf
.dynobj
== NULL
)
1622 htab
->elf
.dynobj
= abfd
;
1624 sreloc
= _bfd_elf_make_dynamic_reloc_section
1625 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
1626 abfd
, /*rela?*/ TRUE
);
1632 /* If this is a global symbol, we count the number of
1633 relocations we need for this symbol. */
1636 head
= &((struct elf_x86_64_link_hash_entry
*) h
)->dyn_relocs
;
1640 /* Track dynamic relocs needed for local syms too.
1641 We really need local syms available to do this
1646 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1651 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1655 /* Beware of type punned pointers vs strict aliasing
1657 vpp
= &(elf_section_data (s
)->local_dynrel
);
1658 head
= (struct elf_dyn_relocs
**)vpp
;
1662 if (p
== NULL
|| p
->sec
!= sec
)
1664 bfd_size_type amt
= sizeof *p
;
1666 p
= ((struct elf_dyn_relocs
*)
1667 bfd_alloc (htab
->elf
.dynobj
, amt
));
1678 if (IS_X86_64_PCREL_TYPE (r_type
))
1683 /* This relocation describes the C++ object vtable hierarchy.
1684 Reconstruct it for later use during GC. */
1685 case R_X86_64_GNU_VTINHERIT
:
1686 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1690 /* This relocation describes which C++ vtable entries are actually
1691 used. Record for later use during GC. */
1692 case R_X86_64_GNU_VTENTRY
:
1693 BFD_ASSERT (h
!= NULL
);
1695 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1707 /* Return the section that should be marked against GC for a given
1711 elf_x86_64_gc_mark_hook (asection
*sec
,
1712 struct bfd_link_info
*info
,
1713 Elf_Internal_Rela
*rel
,
1714 struct elf_link_hash_entry
*h
,
1715 Elf_Internal_Sym
*sym
)
1718 switch (ELF32_R_TYPE (rel
->r_info
))
1720 case R_X86_64_GNU_VTINHERIT
:
1721 case R_X86_64_GNU_VTENTRY
:
1725 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1728 /* Update the got entry reference counts for the section being removed. */
1731 elf_x86_64_gc_sweep_hook (bfd
*abfd
, struct bfd_link_info
*info
,
1733 const Elf_Internal_Rela
*relocs
)
1735 struct elf_x86_64_link_hash_table
*htab
;
1736 Elf_Internal_Shdr
*symtab_hdr
;
1737 struct elf_link_hash_entry
**sym_hashes
;
1738 bfd_signed_vma
*local_got_refcounts
;
1739 const Elf_Internal_Rela
*rel
, *relend
;
1741 if (info
->relocatable
)
1744 htab
= elf_x86_64_hash_table (info
);
1748 elf_section_data (sec
)->local_dynrel
= NULL
;
1750 symtab_hdr
= &elf_symtab_hdr (abfd
);
1751 sym_hashes
= elf_sym_hashes (abfd
);
1752 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1754 htab
= elf_x86_64_hash_table (info
);
1755 relend
= relocs
+ sec
->reloc_count
;
1756 for (rel
= relocs
; rel
< relend
; rel
++)
1758 unsigned long r_symndx
;
1759 unsigned int r_type
;
1760 struct elf_link_hash_entry
*h
= NULL
;
1762 r_symndx
= htab
->r_sym (rel
->r_info
);
1763 if (r_symndx
>= symtab_hdr
->sh_info
)
1765 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1766 while (h
->root
.type
== bfd_link_hash_indirect
1767 || h
->root
.type
== bfd_link_hash_warning
)
1768 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1772 /* A local symbol. */
1773 Elf_Internal_Sym
*isym
;
1775 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1778 /* Check relocation against local STT_GNU_IFUNC symbol. */
1780 && ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1782 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
, FALSE
);
1790 struct elf_x86_64_link_hash_entry
*eh
;
1791 struct elf_dyn_relocs
**pp
;
1792 struct elf_dyn_relocs
*p
;
1794 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
1796 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1799 /* Everything must go for SEC. */
1805 r_type
= ELF32_R_TYPE (rel
->r_info
);
1806 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
1807 symtab_hdr
, sym_hashes
,
1808 &r_type
, GOT_UNKNOWN
,
1809 rel
, relend
, h
, r_symndx
))
1814 case R_X86_64_TLSLD
:
1815 if (htab
->tls_ld_got
.refcount
> 0)
1816 htab
->tls_ld_got
.refcount
-= 1;
1819 case R_X86_64_TLSGD
:
1820 case R_X86_64_GOTPC32_TLSDESC
:
1821 case R_X86_64_TLSDESC_CALL
:
1822 case R_X86_64_GOTTPOFF
:
1823 case R_X86_64_GOT32
:
1824 case R_X86_64_GOTPCREL
:
1825 case R_X86_64_GOT64
:
1826 case R_X86_64_GOTPCREL64
:
1827 case R_X86_64_GOTPLT64
:
1830 if (r_type
== R_X86_64_GOTPLT64
&& h
->plt
.refcount
> 0)
1831 h
->plt
.refcount
-= 1;
1832 if (h
->got
.refcount
> 0)
1833 h
->got
.refcount
-= 1;
1834 if (h
->type
== STT_GNU_IFUNC
)
1836 if (h
->plt
.refcount
> 0)
1837 h
->plt
.refcount
-= 1;
1840 else if (local_got_refcounts
!= NULL
)
1842 if (local_got_refcounts
[r_symndx
] > 0)
1843 local_got_refcounts
[r_symndx
] -= 1;
1857 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
1861 case R_X86_64_PLT32
:
1862 case R_X86_64_PLTOFF64
:
1865 if (h
->plt
.refcount
> 0)
1866 h
->plt
.refcount
-= 1;
1878 /* Adjust a symbol defined by a dynamic object and referenced by a
1879 regular object. The current definition is in some section of the
1880 dynamic object, but we're not including those sections. We have to
1881 change the definition to something the rest of the link can
1885 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1886 struct elf_link_hash_entry
*h
)
1888 struct elf_x86_64_link_hash_table
*htab
;
1891 /* STT_GNU_IFUNC symbol must go through PLT. */
1892 if (h
->type
== STT_GNU_IFUNC
)
1894 if (h
->plt
.refcount
<= 0)
1896 h
->plt
.offset
= (bfd_vma
) -1;
1902 /* If this is a function, put it in the procedure linkage table. We
1903 will fill in the contents of the procedure linkage table later,
1904 when we know the address of the .got section. */
1905 if (h
->type
== STT_FUNC
1908 if (h
->plt
.refcount
<= 0
1909 || SYMBOL_CALLS_LOCAL (info
, h
)
1910 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1911 && h
->root
.type
== bfd_link_hash_undefweak
))
1913 /* This case can occur if we saw a PLT32 reloc in an input
1914 file, but the symbol was never referred to by a dynamic
1915 object, or if all references were garbage collected. In
1916 such a case, we don't actually need to build a procedure
1917 linkage table, and we can just do a PC32 reloc instead. */
1918 h
->plt
.offset
= (bfd_vma
) -1;
1925 /* It's possible that we incorrectly decided a .plt reloc was
1926 needed for an R_X86_64_PC32 reloc to a non-function sym in
1927 check_relocs. We can't decide accurately between function and
1928 non-function syms in check-relocs; Objects loaded later in
1929 the link may change h->type. So fix it now. */
1930 h
->plt
.offset
= (bfd_vma
) -1;
1932 /* If this is a weak symbol, and there is a real definition, the
1933 processor independent code will have arranged for us to see the
1934 real definition first, and we can just use the same value. */
1935 if (h
->u
.weakdef
!= NULL
)
1937 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
1938 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
1939 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
1940 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
1941 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
1942 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
1946 /* This is a reference to a symbol defined by a dynamic object which
1947 is not a function. */
1949 /* If we are creating a shared library, we must presume that the
1950 only references to the symbol are via the global offset table.
1951 For such cases we need not do anything here; the relocations will
1952 be handled correctly by relocate_section. */
1956 /* If there are no references to this symbol that do not use the
1957 GOT, we don't need to generate a copy reloc. */
1958 if (!h
->non_got_ref
)
1961 /* If -z nocopyreloc was given, we won't generate them either. */
1962 if (info
->nocopyreloc
)
1968 if (ELIMINATE_COPY_RELOCS
)
1970 struct elf_x86_64_link_hash_entry
* eh
;
1971 struct elf_dyn_relocs
*p
;
1973 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
1974 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1976 s
= p
->sec
->output_section
;
1977 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1981 /* If we didn't find any dynamic relocs in read-only sections, then
1982 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1992 (*_bfd_error_handler
) (_("dynamic variable `%s' is zero size"),
1993 h
->root
.root
.string
);
1997 /* We must allocate the symbol in our .dynbss section, which will
1998 become part of the .bss section of the executable. There will be
1999 an entry for this symbol in the .dynsym section. The dynamic
2000 object will contain position independent code, so all references
2001 from the dynamic object to this symbol will go through the global
2002 offset table. The dynamic linker will use the .dynsym entry to
2003 determine the address it must put in the global offset table, so
2004 both the dynamic object and the regular object will refer to the
2005 same memory location for the variable. */
2007 htab
= elf_x86_64_hash_table (info
);
2011 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2012 to copy the initial value out of the dynamic object and into the
2013 runtime process image. */
2014 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
2016 const struct elf_backend_data
*bed
;
2017 bed
= get_elf_backend_data (info
->output_bfd
);
2018 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
2024 return _bfd_elf_adjust_dynamic_copy (h
, s
);
2027 /* Allocate space in .plt, .got and associated reloc sections for
2031 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2033 struct bfd_link_info
*info
;
2034 struct elf_x86_64_link_hash_table
*htab
;
2035 struct elf_x86_64_link_hash_entry
*eh
;
2036 struct elf_dyn_relocs
*p
;
2037 const struct elf_backend_data
*bed
;
2039 if (h
->root
.type
== bfd_link_hash_indirect
)
2042 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2044 info
= (struct bfd_link_info
*) inf
;
2045 htab
= elf_x86_64_hash_table (info
);
2048 bed
= get_elf_backend_data (info
->output_bfd
);
2050 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2051 here if it is defined and referenced in a non-shared object. */
2052 if (h
->type
== STT_GNU_IFUNC
2054 return _bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
2058 else if (htab
->elf
.dynamic_sections_created
2059 && h
->plt
.refcount
> 0)
2061 /* Make sure this symbol is output as a dynamic symbol.
2062 Undefined weak syms won't yet be marked as dynamic. */
2063 if (h
->dynindx
== -1
2064 && !h
->forced_local
)
2066 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2071 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2073 asection
*s
= htab
->elf
.splt
;
2075 /* If this is the first .plt entry, make room for the special
2078 s
->size
+= PLT_ENTRY_SIZE
;
2080 h
->plt
.offset
= s
->size
;
2082 /* If this symbol is not defined in a regular file, and we are
2083 not generating a shared library, then set the symbol to this
2084 location in the .plt. This is required to make function
2085 pointers compare as equal between the normal executable and
2086 the shared library. */
2090 h
->root
.u
.def
.section
= s
;
2091 h
->root
.u
.def
.value
= h
->plt
.offset
;
2094 /* Make room for this entry. */
2095 s
->size
+= PLT_ENTRY_SIZE
;
2097 /* We also need to make an entry in the .got.plt section, which
2098 will be placed in the .got section by the linker script. */
2099 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
2101 /* We also need to make an entry in the .rela.plt section. */
2102 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2103 htab
->elf
.srelplt
->reloc_count
++;
2107 h
->plt
.offset
= (bfd_vma
) -1;
2113 h
->plt
.offset
= (bfd_vma
) -1;
2117 eh
->tlsdesc_got
= (bfd_vma
) -1;
2119 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2120 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2121 if (h
->got
.refcount
> 0
2124 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
2126 h
->got
.offset
= (bfd_vma
) -1;
2128 else if (h
->got
.refcount
> 0)
2132 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
2134 /* Make sure this symbol is output as a dynamic symbol.
2135 Undefined weak syms won't yet be marked as dynamic. */
2136 if (h
->dynindx
== -1
2137 && !h
->forced_local
)
2139 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2143 if (GOT_TLS_GDESC_P (tls_type
))
2145 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2146 - elf_x86_64_compute_jump_table_size (htab
);
2147 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2148 h
->got
.offset
= (bfd_vma
) -2;
2150 if (! GOT_TLS_GDESC_P (tls_type
)
2151 || GOT_TLS_GD_P (tls_type
))
2154 h
->got
.offset
= s
->size
;
2155 s
->size
+= GOT_ENTRY_SIZE
;
2156 if (GOT_TLS_GD_P (tls_type
))
2157 s
->size
+= GOT_ENTRY_SIZE
;
2159 dyn
= htab
->elf
.dynamic_sections_created
;
2160 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2162 R_X86_64_GOTTPOFF needs one dynamic relocation. */
2163 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2164 || tls_type
== GOT_TLS_IE
)
2165 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2166 else if (GOT_TLS_GD_P (tls_type
))
2167 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
2168 else if (! GOT_TLS_GDESC_P (tls_type
)
2169 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2170 || h
->root
.type
!= bfd_link_hash_undefweak
)
2172 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2173 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2174 if (GOT_TLS_GDESC_P (tls_type
))
2176 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2177 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2181 h
->got
.offset
= (bfd_vma
) -1;
2183 if (eh
->dyn_relocs
== NULL
)
2186 /* In the shared -Bsymbolic case, discard space allocated for
2187 dynamic pc-relative relocs against symbols which turn out to be
2188 defined in regular objects. For the normal shared case, discard
2189 space for pc-relative relocs that have become local due to symbol
2190 visibility changes. */
2194 /* Relocs that use pc_count are those that appear on a call
2195 insn, or certain REL relocs that can generated via assembly.
2196 We want calls to protected symbols to resolve directly to the
2197 function rather than going via the plt. If people want
2198 function pointer comparisons to work as expected then they
2199 should avoid writing weird assembly. */
2200 if (SYMBOL_CALLS_LOCAL (info
, h
))
2202 struct elf_dyn_relocs
**pp
;
2204 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2206 p
->count
-= p
->pc_count
;
2215 /* Also discard relocs on undefined weak syms with non-default
2217 if (eh
->dyn_relocs
!= NULL
2218 && h
->root
.type
== bfd_link_hash_undefweak
)
2220 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2221 eh
->dyn_relocs
= NULL
;
2223 /* Make sure undefined weak symbols are output as a dynamic
2225 else if (h
->dynindx
== -1
2226 && ! h
->forced_local
2227 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2232 else if (ELIMINATE_COPY_RELOCS
)
2234 /* For the non-shared case, discard space for relocs against
2235 symbols which turn out to need copy relocs or are not
2241 || (htab
->elf
.dynamic_sections_created
2242 && (h
->root
.type
== bfd_link_hash_undefweak
2243 || h
->root
.type
== bfd_link_hash_undefined
))))
2245 /* Make sure this symbol is output as a dynamic symbol.
2246 Undefined weak syms won't yet be marked as dynamic. */
2247 if (h
->dynindx
== -1
2248 && ! h
->forced_local
2249 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2252 /* If that succeeded, we know we'll be keeping all the
2254 if (h
->dynindx
!= -1)
2258 eh
->dyn_relocs
= NULL
;
2263 /* Finally, allocate space. */
2264 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2268 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2270 BFD_ASSERT (sreloc
!= NULL
);
2272 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2278 /* Allocate space in .plt, .got and associated reloc sections for
2279 local dynamic relocs. */
2282 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
2284 struct elf_link_hash_entry
*h
2285 = (struct elf_link_hash_entry
*) *slot
;
2287 if (h
->type
!= STT_GNU_IFUNC
2291 || h
->root
.type
!= bfd_link_hash_defined
)
2294 return elf_x86_64_allocate_dynrelocs (h
, inf
);
2297 /* Find any dynamic relocs that apply to read-only sections. */
2300 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
2303 struct elf_x86_64_link_hash_entry
*eh
;
2304 struct elf_dyn_relocs
*p
;
2306 /* Skip local IFUNC symbols. */
2307 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
2310 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2311 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2313 asection
*s
= p
->sec
->output_section
;
2315 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2317 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2319 info
->flags
|= DF_TEXTREL
;
2321 if (info
->warn_shared_textrel
&& info
->shared
)
2322 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2323 p
->sec
->owner
, h
->root
.root
.string
,
2326 /* Not an error, just cut short the traversal. */
2333 /* Set the sizes of the dynamic sections. */
2336 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
2337 struct bfd_link_info
*info
)
2339 struct elf_x86_64_link_hash_table
*htab
;
2344 const struct elf_backend_data
*bed
;
2346 htab
= elf_x86_64_hash_table (info
);
2349 bed
= get_elf_backend_data (output_bfd
);
2351 dynobj
= htab
->elf
.dynobj
;
2355 if (htab
->elf
.dynamic_sections_created
)
2357 /* Set the contents of the .interp section to the interpreter. */
2358 if (info
->executable
)
2360 s
= bfd_get_section_by_name (dynobj
, ".interp");
2363 s
->size
= htab
->dynamic_interpreter_size
;
2364 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
2368 /* Set up .got offsets for local syms, and space for local dynamic
2370 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
2372 bfd_signed_vma
*local_got
;
2373 bfd_signed_vma
*end_local_got
;
2374 char *local_tls_type
;
2375 bfd_vma
*local_tlsdesc_gotent
;
2376 bfd_size_type locsymcount
;
2377 Elf_Internal_Shdr
*symtab_hdr
;
2380 if (! is_x86_64_elf (ibfd
))
2383 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2385 struct elf_dyn_relocs
*p
;
2387 for (p
= (struct elf_dyn_relocs
*)
2388 (elf_section_data (s
)->local_dynrel
);
2392 if (!bfd_is_abs_section (p
->sec
)
2393 && bfd_is_abs_section (p
->sec
->output_section
))
2395 /* Input section has been discarded, either because
2396 it is a copy of a linkonce section or due to
2397 linker script /DISCARD/, so we'll be discarding
2400 else if (p
->count
!= 0)
2402 srel
= elf_section_data (p
->sec
)->sreloc
;
2403 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2404 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
2405 && (info
->flags
& DF_TEXTREL
) == 0)
2407 info
->flags
|= DF_TEXTREL
;
2408 if (info
->warn_shared_textrel
&& info
->shared
)
2409 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
2410 p
->sec
->owner
, p
->sec
);
2416 local_got
= elf_local_got_refcounts (ibfd
);
2420 symtab_hdr
= &elf_symtab_hdr (ibfd
);
2421 locsymcount
= symtab_hdr
->sh_info
;
2422 end_local_got
= local_got
+ locsymcount
;
2423 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
2424 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
2426 srel
= htab
->elf
.srelgot
;
2427 for (; local_got
< end_local_got
;
2428 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
2430 *local_tlsdesc_gotent
= (bfd_vma
) -1;
2433 if (GOT_TLS_GDESC_P (*local_tls_type
))
2435 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
2436 - elf_x86_64_compute_jump_table_size (htab
);
2437 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2438 *local_got
= (bfd_vma
) -2;
2440 if (! GOT_TLS_GDESC_P (*local_tls_type
)
2441 || GOT_TLS_GD_P (*local_tls_type
))
2443 *local_got
= s
->size
;
2444 s
->size
+= GOT_ENTRY_SIZE
;
2445 if (GOT_TLS_GD_P (*local_tls_type
))
2446 s
->size
+= GOT_ENTRY_SIZE
;
2449 || GOT_TLS_GD_ANY_P (*local_tls_type
)
2450 || *local_tls_type
== GOT_TLS_IE
)
2452 if (GOT_TLS_GDESC_P (*local_tls_type
))
2454 htab
->elf
.srelplt
->size
2455 += bed
->s
->sizeof_rela
;
2456 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2458 if (! GOT_TLS_GDESC_P (*local_tls_type
)
2459 || GOT_TLS_GD_P (*local_tls_type
))
2460 srel
->size
+= bed
->s
->sizeof_rela
;
2464 *local_got
= (bfd_vma
) -1;
2468 if (htab
->tls_ld_got
.refcount
> 0)
2470 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
2472 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
2473 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
2474 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2477 htab
->tls_ld_got
.offset
= -1;
2479 /* Allocate global sym .plt and .got entries, and space for global
2480 sym dynamic relocs. */
2481 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
2484 /* Allocate .plt and .got entries, and space for local symbols. */
2485 htab_traverse (htab
->loc_hash_table
,
2486 elf_x86_64_allocate_local_dynrelocs
,
2489 /* For every jump slot reserved in the sgotplt, reloc_count is
2490 incremented. However, when we reserve space for TLS descriptors,
2491 it's not incremented, so in order to compute the space reserved
2492 for them, it suffices to multiply the reloc count by the jump
2494 if (htab
->elf
.srelplt
)
2495 htab
->sgotplt_jump_table_size
2496 = elf_x86_64_compute_jump_table_size (htab
);
2498 if (htab
->tlsdesc_plt
)
2500 /* If we're not using lazy TLS relocations, don't generate the
2501 PLT and GOT entries they require. */
2502 if ((info
->flags
& DF_BIND_NOW
))
2503 htab
->tlsdesc_plt
= 0;
2506 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
2507 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
2508 /* Reserve room for the initial entry.
2509 FIXME: we could probably do away with it in this case. */
2510 if (htab
->elf
.splt
->size
== 0)
2511 htab
->elf
.splt
->size
+= PLT_ENTRY_SIZE
;
2512 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
2513 htab
->elf
.splt
->size
+= PLT_ENTRY_SIZE
;
2517 if (htab
->elf
.sgotplt
)
2519 struct elf_link_hash_entry
*got
;
2520 got
= elf_link_hash_lookup (elf_hash_table (info
),
2521 "_GLOBAL_OFFSET_TABLE_",
2522 FALSE
, FALSE
, FALSE
);
2524 /* Don't allocate .got.plt section if there are no GOT nor PLT
2525 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
2527 || !got
->ref_regular_nonweak
)
2528 && (htab
->elf
.sgotplt
->size
2529 == get_elf_backend_data (output_bfd
)->got_header_size
)
2530 && (htab
->elf
.splt
== NULL
2531 || htab
->elf
.splt
->size
== 0)
2532 && (htab
->elf
.sgot
== NULL
2533 || htab
->elf
.sgot
->size
== 0)
2534 && (htab
->elf
.iplt
== NULL
2535 || htab
->elf
.iplt
->size
== 0)
2536 && (htab
->elf
.igotplt
== NULL
2537 || htab
->elf
.igotplt
->size
== 0))
2538 htab
->elf
.sgotplt
->size
= 0;
2541 /* We now have determined the sizes of the various dynamic sections.
2542 Allocate memory for them. */
2544 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2546 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2549 if (s
== htab
->elf
.splt
2550 || s
== htab
->elf
.sgot
2551 || s
== htab
->elf
.sgotplt
2552 || s
== htab
->elf
.iplt
2553 || s
== htab
->elf
.igotplt
2554 || s
== htab
->sdynbss
)
2556 /* Strip this section if we don't need it; see the
2559 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
2561 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
2564 /* We use the reloc_count field as a counter if we need
2565 to copy relocs into the output file. */
2566 if (s
!= htab
->elf
.srelplt
)
2571 /* It's not one of our sections, so don't allocate space. */
2577 /* If we don't need this section, strip it from the
2578 output file. This is mostly to handle .rela.bss and
2579 .rela.plt. We must create both sections in
2580 create_dynamic_sections, because they must be created
2581 before the linker maps input sections to output
2582 sections. The linker does that before
2583 adjust_dynamic_symbol is called, and it is that
2584 function which decides whether anything needs to go
2585 into these sections. */
2587 s
->flags
|= SEC_EXCLUDE
;
2591 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2594 /* Allocate memory for the section contents. We use bfd_zalloc
2595 here in case unused entries are not reclaimed before the
2596 section's contents are written out. This should not happen,
2597 but this way if it does, we get a R_X86_64_NONE reloc instead
2599 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
2600 if (s
->contents
== NULL
)
2604 if (htab
->elf
.dynamic_sections_created
)
2606 /* Add some entries to the .dynamic section. We fill in the
2607 values later, in elf_x86_64_finish_dynamic_sections, but we
2608 must add the entries now so that we get the correct size for
2609 the .dynamic section. The DT_DEBUG entry is filled in by the
2610 dynamic linker and used by the debugger. */
2611 #define add_dynamic_entry(TAG, VAL) \
2612 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2614 if (info
->executable
)
2616 if (!add_dynamic_entry (DT_DEBUG
, 0))
2620 if (htab
->elf
.splt
->size
!= 0)
2622 if (!add_dynamic_entry (DT_PLTGOT
, 0)
2623 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
2624 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
2625 || !add_dynamic_entry (DT_JMPREL
, 0))
2628 if (htab
->tlsdesc_plt
2629 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
2630 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
2636 if (!add_dynamic_entry (DT_RELA
, 0)
2637 || !add_dynamic_entry (DT_RELASZ
, 0)
2638 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
2641 /* If any dynamic relocs apply to a read-only section,
2642 then we need a DT_TEXTREL entry. */
2643 if ((info
->flags
& DF_TEXTREL
) == 0)
2644 elf_link_hash_traverse (&htab
->elf
,
2645 elf_x86_64_readonly_dynrelocs
,
2648 if ((info
->flags
& DF_TEXTREL
) != 0)
2650 if (!add_dynamic_entry (DT_TEXTREL
, 0))
2655 #undef add_dynamic_entry
2661 elf_x86_64_always_size_sections (bfd
*output_bfd
,
2662 struct bfd_link_info
*info
)
2664 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
2668 struct elf_link_hash_entry
*tlsbase
;
2670 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
2671 "_TLS_MODULE_BASE_",
2672 FALSE
, FALSE
, FALSE
);
2674 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
2676 struct elf_x86_64_link_hash_table
*htab
;
2677 struct bfd_link_hash_entry
*bh
= NULL
;
2678 const struct elf_backend_data
*bed
2679 = get_elf_backend_data (output_bfd
);
2681 htab
= elf_x86_64_hash_table (info
);
2685 if (!(_bfd_generic_link_add_one_symbol
2686 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
2687 tls_sec
, 0, NULL
, FALSE
,
2688 bed
->collect
, &bh
)))
2691 htab
->tls_module_base
= bh
;
2693 tlsbase
= (struct elf_link_hash_entry
*)bh
;
2694 tlsbase
->def_regular
= 1;
2695 tlsbase
->other
= STV_HIDDEN
;
2696 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
2703 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
2704 executables. Rather than setting it to the beginning of the TLS
2705 section, we have to set it to the end. This function may be called
2706 multiple times, it is idempotent. */
2709 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
2711 struct elf_x86_64_link_hash_table
*htab
;
2712 struct bfd_link_hash_entry
*base
;
2714 if (!info
->executable
)
2717 htab
= elf_x86_64_hash_table (info
);
2721 base
= htab
->tls_module_base
;
2725 base
->u
.def
.value
= htab
->elf
.tls_size
;
2728 /* Return the base VMA address which should be subtracted from real addresses
2729 when resolving @dtpoff relocation.
2730 This is PT_TLS segment p_vaddr. */
2733 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
2735 /* If tls_sec is NULL, we should have signalled an error already. */
2736 if (elf_hash_table (info
)->tls_sec
== NULL
)
2738 return elf_hash_table (info
)->tls_sec
->vma
;
2741 /* Return the relocation value for @tpoff relocation
2742 if STT_TLS virtual address is ADDRESS. */
2745 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
2747 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2748 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
2749 bfd_vma static_tls_size
;
2751 /* If tls_segment is NULL, we should have signalled an error already. */
2752 if (htab
->tls_sec
== NULL
)
2755 /* Consider special static TLS alignment requirements. */
2756 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
2757 return address
- static_tls_size
- htab
->tls_sec
->vma
;
2760 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
2764 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
2766 /* Opcode Instruction
2769 0x0f 0x8x conditional jump */
2771 && (contents
[offset
- 1] == 0xe8
2772 || contents
[offset
- 1] == 0xe9))
2774 && contents
[offset
- 2] == 0x0f
2775 && (contents
[offset
- 1] & 0xf0) == 0x80));
2778 /* Relocate an x86_64 ELF section. */
2781 elf_x86_64_relocate_section (bfd
*output_bfd
,
2782 struct bfd_link_info
*info
,
2784 asection
*input_section
,
2786 Elf_Internal_Rela
*relocs
,
2787 Elf_Internal_Sym
*local_syms
,
2788 asection
**local_sections
)
2790 struct elf_x86_64_link_hash_table
*htab
;
2791 Elf_Internal_Shdr
*symtab_hdr
;
2792 struct elf_link_hash_entry
**sym_hashes
;
2793 bfd_vma
*local_got_offsets
;
2794 bfd_vma
*local_tlsdesc_gotents
;
2795 Elf_Internal_Rela
*rel
;
2796 Elf_Internal_Rela
*relend
;
2798 BFD_ASSERT (is_x86_64_elf (input_bfd
));
2800 htab
= elf_x86_64_hash_table (info
);
2803 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
2804 sym_hashes
= elf_sym_hashes (input_bfd
);
2805 local_got_offsets
= elf_local_got_offsets (input_bfd
);
2806 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
2808 elf_x86_64_set_tls_module_base (info
);
2811 relend
= relocs
+ input_section
->reloc_count
;
2812 for (; rel
< relend
; rel
++)
2814 unsigned int r_type
;
2815 reloc_howto_type
*howto
;
2816 unsigned long r_symndx
;
2817 struct elf_link_hash_entry
*h
;
2818 Elf_Internal_Sym
*sym
;
2820 bfd_vma off
, offplt
;
2822 bfd_boolean unresolved_reloc
;
2823 bfd_reloc_status_type r
;
2827 r_type
= ELF32_R_TYPE (rel
->r_info
);
2828 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
2829 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
2832 if (r_type
>= R_X86_64_max
)
2834 bfd_set_error (bfd_error_bad_value
);
2838 howto
= x86_64_elf_howto_table
+ r_type
;
2839 r_symndx
= htab
->r_sym (rel
->r_info
);
2843 unresolved_reloc
= FALSE
;
2844 if (r_symndx
< symtab_hdr
->sh_info
)
2846 sym
= local_syms
+ r_symndx
;
2847 sec
= local_sections
[r_symndx
];
2849 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
2852 /* Relocate against local STT_GNU_IFUNC symbol. */
2853 if (!info
->relocatable
2854 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
2856 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
2861 /* Set STT_GNU_IFUNC symbol value. */
2862 h
->root
.u
.def
.value
= sym
->st_value
;
2863 h
->root
.u
.def
.section
= sec
;
2868 bfd_boolean warned ATTRIBUTE_UNUSED
;
2870 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2871 r_symndx
, symtab_hdr
, sym_hashes
,
2873 unresolved_reloc
, warned
);
2876 if (sec
!= NULL
&& elf_discarded_section (sec
))
2877 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
2878 rel
, relend
, howto
, contents
);
2880 if (info
->relocatable
)
2883 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
2884 it here if it is defined in a non-shared object. */
2886 && h
->type
== STT_GNU_IFUNC
2893 if ((input_section
->flags
& SEC_ALLOC
) == 0
2894 || h
->plt
.offset
== (bfd_vma
) -1)
2897 /* STT_GNU_IFUNC symbol must go through PLT. */
2898 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
2899 relocation
= (plt
->output_section
->vma
2900 + plt
->output_offset
+ h
->plt
.offset
);
2905 if (h
->root
.root
.string
)
2906 name
= h
->root
.root
.string
;
2908 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
2910 (*_bfd_error_handler
)
2911 (_("%B: relocation %s against STT_GNU_IFUNC "
2912 "symbol `%s' isn't handled by %s"), input_bfd
,
2913 x86_64_elf_howto_table
[r_type
].name
,
2914 name
, __FUNCTION__
);
2915 bfd_set_error (bfd_error_bad_value
);
2924 if (ABI_64_P (output_bfd
))
2928 if (rel
->r_addend
!= 0)
2930 if (h
->root
.root
.string
)
2931 name
= h
->root
.root
.string
;
2933 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
2935 (*_bfd_error_handler
)
2936 (_("%B: relocation %s against STT_GNU_IFUNC "
2937 "symbol `%s' has non-zero addend: %d"),
2938 input_bfd
, x86_64_elf_howto_table
[r_type
].name
,
2939 name
, rel
->r_addend
);
2940 bfd_set_error (bfd_error_bad_value
);
2944 /* Generate dynamic relcoation only when there is a
2945 non-GOF reference in a shared object. */
2946 if (info
->shared
&& h
->non_got_ref
)
2948 Elf_Internal_Rela outrel
;
2951 /* Need a dynamic relocation to get the real function
2953 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
2957 if (outrel
.r_offset
== (bfd_vma
) -1
2958 || outrel
.r_offset
== (bfd_vma
) -2)
2961 outrel
.r_offset
+= (input_section
->output_section
->vma
2962 + input_section
->output_offset
);
2964 if (h
->dynindx
== -1
2966 || info
->executable
)
2968 /* This symbol is resolved locally. */
2969 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
2970 outrel
.r_addend
= (h
->root
.u
.def
.value
2971 + h
->root
.u
.def
.section
->output_section
->vma
2972 + h
->root
.u
.def
.section
->output_offset
);
2976 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
2977 outrel
.r_addend
= 0;
2980 sreloc
= htab
->elf
.irelifunc
;
2981 elf_append_rela (output_bfd
, sreloc
, &outrel
);
2983 /* If this reloc is against an external symbol, we
2984 do not want to fiddle with the addend. Otherwise,
2985 we need to include the symbol value so that it
2986 becomes an addend for the dynamic reloc. For an
2987 internal symbol, we have updated addend. */
2993 case R_X86_64_PLT32
:
2996 case R_X86_64_GOTPCREL
:
2997 case R_X86_64_GOTPCREL64
:
2998 base_got
= htab
->elf
.sgot
;
2999 off
= h
->got
.offset
;
3001 if (base_got
== NULL
)
3004 if (off
== (bfd_vma
) -1)
3006 /* We can't use h->got.offset here to save state, or
3007 even just remember the offset, as finish_dynamic_symbol
3008 would use that as offset into .got. */
3010 if (htab
->elf
.splt
!= NULL
)
3012 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
3013 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
3014 base_got
= htab
->elf
.sgotplt
;
3018 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
;
3019 off
= plt_index
* GOT_ENTRY_SIZE
;
3020 base_got
= htab
->elf
.igotplt
;
3023 if (h
->dynindx
== -1
3027 /* This references the local defitionion. We must
3028 initialize this entry in the global offset table.
3029 Since the offset must always be a multiple of 8,
3030 we use the least significant bit to record
3031 whether we have initialized it already.
3033 When doing a dynamic link, we create a .rela.got
3034 relocation entry to initialize the value. This
3035 is done in the finish_dynamic_symbol routine. */
3040 bfd_put_64 (output_bfd
, relocation
,
3041 base_got
->contents
+ off
);
3042 /* Note that this is harmless for the GOTPLT64
3043 case, as -1 | 1 still is -1. */
3049 relocation
= (base_got
->output_section
->vma
3050 + base_got
->output_offset
+ off
);
3056 /* When generating a shared object, the relocations handled here are
3057 copied into the output file to be resolved at run time. */
3060 case R_X86_64_GOT32
:
3061 case R_X86_64_GOT64
:
3062 /* Relocation is to the entry for this symbol in the global
3064 case R_X86_64_GOTPCREL
:
3065 case R_X86_64_GOTPCREL64
:
3066 /* Use global offset table entry as symbol value. */
3067 case R_X86_64_GOTPLT64
:
3068 /* This is the same as GOT64 for relocation purposes, but
3069 indicates the existence of a PLT entry. The difficulty is,
3070 that we must calculate the GOT slot offset from the PLT
3071 offset, if this symbol got a PLT entry (it was global).
3072 Additionally if it's computed from the PLT entry, then that
3073 GOT offset is relative to .got.plt, not to .got. */
3074 base_got
= htab
->elf
.sgot
;
3076 if (htab
->elf
.sgot
== NULL
)
3083 off
= h
->got
.offset
;
3085 && h
->plt
.offset
!= (bfd_vma
)-1
3086 && off
== (bfd_vma
)-1)
3088 /* We can't use h->got.offset here to save
3089 state, or even just remember the offset, as
3090 finish_dynamic_symbol would use that as offset into
3092 bfd_vma plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
3093 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
3094 base_got
= htab
->elf
.sgotplt
;
3097 dyn
= htab
->elf
.dynamic_sections_created
;
3099 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
3101 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3102 || (ELF_ST_VISIBILITY (h
->other
)
3103 && h
->root
.type
== bfd_link_hash_undefweak
))
3105 /* This is actually a static link, or it is a -Bsymbolic
3106 link and the symbol is defined locally, or the symbol
3107 was forced to be local because of a version file. We
3108 must initialize this entry in the global offset table.
3109 Since the offset must always be a multiple of 8, we
3110 use the least significant bit to record whether we
3111 have initialized it already.
3113 When doing a dynamic link, we create a .rela.got
3114 relocation entry to initialize the value. This is
3115 done in the finish_dynamic_symbol routine. */
3120 bfd_put_64 (output_bfd
, relocation
,
3121 base_got
->contents
+ off
);
3122 /* Note that this is harmless for the GOTPLT64 case,
3123 as -1 | 1 still is -1. */
3128 unresolved_reloc
= FALSE
;
3132 if (local_got_offsets
== NULL
)
3135 off
= local_got_offsets
[r_symndx
];
3137 /* The offset must always be a multiple of 8. We use
3138 the least significant bit to record whether we have
3139 already generated the necessary reloc. */
3144 bfd_put_64 (output_bfd
, relocation
,
3145 base_got
->contents
+ off
);
3150 Elf_Internal_Rela outrel
;
3152 /* We need to generate a R_X86_64_RELATIVE reloc
3153 for the dynamic linker. */
3154 s
= htab
->elf
.srelgot
;
3158 outrel
.r_offset
= (base_got
->output_section
->vma
3159 + base_got
->output_offset
3161 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
3162 outrel
.r_addend
= relocation
;
3163 elf_append_rela (output_bfd
, s
, &outrel
);
3166 local_got_offsets
[r_symndx
] |= 1;
3170 if (off
>= (bfd_vma
) -2)
3173 relocation
= base_got
->output_section
->vma
3174 + base_got
->output_offset
+ off
;
3175 if (r_type
!= R_X86_64_GOTPCREL
&& r_type
!= R_X86_64_GOTPCREL64
)
3176 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3177 - htab
->elf
.sgotplt
->output_offset
;
3181 case R_X86_64_GOTOFF64
:
3182 /* Relocation is relative to the start of the global offset
3185 /* Check to make sure it isn't a protected function symbol
3186 for shared library since it may not be local when used
3187 as function address. */
3191 && h
->type
== STT_FUNC
3192 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
3194 (*_bfd_error_handler
)
3195 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
3196 input_bfd
, h
->root
.root
.string
);
3197 bfd_set_error (bfd_error_bad_value
);
3201 /* Note that sgot is not involved in this
3202 calculation. We always want the start of .got.plt. If we
3203 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3204 permitted by the ABI, we might have to change this
3206 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3207 + htab
->elf
.sgotplt
->output_offset
;
3210 case R_X86_64_GOTPC32
:
3211 case R_X86_64_GOTPC64
:
3212 /* Use global offset table as symbol value. */
3213 relocation
= htab
->elf
.sgotplt
->output_section
->vma
3214 + htab
->elf
.sgotplt
->output_offset
;
3215 unresolved_reloc
= FALSE
;
3218 case R_X86_64_PLTOFF64
:
3219 /* Relocation is PLT entry relative to GOT. For local
3220 symbols it's the symbol itself relative to GOT. */
3222 /* See PLT32 handling. */
3223 && h
->plt
.offset
!= (bfd_vma
) -1
3224 && htab
->elf
.splt
!= NULL
)
3226 relocation
= (htab
->elf
.splt
->output_section
->vma
3227 + htab
->elf
.splt
->output_offset
3229 unresolved_reloc
= FALSE
;
3232 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3233 + htab
->elf
.sgotplt
->output_offset
;
3236 case R_X86_64_PLT32
:
3237 /* Relocation is to the entry for this symbol in the
3238 procedure linkage table. */
3240 /* Resolve a PLT32 reloc against a local symbol directly,
3241 without using the procedure linkage table. */
3245 if (h
->plt
.offset
== (bfd_vma
) -1
3246 || htab
->elf
.splt
== NULL
)
3248 /* We didn't make a PLT entry for this symbol. This
3249 happens when statically linking PIC code, or when
3250 using -Bsymbolic. */
3254 relocation
= (htab
->elf
.splt
->output_section
->vma
3255 + htab
->elf
.splt
->output_offset
3257 unresolved_reloc
= FALSE
;
3264 && ABI_64_P (output_bfd
)
3265 && (input_section
->flags
& SEC_ALLOC
) != 0
3266 && (input_section
->flags
& SEC_READONLY
) != 0
3269 bfd_boolean fail
= FALSE
;
3271 = (r_type
== R_X86_64_PC32
3272 && is_32bit_relative_branch (contents
, rel
->r_offset
));
3274 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
3276 /* Symbol is referenced locally. Make sure it is
3277 defined locally or for a branch. */
3278 fail
= !h
->def_regular
&& !branch
;
3282 /* Symbol isn't referenced locally. We only allow
3283 branch to symbol with non-default visibility. */
3285 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
3292 const char *pic
= "";
3294 switch (ELF_ST_VISIBILITY (h
->other
))
3297 v
= _("hidden symbol");
3300 v
= _("internal symbol");
3303 v
= _("protected symbol");
3307 pic
= _("; recompile with -fPIC");
3312 fmt
= _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
3314 fmt
= _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
3316 (*_bfd_error_handler
) (fmt
, input_bfd
,
3317 x86_64_elf_howto_table
[r_type
].name
,
3318 v
, h
->root
.root
.string
, pic
);
3319 bfd_set_error (bfd_error_bad_value
);
3330 /* FIXME: The ABI says the linker should make sure the value is
3331 the same when it's zeroextended to 64 bit. */
3333 if ((input_section
->flags
& SEC_ALLOC
) == 0)
3338 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3339 || h
->root
.type
!= bfd_link_hash_undefweak
)
3340 && (! IS_X86_64_PCREL_TYPE (r_type
)
3341 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
3342 || (ELIMINATE_COPY_RELOCS
3349 || h
->root
.type
== bfd_link_hash_undefweak
3350 || h
->root
.type
== bfd_link_hash_undefined
)))
3352 Elf_Internal_Rela outrel
;
3353 bfd_boolean skip
, relocate
;
3356 /* When generating a shared object, these relocations
3357 are copied into the output file to be resolved at run
3363 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3365 if (outrel
.r_offset
== (bfd_vma
) -1)
3367 else if (outrel
.r_offset
== (bfd_vma
) -2)
3368 skip
= TRUE
, relocate
= TRUE
;
3370 outrel
.r_offset
+= (input_section
->output_section
->vma
3371 + input_section
->output_offset
);
3374 memset (&outrel
, 0, sizeof outrel
);
3376 /* h->dynindx may be -1 if this symbol was marked to
3380 && (IS_X86_64_PCREL_TYPE (r_type
)
3382 || ! SYMBOLIC_BIND (info
, h
)
3383 || ! h
->def_regular
))
3385 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
3386 outrel
.r_addend
= rel
->r_addend
;
3390 /* This symbol is local, or marked to become local. */
3391 if (r_type
== htab
->pointer_r_type
)
3394 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
3395 outrel
.r_addend
= relocation
+ rel
->r_addend
;
3401 if (bfd_is_abs_section (sec
))
3403 else if (sec
== NULL
|| sec
->owner
== NULL
)
3405 bfd_set_error (bfd_error_bad_value
);
3412 /* We are turning this relocation into one
3413 against a section symbol. It would be
3414 proper to subtract the symbol's value,
3415 osec->vma, from the emitted reloc addend,
3416 but ld.so expects buggy relocs. */
3417 osec
= sec
->output_section
;
3418 sindx
= elf_section_data (osec
)->dynindx
;
3421 asection
*oi
= htab
->elf
.text_index_section
;
3422 sindx
= elf_section_data (oi
)->dynindx
;
3424 BFD_ASSERT (sindx
!= 0);
3427 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
3428 outrel
.r_addend
= relocation
+ rel
->r_addend
;
3432 sreloc
= elf_section_data (input_section
)->sreloc
;
3434 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
3436 r
= bfd_reloc_notsupported
;
3437 goto check_relocation_error
;
3440 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3442 /* If this reloc is against an external symbol, we do
3443 not want to fiddle with the addend. Otherwise, we
3444 need to include the symbol value so that it becomes
3445 an addend for the dynamic reloc. */
3452 case R_X86_64_TLSGD
:
3453 case R_X86_64_GOTPC32_TLSDESC
:
3454 case R_X86_64_TLSDESC_CALL
:
3455 case R_X86_64_GOTTPOFF
:
3456 tls_type
= GOT_UNKNOWN
;
3457 if (h
== NULL
&& local_got_offsets
)
3458 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
3460 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
3462 if (! elf_x86_64_tls_transition (info
, input_bfd
,
3463 input_section
, contents
,
3464 symtab_hdr
, sym_hashes
,
3465 &r_type
, tls_type
, rel
,
3466 relend
, h
, r_symndx
))
3469 if (r_type
== R_X86_64_TPOFF32
)
3471 bfd_vma roff
= rel
->r_offset
;
3473 BFD_ASSERT (! unresolved_reloc
);
3475 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
3477 /* GD->LE transition. For 64bit, change
3478 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3479 .word 0x6666; rex64; call __tls_get_addr
3482 leaq foo@tpoff(%rax), %rax
3484 leaq foo@tlsgd(%rip), %rdi
3485 .word 0x6666; rex64; call __tls_get_addr
3488 leaq foo@tpoff(%rax), %rax */
3489 if (ABI_64_P (output_bfd
))
3490 memcpy (contents
+ roff
- 4,
3491 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3494 memcpy (contents
+ roff
- 3,
3495 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3497 bfd_put_32 (output_bfd
,
3498 elf_x86_64_tpoff (info
, relocation
),
3499 contents
+ roff
+ 8);
3500 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
3504 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
3506 /* GDesc -> LE transition.
3507 It's originally something like:
3508 leaq x@tlsdesc(%rip), %rax
3511 movl $x@tpoff, %rax. */
3513 unsigned int val
, type
;
3515 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
3516 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
3517 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
3518 contents
+ roff
- 3);
3519 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
3520 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
3521 contents
+ roff
- 1);
3522 bfd_put_32 (output_bfd
,
3523 elf_x86_64_tpoff (info
, relocation
),
3527 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
3529 /* GDesc -> LE transition.
3534 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
3535 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
3538 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
3540 /* IE->LE transition:
3541 Originally it can be one of:
3542 movq foo@gottpoff(%rip), %reg
3543 addq foo@gottpoff(%rip), %reg
3546 leaq foo(%reg), %reg
3549 unsigned int val
, type
, reg
;
3551 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
3552 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
3553 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
3559 bfd_put_8 (output_bfd
, 0x49,
3560 contents
+ roff
- 3);
3561 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
3562 bfd_put_8 (output_bfd
, 0x41,
3563 contents
+ roff
- 3);
3564 bfd_put_8 (output_bfd
, 0xc7,
3565 contents
+ roff
- 2);
3566 bfd_put_8 (output_bfd
, 0xc0 | reg
,
3567 contents
+ roff
- 1);
3571 /* addq -> addq - addressing with %rsp/%r12 is
3574 bfd_put_8 (output_bfd
, 0x49,
3575 contents
+ roff
- 3);
3576 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
3577 bfd_put_8 (output_bfd
, 0x41,
3578 contents
+ roff
- 3);
3579 bfd_put_8 (output_bfd
, 0x81,
3580 contents
+ roff
- 2);
3581 bfd_put_8 (output_bfd
, 0xc0 | reg
,
3582 contents
+ roff
- 1);
3588 bfd_put_8 (output_bfd
, 0x4d,
3589 contents
+ roff
- 3);
3590 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
3591 bfd_put_8 (output_bfd
, 0x45,
3592 contents
+ roff
- 3);
3593 bfd_put_8 (output_bfd
, 0x8d,
3594 contents
+ roff
- 2);
3595 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
3596 contents
+ roff
- 1);
3598 bfd_put_32 (output_bfd
,
3599 elf_x86_64_tpoff (info
, relocation
),
3607 if (htab
->elf
.sgot
== NULL
)
3612 off
= h
->got
.offset
;
3613 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
3617 if (local_got_offsets
== NULL
)
3620 off
= local_got_offsets
[r_symndx
];
3621 offplt
= local_tlsdesc_gotents
[r_symndx
];
3628 Elf_Internal_Rela outrel
;
3632 if (htab
->elf
.srelgot
== NULL
)
3635 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
3637 if (GOT_TLS_GDESC_P (tls_type
))
3639 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
3640 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
3641 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
3642 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
3643 + htab
->elf
.sgotplt
->output_offset
3645 + htab
->sgotplt_jump_table_size
);
3646 sreloc
= htab
->elf
.srelplt
;
3648 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
3650 outrel
.r_addend
= 0;
3651 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3654 sreloc
= htab
->elf
.srelgot
;
3656 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
3657 + htab
->elf
.sgot
->output_offset
+ off
);
3659 if (GOT_TLS_GD_P (tls_type
))
3660 dr_type
= R_X86_64_DTPMOD64
;
3661 else if (GOT_TLS_GDESC_P (tls_type
))
3664 dr_type
= R_X86_64_TPOFF64
;
3666 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
3667 outrel
.r_addend
= 0;
3668 if ((dr_type
== R_X86_64_TPOFF64
3669 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
3670 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
3671 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
3673 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3675 if (GOT_TLS_GD_P (tls_type
))
3679 BFD_ASSERT (! unresolved_reloc
);
3680 bfd_put_64 (output_bfd
,
3681 relocation
- elf_x86_64_dtpoff_base (info
),
3682 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
3686 bfd_put_64 (output_bfd
, 0,
3687 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
3688 outrel
.r_info
= htab
->r_info (indx
,
3690 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
3691 elf_append_rela (output_bfd
, sreloc
,
3700 local_got_offsets
[r_symndx
] |= 1;
3703 if (off
>= (bfd_vma
) -2
3704 && ! GOT_TLS_GDESC_P (tls_type
))
3706 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
3708 if (r_type
== R_X86_64_GOTPC32_TLSDESC
3709 || r_type
== R_X86_64_TLSDESC_CALL
)
3710 relocation
= htab
->elf
.sgotplt
->output_section
->vma
3711 + htab
->elf
.sgotplt
->output_offset
3712 + offplt
+ htab
->sgotplt_jump_table_size
;
3714 relocation
= htab
->elf
.sgot
->output_section
->vma
3715 + htab
->elf
.sgot
->output_offset
+ off
;
3716 unresolved_reloc
= FALSE
;
3720 bfd_vma roff
= rel
->r_offset
;
3722 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
3724 /* GD->IE transition. For 64bit, change
3725 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3726 .word 0x6666; rex64; call __tls_get_addr@plt
3729 addq foo@gottpoff(%rip), %rax
3731 leaq foo@tlsgd(%rip), %rdi
3732 .word 0x6666; rex64; call __tls_get_addr@plt
3735 addq foo@gottpoff(%rip), %rax */
3736 if (ABI_64_P (output_bfd
))
3737 memcpy (contents
+ roff
- 4,
3738 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
3741 memcpy (contents
+ roff
- 3,
3742 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
3745 relocation
= (htab
->elf
.sgot
->output_section
->vma
3746 + htab
->elf
.sgot
->output_offset
+ off
3748 - input_section
->output_section
->vma
3749 - input_section
->output_offset
3751 bfd_put_32 (output_bfd
, relocation
,
3752 contents
+ roff
+ 8);
3753 /* Skip R_X86_64_PLT32. */
3757 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
3759 /* GDesc -> IE transition.
3760 It's originally something like:
3761 leaq x@tlsdesc(%rip), %rax
3764 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
3766 /* Now modify the instruction as appropriate. To
3767 turn a leaq into a movq in the form we use it, it
3768 suffices to change the second byte from 0x8d to
3770 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
3772 bfd_put_32 (output_bfd
,
3773 htab
->elf
.sgot
->output_section
->vma
3774 + htab
->elf
.sgot
->output_offset
+ off
3776 - input_section
->output_section
->vma
3777 - input_section
->output_offset
3782 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
3784 /* GDesc -> IE transition.
3791 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
3792 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
3800 case R_X86_64_TLSLD
:
3801 if (! elf_x86_64_tls_transition (info
, input_bfd
,
3802 input_section
, contents
,
3803 symtab_hdr
, sym_hashes
,
3804 &r_type
, GOT_UNKNOWN
,
3805 rel
, relend
, h
, r_symndx
))
3808 if (r_type
!= R_X86_64_TLSLD
)
3810 /* LD->LE transition:
3811 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
3812 For 64bit, we change it into:
3813 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
3814 For 32bit, we change it into:
3815 nopl 0x0(%rax); movl %fs:0, %eax. */
3817 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
3818 if (ABI_64_P (output_bfd
))
3819 memcpy (contents
+ rel
->r_offset
- 3,
3820 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
3822 memcpy (contents
+ rel
->r_offset
- 3,
3823 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
3824 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
3829 if (htab
->elf
.sgot
== NULL
)
3832 off
= htab
->tls_ld_got
.offset
;
3837 Elf_Internal_Rela outrel
;
3839 if (htab
->elf
.srelgot
== NULL
)
3842 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
3843 + htab
->elf
.sgot
->output_offset
+ off
);
3845 bfd_put_64 (output_bfd
, 0,
3846 htab
->elf
.sgot
->contents
+ off
);
3847 bfd_put_64 (output_bfd
, 0,
3848 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
3849 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
3850 outrel
.r_addend
= 0;
3851 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
3853 htab
->tls_ld_got
.offset
|= 1;
3855 relocation
= htab
->elf
.sgot
->output_section
->vma
3856 + htab
->elf
.sgot
->output_offset
+ off
;
3857 unresolved_reloc
= FALSE
;
3860 case R_X86_64_DTPOFF32
:
3861 if (!info
->executable
|| (input_section
->flags
& SEC_CODE
) == 0)
3862 relocation
-= elf_x86_64_dtpoff_base (info
);
3864 relocation
= elf_x86_64_tpoff (info
, relocation
);
3867 case R_X86_64_TPOFF32
:
3868 case R_X86_64_TPOFF64
:
3869 BFD_ASSERT (info
->executable
);
3870 relocation
= elf_x86_64_tpoff (info
, relocation
);
3877 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3878 because such sections are not SEC_ALLOC and thus ld.so will
3879 not process them. */
3880 if (unresolved_reloc
3881 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
3883 (*_bfd_error_handler
)
3884 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3887 (long) rel
->r_offset
,
3889 h
->root
.root
.string
);
3892 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
3893 contents
, rel
->r_offset
,
3894 relocation
, rel
->r_addend
);
3896 check_relocation_error
:
3897 if (r
!= bfd_reloc_ok
)
3902 name
= h
->root
.root
.string
;
3905 name
= bfd_elf_string_from_elf_section (input_bfd
,
3906 symtab_hdr
->sh_link
,
3911 name
= bfd_section_name (input_bfd
, sec
);
3914 if (r
== bfd_reloc_overflow
)
3916 if (! ((*info
->callbacks
->reloc_overflow
)
3917 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
3918 (bfd_vma
) 0, input_bfd
, input_section
,
3924 (*_bfd_error_handler
)
3925 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3926 input_bfd
, input_section
,
3927 (long) rel
->r_offset
, name
, (int) r
);
3936 /* Finish up dynamic symbol handling. We set the contents of various
3937 dynamic sections here. */
3940 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
3941 struct bfd_link_info
*info
,
3942 struct elf_link_hash_entry
*h
,
3943 Elf_Internal_Sym
*sym
)
3945 struct elf_x86_64_link_hash_table
*htab
;
3947 htab
= elf_x86_64_hash_table (info
);
3951 if (h
->plt
.offset
!= (bfd_vma
) -1)
3955 Elf_Internal_Rela rela
;
3957 asection
*plt
, *gotplt
, *relplt
;
3958 const struct elf_backend_data
*bed
;
3960 /* When building a static executable, use .iplt, .igot.plt and
3961 .rela.iplt sections for STT_GNU_IFUNC symbols. */
3962 if (htab
->elf
.splt
!= NULL
)
3964 plt
= htab
->elf
.splt
;
3965 gotplt
= htab
->elf
.sgotplt
;
3966 relplt
= htab
->elf
.srelplt
;
3970 plt
= htab
->elf
.iplt
;
3971 gotplt
= htab
->elf
.igotplt
;
3972 relplt
= htab
->elf
.irelplt
;
3975 /* This symbol has an entry in the procedure linkage table. Set
3977 if ((h
->dynindx
== -1
3978 && !((h
->forced_local
|| info
->executable
)
3980 && h
->type
== STT_GNU_IFUNC
))
3986 /* Get the index in the procedure linkage table which
3987 corresponds to this symbol. This is the index of this symbol
3988 in all the symbols for which we are making plt entries. The
3989 first entry in the procedure linkage table is reserved.
3991 Get the offset into the .got table of the entry that
3992 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
3993 bytes. The first three are reserved for the dynamic linker.
3995 For static executables, we don't reserve anything. */
3997 if (plt
== htab
->elf
.splt
)
3999 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
4000 got_offset
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4004 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
;
4005 got_offset
= plt_index
* GOT_ENTRY_SIZE
;
4008 /* Fill in the entry in the procedure linkage table. */
4009 memcpy (plt
->contents
+ h
->plt
.offset
, elf_x86_64_plt_entry
,
4012 /* Insert the relocation positions of the plt section. The magic
4013 numbers at the end of the statements are the positions of the
4014 relocations in the plt section. */
4015 /* Put offset for jmp *name@GOTPCREL(%rip), since the
4016 instruction uses 6 bytes, subtract this value. */
4017 bfd_put_32 (output_bfd
,
4018 (gotplt
->output_section
->vma
4019 + gotplt
->output_offset
4021 - plt
->output_section
->vma
4022 - plt
->output_offset
4025 plt
->contents
+ h
->plt
.offset
+ 2);
4027 /* Don't fill PLT entry for static executables. */
4028 if (plt
== htab
->elf
.splt
)
4030 /* Put relocation index. */
4031 bfd_put_32 (output_bfd
, plt_index
,
4032 plt
->contents
+ h
->plt
.offset
+ 7);
4033 /* Put offset for jmp .PLT0. */
4034 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
4035 plt
->contents
+ h
->plt
.offset
+ 12);
4038 /* Fill in the entry in the global offset table, initially this
4039 points to the pushq instruction in the PLT which is at offset 6. */
4040 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
4041 + plt
->output_offset
4042 + h
->plt
.offset
+ 6),
4043 gotplt
->contents
+ got_offset
);
4045 /* Fill in the entry in the .rela.plt section. */
4046 rela
.r_offset
= (gotplt
->output_section
->vma
4047 + gotplt
->output_offset
4049 if (h
->dynindx
== -1
4050 || ((info
->executable
4051 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
4053 && h
->type
== STT_GNU_IFUNC
))
4055 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4056 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
4057 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4058 rela
.r_addend
= (h
->root
.u
.def
.value
4059 + h
->root
.u
.def
.section
->output_section
->vma
4060 + h
->root
.u
.def
.section
->output_offset
);
4064 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
4068 bed
= get_elf_backend_data (output_bfd
);
4069 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
4070 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
4072 if (!h
->def_regular
)
4074 /* Mark the symbol as undefined, rather than as defined in
4075 the .plt section. Leave the value if there were any
4076 relocations where pointer equality matters (this is a clue
4077 for the dynamic linker, to make function pointer
4078 comparisons work between an application and shared
4079 library), otherwise set it to zero. If a function is only
4080 called from a binary, there is no need to slow down
4081 shared libraries because of that. */
4082 sym
->st_shndx
= SHN_UNDEF
;
4083 if (!h
->pointer_equality_needed
)
4088 if (h
->got
.offset
!= (bfd_vma
) -1
4089 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
4090 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
)
4092 Elf_Internal_Rela rela
;
4094 /* This symbol has an entry in the global offset table. Set it
4096 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
4099 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4100 + htab
->elf
.sgot
->output_offset
4101 + (h
->got
.offset
&~ (bfd_vma
) 1));
4103 /* If this is a static link, or it is a -Bsymbolic link and the
4104 symbol is defined locally or was forced to be local because
4105 of a version file, we just want to emit a RELATIVE reloc.
4106 The entry in the global offset table will already have been
4107 initialized in the relocate_section function. */
4109 && h
->type
== STT_GNU_IFUNC
)
4113 /* Generate R_X86_64_GLOB_DAT. */
4120 if (!h
->pointer_equality_needed
)
4123 /* For non-shared object, we can't use .got.plt, which
4124 contains the real function addres if we need pointer
4125 equality. We load the GOT entry with the PLT entry. */
4126 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
4127 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
4128 + plt
->output_offset
4130 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
4134 else if (info
->shared
4135 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4137 if (!h
->def_regular
)
4139 BFD_ASSERT((h
->got
.offset
& 1) != 0);
4140 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4141 rela
.r_addend
= (h
->root
.u
.def
.value
4142 + h
->root
.u
.def
.section
->output_section
->vma
4143 + h
->root
.u
.def
.section
->output_offset
);
4147 BFD_ASSERT((h
->got
.offset
& 1) == 0);
4149 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
4150 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
4151 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
4155 elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &rela
);
4160 Elf_Internal_Rela rela
;
4162 /* This symbol needs a copy reloc. Set it up. */
4164 if (h
->dynindx
== -1
4165 || (h
->root
.type
!= bfd_link_hash_defined
4166 && h
->root
.type
!= bfd_link_hash_defweak
)
4167 || htab
->srelbss
== NULL
)
4170 rela
.r_offset
= (h
->root
.u
.def
.value
4171 + h
->root
.u
.def
.section
->output_section
->vma
4172 + h
->root
.u
.def
.section
->output_offset
);
4173 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
4175 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
4178 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. SYM may
4179 be NULL for local symbols. */
4181 && (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
4182 || h
== htab
->elf
.hgot
))
4183 sym
->st_shndx
= SHN_ABS
;
4188 /* Finish up local dynamic symbol handling. We set the contents of
4189 various dynamic sections here. */
4192 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
4194 struct elf_link_hash_entry
*h
4195 = (struct elf_link_hash_entry
*) *slot
;
4196 struct bfd_link_info
*info
4197 = (struct bfd_link_info
*) inf
;
4199 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
4203 /* Used to decide how to sort relocs in an optimal manner for the
4204 dynamic linker, before writing them out. */
4206 static enum elf_reloc_type_class
4207 elf_x86_64_reloc_type_class (const Elf_Internal_Rela
*rela
)
4209 switch ((int) ELF32_R_TYPE (rela
->r_info
))
4211 case R_X86_64_RELATIVE
:
4212 return reloc_class_relative
;
4213 case R_X86_64_JUMP_SLOT
:
4214 return reloc_class_plt
;
4216 return reloc_class_copy
;
4218 return reloc_class_normal
;
4222 /* Finish up the dynamic sections. */
4225 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
4226 struct bfd_link_info
*info
)
4228 struct elf_x86_64_link_hash_table
*htab
;
4232 htab
= elf_x86_64_hash_table (info
);
4236 dynobj
= htab
->elf
.dynobj
;
4237 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
4239 if (htab
->elf
.dynamic_sections_created
)
4241 bfd_byte
*dyncon
, *dynconend
;
4242 const struct elf_backend_data
*bed
;
4243 bfd_size_type sizeof_dyn
;
4245 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
4248 bed
= get_elf_backend_data (dynobj
);
4249 sizeof_dyn
= bed
->s
->sizeof_dyn
;
4250 dyncon
= sdyn
->contents
;
4251 dynconend
= sdyn
->contents
+ sdyn
->size
;
4252 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
4254 Elf_Internal_Dyn dyn
;
4257 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
4265 s
= htab
->elf
.sgotplt
;
4266 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
4270 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
4274 s
= htab
->elf
.srelplt
->output_section
;
4275 dyn
.d_un
.d_val
= s
->size
;
4279 /* The procedure linkage table relocs (DT_JMPREL) should
4280 not be included in the overall relocs (DT_RELA).
4281 Therefore, we override the DT_RELASZ entry here to
4282 make it not include the JMPREL relocs. Since the
4283 linker script arranges for .rela.plt to follow all
4284 other relocation sections, we don't have to worry
4285 about changing the DT_RELA entry. */
4286 if (htab
->elf
.srelplt
!= NULL
)
4288 s
= htab
->elf
.srelplt
->output_section
;
4289 dyn
.d_un
.d_val
-= s
->size
;
4293 case DT_TLSDESC_PLT
:
4295 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
4296 + htab
->tlsdesc_plt
;
4299 case DT_TLSDESC_GOT
:
4301 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
4302 + htab
->tlsdesc_got
;
4306 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
4309 /* Fill in the special first entry in the procedure linkage table. */
4310 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
4312 /* Fill in the first entry in the procedure linkage table. */
4313 memcpy (htab
->elf
.splt
->contents
, elf_x86_64_plt0_entry
,
4315 /* Add offset for pushq GOT+8(%rip), since the instruction
4316 uses 6 bytes subtract this value. */
4317 bfd_put_32 (output_bfd
,
4318 (htab
->elf
.sgotplt
->output_section
->vma
4319 + htab
->elf
.sgotplt
->output_offset
4321 - htab
->elf
.splt
->output_section
->vma
4322 - htab
->elf
.splt
->output_offset
4324 htab
->elf
.splt
->contents
+ 2);
4325 /* Add offset for jmp *GOT+16(%rip). The 12 is the offset to
4326 the end of the instruction. */
4327 bfd_put_32 (output_bfd
,
4328 (htab
->elf
.sgotplt
->output_section
->vma
4329 + htab
->elf
.sgotplt
->output_offset
4331 - htab
->elf
.splt
->output_section
->vma
4332 - htab
->elf
.splt
->output_offset
4334 htab
->elf
.splt
->contents
+ 8);
4336 elf_section_data (htab
->elf
.splt
->output_section
)->this_hdr
.sh_entsize
=
4339 if (htab
->tlsdesc_plt
)
4341 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
4342 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
4344 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
4345 elf_x86_64_plt0_entry
,
4348 /* Add offset for pushq GOT+8(%rip), since the
4349 instruction uses 6 bytes subtract this value. */
4350 bfd_put_32 (output_bfd
,
4351 (htab
->elf
.sgotplt
->output_section
->vma
4352 + htab
->elf
.sgotplt
->output_offset
4354 - htab
->elf
.splt
->output_section
->vma
4355 - htab
->elf
.splt
->output_offset
4358 htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
+ 2);
4359 /* Add offset for jmp *GOT+TDG(%rip), where TGD stands for
4360 htab->tlsdesc_got. The 12 is the offset to the end of
4362 bfd_put_32 (output_bfd
,
4363 (htab
->elf
.sgot
->output_section
->vma
4364 + htab
->elf
.sgot
->output_offset
4366 - htab
->elf
.splt
->output_section
->vma
4367 - htab
->elf
.splt
->output_offset
4370 htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
+ 8);
4375 if (htab
->elf
.sgotplt
)
4377 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
4379 (*_bfd_error_handler
)
4380 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
4384 /* Fill in the first three entries in the global offset table. */
4385 if (htab
->elf
.sgotplt
->size
> 0)
4387 /* Set the first entry in the global offset table to the address of
4388 the dynamic section. */
4390 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
4392 bfd_put_64 (output_bfd
,
4393 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
4394 htab
->elf
.sgotplt
->contents
);
4395 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
4396 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
4397 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
4400 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
4404 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
4405 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
4408 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4409 htab_traverse (htab
->loc_hash_table
,
4410 elf_x86_64_finish_local_dynamic_symbol
,
4416 /* Return address for Ith PLT stub in section PLT, for relocation REL
4417 or (bfd_vma) -1 if it should not be included. */
4420 elf_x86_64_plt_sym_val (bfd_vma i
, const asection
*plt
,
4421 const arelent
*rel ATTRIBUTE_UNUSED
)
4423 return plt
->vma
+ (i
+ 1) * PLT_ENTRY_SIZE
;
4426 /* Handle an x86-64 specific section when reading an object file. This
4427 is called when elfcode.h finds a section with an unknown type. */
4430 elf_x86_64_section_from_shdr (bfd
*abfd
,
4431 Elf_Internal_Shdr
*hdr
,
4435 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
4438 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
4444 /* Hook called by the linker routine which adds symbols from an object
4445 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
4449 elf_x86_64_add_symbol_hook (bfd
*abfd
,
4450 struct bfd_link_info
*info
,
4451 Elf_Internal_Sym
*sym
,
4452 const char **namep ATTRIBUTE_UNUSED
,
4453 flagword
*flagsp ATTRIBUTE_UNUSED
,
4459 switch (sym
->st_shndx
)
4461 case SHN_X86_64_LCOMMON
:
4462 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
4465 lcomm
= bfd_make_section_with_flags (abfd
,
4469 | SEC_LINKER_CREATED
));
4472 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
4475 *valp
= sym
->st_size
;
4479 if ((abfd
->flags
& DYNAMIC
) == 0
4480 && (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
4481 || ELF_ST_BIND (sym
->st_info
) == STB_GNU_UNIQUE
))
4482 elf_tdata (info
->output_bfd
)->has_gnu_symbols
= TRUE
;
4488 /* Given a BFD section, try to locate the corresponding ELF section
4492 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
4493 asection
*sec
, int *index_return
)
4495 if (sec
== &_bfd_elf_large_com_section
)
4497 *index_return
= SHN_X86_64_LCOMMON
;
4503 /* Process a symbol. */
4506 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
4509 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
4511 switch (elfsym
->internal_elf_sym
.st_shndx
)
4513 case SHN_X86_64_LCOMMON
:
4514 asym
->section
= &_bfd_elf_large_com_section
;
4515 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
4516 /* Common symbol doesn't set BSF_GLOBAL. */
4517 asym
->flags
&= ~BSF_GLOBAL
;
4523 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
4525 return (sym
->st_shndx
== SHN_COMMON
4526 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
4530 elf_x86_64_common_section_index (asection
*sec
)
4532 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
4535 return SHN_X86_64_LCOMMON
;
4539 elf_x86_64_common_section (asection
*sec
)
4541 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
4542 return bfd_com_section_ptr
;
4544 return &_bfd_elf_large_com_section
;
4548 elf_x86_64_merge_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4549 struct elf_link_hash_entry
**sym_hash ATTRIBUTE_UNUSED
,
4550 struct elf_link_hash_entry
*h
,
4551 Elf_Internal_Sym
*sym
,
4553 bfd_vma
*pvalue ATTRIBUTE_UNUSED
,
4554 unsigned int *pold_alignment ATTRIBUTE_UNUSED
,
4555 bfd_boolean
*skip ATTRIBUTE_UNUSED
,
4556 bfd_boolean
*override ATTRIBUTE_UNUSED
,
4557 bfd_boolean
*type_change_ok ATTRIBUTE_UNUSED
,
4558 bfd_boolean
*size_change_ok ATTRIBUTE_UNUSED
,
4559 bfd_boolean
*newdyn ATTRIBUTE_UNUSED
,
4560 bfd_boolean
*newdef
,
4561 bfd_boolean
*newdyncommon ATTRIBUTE_UNUSED
,
4562 bfd_boolean
*newweak ATTRIBUTE_UNUSED
,
4563 bfd
*abfd ATTRIBUTE_UNUSED
,
4565 bfd_boolean
*olddyn ATTRIBUTE_UNUSED
,
4566 bfd_boolean
*olddef
,
4567 bfd_boolean
*olddyncommon ATTRIBUTE_UNUSED
,
4568 bfd_boolean
*oldweak ATTRIBUTE_UNUSED
,
4572 /* A normal common symbol and a large common symbol result in a
4573 normal common symbol. We turn the large common symbol into a
4576 && h
->root
.type
== bfd_link_hash_common
4578 && bfd_is_com_section (*sec
)
4581 if (sym
->st_shndx
== SHN_COMMON
4582 && (elf_section_flags (*oldsec
) & SHF_X86_64_LARGE
) != 0)
4584 h
->root
.u
.c
.p
->section
4585 = bfd_make_section_old_way (oldbfd
, "COMMON");
4586 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
4588 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
4589 && (elf_section_flags (*oldsec
) & SHF_X86_64_LARGE
) == 0)
4590 *psec
= *sec
= bfd_com_section_ptr
;
4597 elf_x86_64_additional_program_headers (bfd
*abfd
,
4598 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
4603 /* Check to see if we need a large readonly segment. */
4604 s
= bfd_get_section_by_name (abfd
, ".lrodata");
4605 if (s
&& (s
->flags
& SEC_LOAD
))
4608 /* Check to see if we need a large data segment. Since .lbss sections
4609 is placed right after the .bss section, there should be no need for
4610 a large data segment just because of .lbss. */
4611 s
= bfd_get_section_by_name (abfd
, ".ldata");
4612 if (s
&& (s
->flags
& SEC_LOAD
))
4618 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
4621 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
4623 if (h
->plt
.offset
!= (bfd_vma
) -1
4625 && !h
->pointer_equality_needed
)
4628 return _bfd_elf_hash_symbol (h
);
4631 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
4634 elf_x86_64_relocs_compatible (const bfd_target
*input
,
4635 const bfd_target
*output
)
4637 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
4638 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
4639 && _bfd_elf_relocs_compatible (input
, output
));
4642 static const struct bfd_elf_special_section
4643 elf_x86_64_special_sections
[]=
4645 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
4646 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
4647 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
4648 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
4649 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
4650 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
4651 { NULL
, 0, 0, 0, 0 }
4654 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_vec
4655 #define TARGET_LITTLE_NAME "elf64-x86-64"
4656 #define ELF_ARCH bfd_arch_i386
4657 #define ELF_TARGET_ID X86_64_ELF_DATA
4658 #define ELF_MACHINE_CODE EM_X86_64
4659 #define ELF_MAXPAGESIZE 0x200000
4660 #define ELF_MINPAGESIZE 0x1000
4661 #define ELF_COMMONPAGESIZE 0x1000
4663 #define elf_backend_can_gc_sections 1
4664 #define elf_backend_can_refcount 1
4665 #define elf_backend_want_got_plt 1
4666 #define elf_backend_plt_readonly 1
4667 #define elf_backend_want_plt_sym 0
4668 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
4669 #define elf_backend_rela_normal 1
4671 #define elf_info_to_howto elf_x86_64_info_to_howto
4673 #define bfd_elf64_bfd_link_hash_table_create \
4674 elf_x86_64_link_hash_table_create
4675 #define bfd_elf64_bfd_link_hash_table_free \
4676 elf_x86_64_link_hash_table_free
4677 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
4678 #define bfd_elf64_bfd_reloc_name_lookup \
4679 elf_x86_64_reloc_name_lookup
4681 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
4682 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
4683 #define elf_backend_check_relocs elf_x86_64_check_relocs
4684 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
4685 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
4686 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
4687 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
4688 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
4689 #define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
4690 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
4691 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
4692 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
4693 #define elf_backend_relocate_section elf_x86_64_relocate_section
4694 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
4695 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
4696 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
4697 #define elf_backend_plt_sym_val elf_x86_64_plt_sym_val
4698 #define elf_backend_object_p elf64_x86_64_elf_object_p
4699 #define bfd_elf64_mkobject elf_x86_64_mkobject
4701 #define elf_backend_section_from_shdr \
4702 elf_x86_64_section_from_shdr
4704 #define elf_backend_section_from_bfd_section \
4705 elf_x86_64_elf_section_from_bfd_section
4706 #define elf_backend_add_symbol_hook \
4707 elf_x86_64_add_symbol_hook
4708 #define elf_backend_symbol_processing \
4709 elf_x86_64_symbol_processing
4710 #define elf_backend_common_section_index \
4711 elf_x86_64_common_section_index
4712 #define elf_backend_common_section \
4713 elf_x86_64_common_section
4714 #define elf_backend_common_definition \
4715 elf_x86_64_common_definition
4716 #define elf_backend_merge_symbol \
4717 elf_x86_64_merge_symbol
4718 #define elf_backend_special_sections \
4719 elf_x86_64_special_sections
4720 #define elf_backend_additional_program_headers \
4721 elf_x86_64_additional_program_headers
4722 #define elf_backend_hash_symbol \
4723 elf_x86_64_hash_symbol
4725 #undef elf_backend_post_process_headers
4726 #define elf_backend_post_process_headers _bfd_elf_set_osabi
4728 #include "elf64-target.h"
4730 /* FreeBSD support. */
4732 #undef TARGET_LITTLE_SYM
4733 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_freebsd_vec
4734 #undef TARGET_LITTLE_NAME
4735 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
4738 #define ELF_OSABI ELFOSABI_FREEBSD
4741 #define elf64_bed elf64_x86_64_fbsd_bed
4743 #include "elf64-target.h"
4745 /* Solaris 2 support. */
4747 #undef TARGET_LITTLE_SYM
4748 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_sol2_vec
4749 #undef TARGET_LITTLE_NAME
4750 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
4752 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
4753 objects won't be recognized. */
4757 #define elf64_bed elf64_x86_64_sol2_bed
4759 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
4761 #undef elf_backend_static_tls_alignment
4762 #define elf_backend_static_tls_alignment 16
4764 /* The Solaris 2 ABI requires a plt symbol on all platforms.
4766 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
4768 #undef elf_backend_want_plt_sym
4769 #define elf_backend_want_plt_sym 1
4771 #include "elf64-target.h"
4773 /* Intel L1OM support. */
4776 elf64_l1om_elf_object_p (bfd
*abfd
)
4778 /* Set the right machine number for an L1OM elf64 file. */
4779 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
4783 #undef TARGET_LITTLE_SYM
4784 #define TARGET_LITTLE_SYM bfd_elf64_l1om_vec
4785 #undef TARGET_LITTLE_NAME
4786 #define TARGET_LITTLE_NAME "elf64-l1om"
4788 #define ELF_ARCH bfd_arch_l1om
4790 #undef ELF_MACHINE_CODE
4791 #define ELF_MACHINE_CODE EM_L1OM
4796 #define elf64_bed elf64_l1om_bed
4798 #undef elf_backend_object_p
4799 #define elf_backend_object_p elf64_l1om_elf_object_p
4801 #undef elf_backend_post_process_headers
4802 #undef elf_backend_static_tls_alignment
4804 #undef elf_backend_want_plt_sym
4805 #define elf_backend_want_plt_sym 0
4807 #include "elf64-target.h"
4809 /* FreeBSD L1OM support. */
4811 #undef TARGET_LITTLE_SYM
4812 #define TARGET_LITTLE_SYM bfd_elf64_l1om_freebsd_vec
4813 #undef TARGET_LITTLE_NAME
4814 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
4817 #define ELF_OSABI ELFOSABI_FREEBSD
4820 #define elf64_bed elf64_l1om_fbsd_bed
4822 #undef elf_backend_post_process_headers
4823 #define elf_backend_post_process_headers _bfd_elf_set_osabi
4825 #include "elf64-target.h"
4827 /* 32bit x86-64 support. */
4830 elf32_x86_64_elf_object_p (bfd
*abfd
)
4832 /* Set the right machine number for an x86-64 elf32 file. */
4833 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
4837 #undef TARGET_LITTLE_SYM
4838 #define TARGET_LITTLE_SYM bfd_elf32_x86_64_vec
4839 #undef TARGET_LITTLE_NAME
4840 #define TARGET_LITTLE_NAME "elf32-x86-64"
4843 #define ELF_ARCH bfd_arch_i386
4845 #undef ELF_MACHINE_CODE
4846 #define ELF_MACHINE_CODE EM_X86_64
4848 #define bfd_elf32_bfd_link_hash_table_create \
4849 elf_x86_64_link_hash_table_create
4850 #define bfd_elf32_bfd_link_hash_table_free \
4851 elf_x86_64_link_hash_table_free
4852 #define bfd_elf32_bfd_reloc_type_lookup \
4853 elf_x86_64_reloc_type_lookup
4854 #define bfd_elf32_bfd_reloc_name_lookup \
4855 elf_x86_64_reloc_name_lookup
4856 #define bfd_elf32_mkobject \
4861 #undef elf_backend_post_process_headers
4863 #undef elf_backend_object_p
4864 #define elf_backend_object_p \
4865 elf32_x86_64_elf_object_p
4867 #undef elf_backend_bfd_from_remote_memory
4868 #define elf_backend_bfd_from_remote_memory \
4869 _bfd_elf32_bfd_from_remote_memory
4871 #undef elf_backend_size_info
4872 #define elf_backend_size_info \
4873 _bfd_elf32_size_info
4875 #include "elf32-target.h"