1 /* X86-64 specific support for ELF
2 Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
3 2010 Free Software Foundation, Inc.
4 Contributed by Jan Hubicka <jh@suse.cz>.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
28 #include "bfd_stdint.h"
32 #include "elf/x86-64.h"
34 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
35 #define MINUS_ONE (~ (bfd_vma) 0)
37 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
38 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
39 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
40 since they are the same. */
42 #define ABI_64_P(abfd) \
43 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
45 /* The relocation "howto" table. Order of fields:
46 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
47 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
48 static reloc_howto_type x86_64_elf_howto_table
[] =
50 HOWTO(R_X86_64_NONE
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
51 bfd_elf_generic_reloc
, "R_X86_64_NONE", FALSE
, 0x00000000, 0x00000000,
53 HOWTO(R_X86_64_64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
54 bfd_elf_generic_reloc
, "R_X86_64_64", FALSE
, MINUS_ONE
, MINUS_ONE
,
56 HOWTO(R_X86_64_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
57 bfd_elf_generic_reloc
, "R_X86_64_PC32", FALSE
, 0xffffffff, 0xffffffff,
59 HOWTO(R_X86_64_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
60 bfd_elf_generic_reloc
, "R_X86_64_GOT32", FALSE
, 0xffffffff, 0xffffffff,
62 HOWTO(R_X86_64_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
63 bfd_elf_generic_reloc
, "R_X86_64_PLT32", FALSE
, 0xffffffff, 0xffffffff,
65 HOWTO(R_X86_64_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
66 bfd_elf_generic_reloc
, "R_X86_64_COPY", FALSE
, 0xffffffff, 0xffffffff,
68 HOWTO(R_X86_64_GLOB_DAT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
69 bfd_elf_generic_reloc
, "R_X86_64_GLOB_DAT", FALSE
, MINUS_ONE
,
71 HOWTO(R_X86_64_JUMP_SLOT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
72 bfd_elf_generic_reloc
, "R_X86_64_JUMP_SLOT", FALSE
, MINUS_ONE
,
74 HOWTO(R_X86_64_RELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
75 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE", FALSE
, MINUS_ONE
,
77 HOWTO(R_X86_64_GOTPCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
78 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL", FALSE
, 0xffffffff,
80 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
81 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
83 HOWTO(R_X86_64_32S
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
84 bfd_elf_generic_reloc
, "R_X86_64_32S", FALSE
, 0xffffffff, 0xffffffff,
86 HOWTO(R_X86_64_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
87 bfd_elf_generic_reloc
, "R_X86_64_16", FALSE
, 0xffff, 0xffff, FALSE
),
88 HOWTO(R_X86_64_PC16
,0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
89 bfd_elf_generic_reloc
, "R_X86_64_PC16", FALSE
, 0xffff, 0xffff, TRUE
),
90 HOWTO(R_X86_64_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
91 bfd_elf_generic_reloc
, "R_X86_64_8", FALSE
, 0xff, 0xff, FALSE
),
92 HOWTO(R_X86_64_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
93 bfd_elf_generic_reloc
, "R_X86_64_PC8", FALSE
, 0xff, 0xff, TRUE
),
94 HOWTO(R_X86_64_DTPMOD64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
95 bfd_elf_generic_reloc
, "R_X86_64_DTPMOD64", FALSE
, MINUS_ONE
,
97 HOWTO(R_X86_64_DTPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
98 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF64", FALSE
, MINUS_ONE
,
100 HOWTO(R_X86_64_TPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
101 bfd_elf_generic_reloc
, "R_X86_64_TPOFF64", FALSE
, MINUS_ONE
,
103 HOWTO(R_X86_64_TLSGD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
104 bfd_elf_generic_reloc
, "R_X86_64_TLSGD", FALSE
, 0xffffffff,
106 HOWTO(R_X86_64_TLSLD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
107 bfd_elf_generic_reloc
, "R_X86_64_TLSLD", FALSE
, 0xffffffff,
109 HOWTO(R_X86_64_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
110 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF32", FALSE
, 0xffffffff,
112 HOWTO(R_X86_64_GOTTPOFF
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
113 bfd_elf_generic_reloc
, "R_X86_64_GOTTPOFF", FALSE
, 0xffffffff,
115 HOWTO(R_X86_64_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
116 bfd_elf_generic_reloc
, "R_X86_64_TPOFF32", FALSE
, 0xffffffff,
118 HOWTO(R_X86_64_PC64
, 0, 4, 64, TRUE
, 0, complain_overflow_bitfield
,
119 bfd_elf_generic_reloc
, "R_X86_64_PC64", FALSE
, MINUS_ONE
, MINUS_ONE
,
121 HOWTO(R_X86_64_GOTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
122 bfd_elf_generic_reloc
, "R_X86_64_GOTOFF64",
123 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
124 HOWTO(R_X86_64_GOTPC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
125 bfd_elf_generic_reloc
, "R_X86_64_GOTPC32",
126 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
127 HOWTO(R_X86_64_GOT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
128 bfd_elf_generic_reloc
, "R_X86_64_GOT64", FALSE
, MINUS_ONE
, MINUS_ONE
,
130 HOWTO(R_X86_64_GOTPCREL64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
131 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL64", FALSE
, MINUS_ONE
,
133 HOWTO(R_X86_64_GOTPC64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
134 bfd_elf_generic_reloc
, "R_X86_64_GOTPC64",
135 FALSE
, MINUS_ONE
, MINUS_ONE
, TRUE
),
136 HOWTO(R_X86_64_GOTPLT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
137 bfd_elf_generic_reloc
, "R_X86_64_GOTPLT64", FALSE
, MINUS_ONE
,
139 HOWTO(R_X86_64_PLTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
140 bfd_elf_generic_reloc
, "R_X86_64_PLTOFF64", FALSE
, MINUS_ONE
,
144 HOWTO(R_X86_64_GOTPC32_TLSDESC
, 0, 2, 32, TRUE
, 0,
145 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
146 "R_X86_64_GOTPC32_TLSDESC",
147 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
148 HOWTO(R_X86_64_TLSDESC_CALL
, 0, 0, 0, FALSE
, 0,
149 complain_overflow_dont
, bfd_elf_generic_reloc
,
150 "R_X86_64_TLSDESC_CALL",
152 HOWTO(R_X86_64_TLSDESC
, 0, 4, 64, FALSE
, 0,
153 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
155 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
156 HOWTO(R_X86_64_IRELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
157 bfd_elf_generic_reloc
, "R_X86_64_IRELATIVE", FALSE
, MINUS_ONE
,
160 /* We have a gap in the reloc numbers here.
161 R_X86_64_standard counts the number up to this point, and
162 R_X86_64_vt_offset is the value to subtract from a reloc type of
163 R_X86_64_GNU_VT* to form an index into this table. */
164 #define R_X86_64_standard (R_X86_64_IRELATIVE + 1)
165 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
167 /* GNU extension to record C++ vtable hierarchy. */
168 HOWTO (R_X86_64_GNU_VTINHERIT
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
169 NULL
, "R_X86_64_GNU_VTINHERIT", FALSE
, 0, 0, FALSE
),
171 /* GNU extension to record C++ vtable member usage. */
172 HOWTO (R_X86_64_GNU_VTENTRY
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
173 _bfd_elf_rel_vtable_reloc_fn
, "R_X86_64_GNU_VTENTRY", FALSE
, 0, 0,
177 #define IS_X86_64_PCREL_TYPE(TYPE) \
178 ( ((TYPE) == R_X86_64_PC8) \
179 || ((TYPE) == R_X86_64_PC16) \
180 || ((TYPE) == R_X86_64_PC32) \
181 || ((TYPE) == R_X86_64_PC64))
183 /* Map BFD relocs to the x86_64 elf relocs. */
186 bfd_reloc_code_real_type bfd_reloc_val
;
187 unsigned char elf_reloc_val
;
190 static const struct elf_reloc_map x86_64_reloc_map
[] =
192 { BFD_RELOC_NONE
, R_X86_64_NONE
, },
193 { BFD_RELOC_64
, R_X86_64_64
, },
194 { BFD_RELOC_32_PCREL
, R_X86_64_PC32
, },
195 { BFD_RELOC_X86_64_GOT32
, R_X86_64_GOT32
,},
196 { BFD_RELOC_X86_64_PLT32
, R_X86_64_PLT32
,},
197 { BFD_RELOC_X86_64_COPY
, R_X86_64_COPY
, },
198 { BFD_RELOC_X86_64_GLOB_DAT
, R_X86_64_GLOB_DAT
, },
199 { BFD_RELOC_X86_64_JUMP_SLOT
, R_X86_64_JUMP_SLOT
, },
200 { BFD_RELOC_X86_64_RELATIVE
, R_X86_64_RELATIVE
, },
201 { BFD_RELOC_X86_64_GOTPCREL
, R_X86_64_GOTPCREL
, },
202 { BFD_RELOC_32
, R_X86_64_32
, },
203 { BFD_RELOC_X86_64_32S
, R_X86_64_32S
, },
204 { BFD_RELOC_16
, R_X86_64_16
, },
205 { BFD_RELOC_16_PCREL
, R_X86_64_PC16
, },
206 { BFD_RELOC_8
, R_X86_64_8
, },
207 { BFD_RELOC_8_PCREL
, R_X86_64_PC8
, },
208 { BFD_RELOC_X86_64_DTPMOD64
, R_X86_64_DTPMOD64
, },
209 { BFD_RELOC_X86_64_DTPOFF64
, R_X86_64_DTPOFF64
, },
210 { BFD_RELOC_X86_64_TPOFF64
, R_X86_64_TPOFF64
, },
211 { BFD_RELOC_X86_64_TLSGD
, R_X86_64_TLSGD
, },
212 { BFD_RELOC_X86_64_TLSLD
, R_X86_64_TLSLD
, },
213 { BFD_RELOC_X86_64_DTPOFF32
, R_X86_64_DTPOFF32
, },
214 { BFD_RELOC_X86_64_GOTTPOFF
, R_X86_64_GOTTPOFF
, },
215 { BFD_RELOC_X86_64_TPOFF32
, R_X86_64_TPOFF32
, },
216 { BFD_RELOC_64_PCREL
, R_X86_64_PC64
, },
217 { BFD_RELOC_X86_64_GOTOFF64
, R_X86_64_GOTOFF64
, },
218 { BFD_RELOC_X86_64_GOTPC32
, R_X86_64_GOTPC32
, },
219 { BFD_RELOC_X86_64_GOT64
, R_X86_64_GOT64
, },
220 { BFD_RELOC_X86_64_GOTPCREL64
,R_X86_64_GOTPCREL64
, },
221 { BFD_RELOC_X86_64_GOTPC64
, R_X86_64_GOTPC64
, },
222 { BFD_RELOC_X86_64_GOTPLT64
, R_X86_64_GOTPLT64
, },
223 { BFD_RELOC_X86_64_PLTOFF64
, R_X86_64_PLTOFF64
, },
224 { BFD_RELOC_X86_64_GOTPC32_TLSDESC
, R_X86_64_GOTPC32_TLSDESC
, },
225 { BFD_RELOC_X86_64_TLSDESC_CALL
, R_X86_64_TLSDESC_CALL
, },
226 { BFD_RELOC_X86_64_TLSDESC
, R_X86_64_TLSDESC
, },
227 { BFD_RELOC_X86_64_IRELATIVE
, R_X86_64_IRELATIVE
, },
228 { BFD_RELOC_VTABLE_INHERIT
, R_X86_64_GNU_VTINHERIT
, },
229 { BFD_RELOC_VTABLE_ENTRY
, R_X86_64_GNU_VTENTRY
, },
232 static reloc_howto_type
*
233 elf_x86_64_rtype_to_howto (bfd
*abfd
, unsigned r_type
)
237 if (r_type
< (unsigned int) R_X86_64_GNU_VTINHERIT
238 || r_type
>= (unsigned int) R_X86_64_max
)
240 if (r_type
>= (unsigned int) R_X86_64_standard
)
242 (*_bfd_error_handler
) (_("%B: invalid relocation type %d"),
244 r_type
= R_X86_64_NONE
;
249 i
= r_type
- (unsigned int) R_X86_64_vt_offset
;
250 BFD_ASSERT (x86_64_elf_howto_table
[i
].type
== r_type
);
251 return &x86_64_elf_howto_table
[i
];
254 /* Given a BFD reloc type, return a HOWTO structure. */
255 static reloc_howto_type
*
256 elf_x86_64_reloc_type_lookup (bfd
*abfd
,
257 bfd_reloc_code_real_type code
)
261 for (i
= 0; i
< sizeof (x86_64_reloc_map
) / sizeof (struct elf_reloc_map
);
264 if (x86_64_reloc_map
[i
].bfd_reloc_val
== code
)
265 return elf_x86_64_rtype_to_howto (abfd
,
266 x86_64_reloc_map
[i
].elf_reloc_val
);
271 static reloc_howto_type
*
272 elf_x86_64_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
278 i
< (sizeof (x86_64_elf_howto_table
)
279 / sizeof (x86_64_elf_howto_table
[0]));
281 if (x86_64_elf_howto_table
[i
].name
!= NULL
282 && strcasecmp (x86_64_elf_howto_table
[i
].name
, r_name
) == 0)
283 return &x86_64_elf_howto_table
[i
];
288 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
291 elf_x86_64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
292 Elf_Internal_Rela
*dst
)
296 r_type
= ELF32_R_TYPE (dst
->r_info
);
297 cache_ptr
->howto
= elf_x86_64_rtype_to_howto (abfd
, r_type
);
298 BFD_ASSERT (r_type
== cache_ptr
->howto
->type
);
301 /* Support for core dump NOTE sections. */
303 elf_x86_64_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
308 switch (note
->descsz
)
313 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
315 elf_tdata (abfd
)->core_signal
316 = bfd_get_16 (abfd
, note
->descdata
+ 12);
319 elf_tdata (abfd
)->core_lwpid
320 = bfd_get_32 (abfd
, note
->descdata
+ 32);
329 /* Make a ".reg/999" section. */
330 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
331 size
, note
->descpos
+ offset
);
335 elf_x86_64_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
337 switch (note
->descsz
)
342 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
343 elf_tdata (abfd
)->core_pid
344 = bfd_get_32 (abfd
, note
->descdata
+ 24);
345 elf_tdata (abfd
)->core_program
346 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
347 elf_tdata (abfd
)->core_command
348 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
351 /* Note that for some reason, a spurious space is tacked
352 onto the end of the args in some (at least one anyway)
353 implementations, so strip it off if it exists. */
356 char *command
= elf_tdata (abfd
)->core_command
;
357 int n
= strlen (command
);
359 if (0 < n
&& command
[n
- 1] == ' ')
360 command
[n
- 1] = '\0';
366 /* Functions for the x86-64 ELF linker. */
368 /* The name of the dynamic interpreter. This is put in the .interp
371 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
372 #define ELF32_DYNAMIC_INTERPRETER "/lib/ld32.so.1"
374 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
375 copying dynamic variables from a shared lib into an app's dynbss
376 section, and instead use a dynamic relocation to point into the
378 #define ELIMINATE_COPY_RELOCS 1
380 /* The size in bytes of an entry in the global offset table. */
382 #define GOT_ENTRY_SIZE 8
384 /* The size in bytes of an entry in the procedure linkage table. */
386 #define PLT_ENTRY_SIZE 16
388 /* The first entry in a procedure linkage table looks like this. See the
389 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
391 static const bfd_byte elf_x86_64_plt0_entry
[PLT_ENTRY_SIZE
] =
393 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
394 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
395 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
398 /* Subsequent entries in a procedure linkage table look like this. */
400 static const bfd_byte elf_x86_64_plt_entry
[PLT_ENTRY_SIZE
] =
402 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
403 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
404 0x68, /* pushq immediate */
405 0, 0, 0, 0, /* replaced with index into relocation table. */
406 0xe9, /* jmp relative */
407 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
410 /* x86-64 ELF linker hash entry. */
412 struct elf_x86_64_link_hash_entry
414 struct elf_link_hash_entry elf
;
416 /* Track dynamic relocs copied for this symbol. */
417 struct elf_dyn_relocs
*dyn_relocs
;
419 #define GOT_UNKNOWN 0
423 #define GOT_TLS_GDESC 4
424 #define GOT_TLS_GD_BOTH_P(type) \
425 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
426 #define GOT_TLS_GD_P(type) \
427 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
428 #define GOT_TLS_GDESC_P(type) \
429 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
430 #define GOT_TLS_GD_ANY_P(type) \
431 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
432 unsigned char tls_type
;
434 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
435 starting at the end of the jump table. */
439 #define elf_x86_64_hash_entry(ent) \
440 ((struct elf_x86_64_link_hash_entry *)(ent))
442 struct elf_x86_64_obj_tdata
444 struct elf_obj_tdata root
;
446 /* tls_type for each local got entry. */
447 char *local_got_tls_type
;
449 /* GOTPLT entries for TLS descriptors. */
450 bfd_vma
*local_tlsdesc_gotent
;
453 #define elf_x86_64_tdata(abfd) \
454 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
456 #define elf_x86_64_local_got_tls_type(abfd) \
457 (elf_x86_64_tdata (abfd)->local_got_tls_type)
459 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
460 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
462 #define is_x86_64_elf(bfd) \
463 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
464 && elf_tdata (bfd) != NULL \
465 && elf_object_id (bfd) == X86_64_ELF_DATA)
468 elf_x86_64_mkobject (bfd
*abfd
)
470 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_x86_64_obj_tdata
),
474 /* x86-64 ELF linker hash table. */
476 struct elf_x86_64_link_hash_table
478 struct elf_link_hash_table elf
;
480 /* Short-cuts to get to dynamic linker sections. */
486 bfd_signed_vma refcount
;
490 /* The amount of space used by the jump slots in the GOT. */
491 bfd_vma sgotplt_jump_table_size
;
493 /* Small local sym cache. */
494 struct sym_cache sym_cache
;
496 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
497 bfd_vma (*r_sym
) (bfd_vma
);
498 const char *dynamic_interpreter
;
499 int dynamic_interpreter_size
;
501 /* _TLS_MODULE_BASE_ symbol. */
502 struct bfd_link_hash_entry
*tls_module_base
;
504 /* Used by local STT_GNU_IFUNC symbols. */
505 htab_t loc_hash_table
;
506 void * loc_hash_memory
;
508 /* The offset into splt of the PLT entry for the TLS descriptor
509 resolver. Special values are 0, if not necessary (or not found
510 to be necessary yet), and -1 if needed but not determined
513 /* The offset into sgot of the GOT entry used by the PLT entry
518 /* Get the x86-64 ELF linker hash table from a link_info structure. */
520 #define elf_x86_64_hash_table(p) \
521 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
522 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
524 #define elf_x86_64_compute_jump_table_size(htab) \
525 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
527 /* Create an entry in an x86-64 ELF linker hash table. */
529 static struct bfd_hash_entry
*
530 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
531 struct bfd_hash_table
*table
,
534 /* Allocate the structure if it has not already been allocated by a
538 entry
= (struct bfd_hash_entry
*)
539 bfd_hash_allocate (table
,
540 sizeof (struct elf_x86_64_link_hash_entry
));
545 /* Call the allocation method of the superclass. */
546 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
549 struct elf_x86_64_link_hash_entry
*eh
;
551 eh
= (struct elf_x86_64_link_hash_entry
*) entry
;
552 eh
->dyn_relocs
= NULL
;
553 eh
->tls_type
= GOT_UNKNOWN
;
554 eh
->tlsdesc_got
= (bfd_vma
) -1;
560 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
561 for local symbol so that we can handle local STT_GNU_IFUNC symbols
562 as global symbol. We reuse indx and dynstr_index for local symbol
563 hash since they aren't used by global symbols in this backend. */
566 elf_x86_64_local_htab_hash (const void *ptr
)
568 struct elf_link_hash_entry
*h
569 = (struct elf_link_hash_entry
*) ptr
;
570 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
573 /* Compare local hash entries. */
576 elf_x86_64_local_htab_eq (const void *ptr1
, const void *ptr2
)
578 struct elf_link_hash_entry
*h1
579 = (struct elf_link_hash_entry
*) ptr1
;
580 struct elf_link_hash_entry
*h2
581 = (struct elf_link_hash_entry
*) ptr2
;
583 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
586 /* Find and/or create a hash entry for local symbol. */
588 static struct elf_link_hash_entry
*
589 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table
*htab
,
590 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
593 struct elf_x86_64_link_hash_entry e
, *ret
;
594 asection
*sec
= abfd
->sections
;
595 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
596 htab
->r_sym (rel
->r_info
));
599 e
.elf
.indx
= sec
->id
;
600 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
601 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
602 create
? INSERT
: NO_INSERT
);
609 ret
= (struct elf_x86_64_link_hash_entry
*) *slot
;
613 ret
= (struct elf_x86_64_link_hash_entry
*)
614 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
615 sizeof (struct elf_x86_64_link_hash_entry
));
618 memset (ret
, 0, sizeof (*ret
));
619 ret
->elf
.indx
= sec
->id
;
620 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
621 ret
->elf
.dynindx
= -1;
627 /* Create an X86-64 ELF linker hash table. */
629 static struct bfd_link_hash_table
*
630 elf_x86_64_link_hash_table_create (bfd
*abfd
)
632 struct elf_x86_64_link_hash_table
*ret
;
633 bfd_size_type amt
= sizeof (struct elf_x86_64_link_hash_table
);
635 ret
= (struct elf_x86_64_link_hash_table
*) bfd_malloc (amt
);
639 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
640 elf_x86_64_link_hash_newfunc
,
641 sizeof (struct elf_x86_64_link_hash_entry
),
650 ret
->sym_cache
.abfd
= NULL
;
651 ret
->tlsdesc_plt
= 0;
652 ret
->tlsdesc_got
= 0;
653 ret
->tls_ld_got
.refcount
= 0;
654 ret
->sgotplt_jump_table_size
= 0;
655 ret
->tls_module_base
= NULL
;
659 ret
->r_info
= elf64_r_info
;
660 ret
->r_sym
= elf64_r_sym
;
661 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
662 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
666 ret
->r_info
= elf32_r_info
;
667 ret
->r_sym
= elf32_r_sym
;
668 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
669 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
672 ret
->loc_hash_table
= htab_try_create (1024,
673 elf_x86_64_local_htab_hash
,
674 elf_x86_64_local_htab_eq
,
676 ret
->loc_hash_memory
= objalloc_create ();
677 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
683 return &ret
->elf
.root
;
686 /* Destroy an X86-64 ELF linker hash table. */
689 elf_x86_64_link_hash_table_free (struct bfd_link_hash_table
*hash
)
691 struct elf_x86_64_link_hash_table
*htab
692 = (struct elf_x86_64_link_hash_table
*) hash
;
694 if (htab
->loc_hash_table
)
695 htab_delete (htab
->loc_hash_table
);
696 if (htab
->loc_hash_memory
)
697 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
698 _bfd_generic_link_hash_table_free (hash
);
701 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
702 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
706 elf_x86_64_create_dynamic_sections (bfd
*dynobj
,
707 struct bfd_link_info
*info
)
709 struct elf_x86_64_link_hash_table
*htab
;
711 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
714 htab
= elf_x86_64_hash_table (info
);
718 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
720 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rela.bss");
723 || (!info
->shared
&& !htab
->srelbss
))
729 /* Copy the extra info we tack onto an elf_link_hash_entry. */
732 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
733 struct elf_link_hash_entry
*dir
,
734 struct elf_link_hash_entry
*ind
)
736 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
738 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
739 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
741 if (eind
->dyn_relocs
!= NULL
)
743 if (edir
->dyn_relocs
!= NULL
)
745 struct elf_dyn_relocs
**pp
;
746 struct elf_dyn_relocs
*p
;
748 /* Add reloc counts against the indirect sym to the direct sym
749 list. Merge any entries against the same section. */
750 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
752 struct elf_dyn_relocs
*q
;
754 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
755 if (q
->sec
== p
->sec
)
757 q
->pc_count
+= p
->pc_count
;
758 q
->count
+= p
->count
;
765 *pp
= edir
->dyn_relocs
;
768 edir
->dyn_relocs
= eind
->dyn_relocs
;
769 eind
->dyn_relocs
= NULL
;
772 if (ind
->root
.type
== bfd_link_hash_indirect
773 && dir
->got
.refcount
<= 0)
775 edir
->tls_type
= eind
->tls_type
;
776 eind
->tls_type
= GOT_UNKNOWN
;
779 if (ELIMINATE_COPY_RELOCS
780 && ind
->root
.type
!= bfd_link_hash_indirect
781 && dir
->dynamic_adjusted
)
783 /* If called to transfer flags for a weakdef during processing
784 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
785 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
786 dir
->ref_dynamic
|= ind
->ref_dynamic
;
787 dir
->ref_regular
|= ind
->ref_regular
;
788 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
789 dir
->needs_plt
|= ind
->needs_plt
;
790 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
793 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
797 elf64_x86_64_elf_object_p (bfd
*abfd
)
799 /* Set the right machine number for an x86-64 elf64 file. */
800 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
818 /* Return TRUE if the TLS access code sequence support transition
822 elf_x86_64_check_tls_transition (bfd
*abfd
,
823 struct bfd_link_info
*info
,
826 Elf_Internal_Shdr
*symtab_hdr
,
827 struct elf_link_hash_entry
**sym_hashes
,
829 const Elf_Internal_Rela
*rel
,
830 const Elf_Internal_Rela
*relend
)
833 unsigned long r_symndx
;
834 struct elf_link_hash_entry
*h
;
836 struct elf_x86_64_link_hash_table
*htab
;
838 /* Get the section contents. */
839 if (contents
== NULL
)
841 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
842 contents
= elf_section_data (sec
)->this_hdr
.contents
;
845 /* FIXME: How to better handle error condition? */
846 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
849 /* Cache the section contents for elf_link_input_bfd. */
850 elf_section_data (sec
)->this_hdr
.contents
= contents
;
854 htab
= elf_x86_64_hash_table (info
);
855 offset
= rel
->r_offset
;
860 if ((rel
+ 1) >= relend
)
863 if (r_type
== R_X86_64_TLSGD
)
865 /* Check transition from GD access model. Only
866 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
867 .word 0x6666; rex64; call __tls_get_addr
868 can transit to different access model. */
870 static x86_64_opcode32 leaq
= { { 0x66, 0x48, 0x8d, 0x3d } },
871 call
= { { 0x66, 0x66, 0x48, 0xe8 } };
873 || (offset
+ 12) > sec
->size
874 || bfd_get_32 (abfd
, contents
+ offset
- 4) != leaq
.i
875 || bfd_get_32 (abfd
, contents
+ offset
+ 4) != call
.i
)
880 /* Check transition from LD access model. Only
881 leaq foo@tlsld(%rip), %rdi;
883 can transit to different access model. */
885 static x86_64_opcode32 ld
= { { 0x48, 0x8d, 0x3d, 0xe8 } };
888 if (offset
< 3 || (offset
+ 9) > sec
->size
)
891 op
.i
= bfd_get_32 (abfd
, contents
+ offset
- 3);
892 op
.c
[3] = bfd_get_8 (abfd
, contents
+ offset
+ 4);
897 r_symndx
= htab
->r_sym (rel
[1].r_info
);
898 if (r_symndx
< symtab_hdr
->sh_info
)
901 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
902 /* Use strncmp to check __tls_get_addr since __tls_get_addr
905 && h
->root
.root
.string
!= NULL
906 && (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
907 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
)
908 && (strncmp (h
->root
.root
.string
,
909 "__tls_get_addr", 14) == 0));
911 case R_X86_64_GOTTPOFF
:
912 /* Check transition from IE access model:
913 movq foo@gottpoff(%rip), %reg
914 addq foo@gottpoff(%rip), %reg
917 if (offset
< 3 || (offset
+ 4) > sec
->size
)
920 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
921 if (val
!= 0x48 && val
!= 0x4c)
924 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
925 if (val
!= 0x8b && val
!= 0x03)
928 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
929 return (val
& 0xc7) == 5;
931 case R_X86_64_GOTPC32_TLSDESC
:
932 /* Check transition from GDesc access model:
933 leaq x@tlsdesc(%rip), %rax
935 Make sure it's a leaq adding rip to a 32-bit offset
936 into any register, although it's probably almost always
939 if (offset
< 3 || (offset
+ 4) > sec
->size
)
942 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
943 if ((val
& 0xfb) != 0x48)
946 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
949 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
950 return (val
& 0xc7) == 0x05;
952 case R_X86_64_TLSDESC_CALL
:
953 /* Check transition from GDesc access model:
954 call *x@tlsdesc(%rax)
956 if (offset
+ 2 <= sec
->size
)
958 /* Make sure that it's a call *x@tlsdesc(%rax). */
959 static x86_64_opcode16 call
= { { 0xff, 0x10 } };
960 return bfd_get_16 (abfd
, contents
+ offset
) == call
.i
;
970 /* Return TRUE if the TLS access transition is OK or no transition
971 will be performed. Update R_TYPE if there is a transition. */
974 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
975 asection
*sec
, bfd_byte
*contents
,
976 Elf_Internal_Shdr
*symtab_hdr
,
977 struct elf_link_hash_entry
**sym_hashes
,
978 unsigned int *r_type
, int tls_type
,
979 const Elf_Internal_Rela
*rel
,
980 const Elf_Internal_Rela
*relend
,
981 struct elf_link_hash_entry
*h
,
982 unsigned long r_symndx
)
984 unsigned int from_type
= *r_type
;
985 unsigned int to_type
= from_type
;
986 bfd_boolean check
= TRUE
;
988 /* Skip TLS transition for functions. */
990 && (h
->type
== STT_FUNC
991 || h
->type
== STT_GNU_IFUNC
))
997 case R_X86_64_GOTPC32_TLSDESC
:
998 case R_X86_64_TLSDESC_CALL
:
999 case R_X86_64_GOTTPOFF
:
1000 if (info
->executable
)
1003 to_type
= R_X86_64_TPOFF32
;
1005 to_type
= R_X86_64_GOTTPOFF
;
1008 /* When we are called from elf_x86_64_relocate_section,
1009 CONTENTS isn't NULL and there may be additional transitions
1010 based on TLS_TYPE. */
1011 if (contents
!= NULL
)
1013 unsigned int new_to_type
= to_type
;
1015 if (info
->executable
1018 && tls_type
== GOT_TLS_IE
)
1019 new_to_type
= R_X86_64_TPOFF32
;
1021 if (to_type
== R_X86_64_TLSGD
1022 || to_type
== R_X86_64_GOTPC32_TLSDESC
1023 || to_type
== R_X86_64_TLSDESC_CALL
)
1025 if (tls_type
== GOT_TLS_IE
)
1026 new_to_type
= R_X86_64_GOTTPOFF
;
1029 /* We checked the transition before when we were called from
1030 elf_x86_64_check_relocs. We only want to check the new
1031 transition which hasn't been checked before. */
1032 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1033 to_type
= new_to_type
;
1038 case R_X86_64_TLSLD
:
1039 if (info
->executable
)
1040 to_type
= R_X86_64_TPOFF32
;
1047 /* Return TRUE if there is no transition. */
1048 if (from_type
== to_type
)
1051 /* Check if the transition can be performed. */
1053 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1054 symtab_hdr
, sym_hashes
,
1055 from_type
, rel
, relend
))
1057 reloc_howto_type
*from
, *to
;
1060 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1061 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1064 name
= h
->root
.root
.string
;
1067 struct elf_x86_64_link_hash_table
*htab
;
1069 htab
= elf_x86_64_hash_table (info
);
1074 Elf_Internal_Sym
*isym
;
1076 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1078 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1082 (*_bfd_error_handler
)
1083 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1084 "in section `%A' failed"),
1085 abfd
, sec
, from
->name
, to
->name
, name
,
1086 (unsigned long) rel
->r_offset
);
1087 bfd_set_error (bfd_error_bad_value
);
1095 /* Look through the relocs for a section during the first phase, and
1096 calculate needed space in the global offset table, procedure
1097 linkage table, and dynamic reloc sections. */
1100 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1102 const Elf_Internal_Rela
*relocs
)
1104 struct elf_x86_64_link_hash_table
*htab
;
1105 Elf_Internal_Shdr
*symtab_hdr
;
1106 struct elf_link_hash_entry
**sym_hashes
;
1107 const Elf_Internal_Rela
*rel
;
1108 const Elf_Internal_Rela
*rel_end
;
1111 if (info
->relocatable
)
1114 BFD_ASSERT (is_x86_64_elf (abfd
));
1116 htab
= elf_x86_64_hash_table (info
);
1120 symtab_hdr
= &elf_symtab_hdr (abfd
);
1121 sym_hashes
= elf_sym_hashes (abfd
);
1125 rel_end
= relocs
+ sec
->reloc_count
;
1126 for (rel
= relocs
; rel
< rel_end
; rel
++)
1128 unsigned int r_type
;
1129 unsigned long r_symndx
;
1130 struct elf_link_hash_entry
*h
;
1131 Elf_Internal_Sym
*isym
;
1134 r_symndx
= htab
->r_sym (rel
->r_info
);
1135 r_type
= ELF32_R_TYPE (rel
->r_info
);
1137 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1139 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1144 if (r_symndx
< symtab_hdr
->sh_info
)
1146 /* A local symbol. */
1147 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1152 /* Check relocation against local STT_GNU_IFUNC symbol. */
1153 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1155 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
1160 /* Fake a STT_GNU_IFUNC symbol. */
1161 h
->type
= STT_GNU_IFUNC
;
1164 h
->forced_local
= 1;
1165 h
->root
.type
= bfd_link_hash_defined
;
1173 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1174 while (h
->root
.type
== bfd_link_hash_indirect
1175 || h
->root
.type
== bfd_link_hash_warning
)
1176 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1181 /* Create the ifunc sections for static executables. If we
1182 never see an indirect function symbol nor we are building
1183 a static executable, those sections will be empty and
1184 won't appear in output. */
1195 case R_X86_64_PLT32
:
1196 case R_X86_64_GOTPCREL
:
1197 case R_X86_64_GOTPCREL64
:
1198 if (!_bfd_elf_create_ifunc_sections (abfd
, info
))
1203 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
1204 it here if it is defined in a non-shared object. */
1205 if (h
->type
== STT_GNU_IFUNC
1208 /* It is referenced by a non-shared object. */
1212 /* STT_GNU_IFUNC symbol must go through PLT. */
1213 h
->plt
.refcount
+= 1;
1215 /* STT_GNU_IFUNC needs dynamic sections. */
1216 if (htab
->elf
.dynobj
== NULL
)
1217 htab
->elf
.dynobj
= abfd
;
1222 if (h
->root
.root
.string
)
1223 name
= h
->root
.root
.string
;
1225 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1227 (*_bfd_error_handler
)
1228 (_("%B: relocation %s against STT_GNU_IFUNC "
1229 "symbol `%s' isn't handled by %s"), abfd
,
1230 x86_64_elf_howto_table
[r_type
].name
,
1231 name
, __FUNCTION__
);
1232 bfd_set_error (bfd_error_bad_value
);
1237 h
->pointer_equality_needed
= 1;
1240 /* We must copy these reloc types into the output
1241 file. Create a reloc section in dynobj and
1242 make room for this reloc. */
1243 sreloc
= _bfd_elf_create_ifunc_dyn_reloc
1244 (abfd
, info
, sec
, sreloc
,
1245 &((struct elf_x86_64_link_hash_entry
*) h
)->dyn_relocs
);
1256 if (r_type
!= R_X86_64_PC32
1257 && r_type
!= R_X86_64_PC64
)
1258 h
->pointer_equality_needed
= 1;
1261 case R_X86_64_PLT32
:
1264 case R_X86_64_GOTPCREL
:
1265 case R_X86_64_GOTPCREL64
:
1266 h
->got
.refcount
+= 1;
1267 if (htab
->elf
.sgot
== NULL
1268 && !_bfd_elf_create_got_section (htab
->elf
.dynobj
,
1278 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
1279 symtab_hdr
, sym_hashes
,
1280 &r_type
, GOT_UNKNOWN
,
1281 rel
, rel_end
, h
, r_symndx
))
1286 case R_X86_64_TLSLD
:
1287 htab
->tls_ld_got
.refcount
+= 1;
1290 case R_X86_64_TPOFF32
:
1291 if (!info
->executable
&& ABI_64_P (abfd
))
1294 name
= h
->root
.root
.string
;
1296 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1298 (*_bfd_error_handler
)
1299 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1301 x86_64_elf_howto_table
[r_type
].name
, name
);
1302 bfd_set_error (bfd_error_bad_value
);
1307 case R_X86_64_GOTTPOFF
:
1308 if (!info
->executable
)
1309 info
->flags
|= DF_STATIC_TLS
;
1312 case R_X86_64_GOT32
:
1313 case R_X86_64_GOTPCREL
:
1314 case R_X86_64_TLSGD
:
1315 case R_X86_64_GOT64
:
1316 case R_X86_64_GOTPCREL64
:
1317 case R_X86_64_GOTPLT64
:
1318 case R_X86_64_GOTPC32_TLSDESC
:
1319 case R_X86_64_TLSDESC_CALL
:
1320 /* This symbol requires a global offset table entry. */
1322 int tls_type
, old_tls_type
;
1326 default: tls_type
= GOT_NORMAL
; break;
1327 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
1328 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
1329 case R_X86_64_GOTPC32_TLSDESC
:
1330 case R_X86_64_TLSDESC_CALL
:
1331 tls_type
= GOT_TLS_GDESC
; break;
1336 if (r_type
== R_X86_64_GOTPLT64
)
1338 /* This relocation indicates that we also need
1339 a PLT entry, as this is a function. We don't need
1340 a PLT entry for local symbols. */
1342 h
->plt
.refcount
+= 1;
1344 h
->got
.refcount
+= 1;
1345 old_tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
1349 bfd_signed_vma
*local_got_refcounts
;
1351 /* This is a global offset table entry for a local symbol. */
1352 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1353 if (local_got_refcounts
== NULL
)
1357 size
= symtab_hdr
->sh_info
;
1358 size
*= sizeof (bfd_signed_vma
)
1359 + sizeof (bfd_vma
) + sizeof (char);
1360 local_got_refcounts
= ((bfd_signed_vma
*)
1361 bfd_zalloc (abfd
, size
));
1362 if (local_got_refcounts
== NULL
)
1364 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1365 elf_x86_64_local_tlsdesc_gotent (abfd
)
1366 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1367 elf_x86_64_local_got_tls_type (abfd
)
1368 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1370 local_got_refcounts
[r_symndx
] += 1;
1372 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
1375 /* If a TLS symbol is accessed using IE at least once,
1376 there is no point to use dynamic model for it. */
1377 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1378 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1379 || tls_type
!= GOT_TLS_IE
))
1381 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
1382 tls_type
= old_tls_type
;
1383 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1384 && GOT_TLS_GD_ANY_P (tls_type
))
1385 tls_type
|= old_tls_type
;
1389 name
= h
->root
.root
.string
;
1391 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
1393 (*_bfd_error_handler
)
1394 (_("%B: '%s' accessed both as normal and thread local symbol"),
1400 if (old_tls_type
!= tls_type
)
1403 elf_x86_64_hash_entry (h
)->tls_type
= tls_type
;
1405 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1410 case R_X86_64_GOTOFF64
:
1411 case R_X86_64_GOTPC32
:
1412 case R_X86_64_GOTPC64
:
1414 if (htab
->elf
.sgot
== NULL
)
1416 if (htab
->elf
.dynobj
== NULL
)
1417 htab
->elf
.dynobj
= abfd
;
1418 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
1424 case R_X86_64_PLT32
:
1425 /* This symbol requires a procedure linkage table entry. We
1426 actually build the entry in adjust_dynamic_symbol,
1427 because this might be a case of linking PIC code which is
1428 never referenced by a dynamic object, in which case we
1429 don't need to generate a procedure linkage table entry
1432 /* If this is a local symbol, we resolve it directly without
1433 creating a procedure linkage table entry. */
1438 h
->plt
.refcount
+= 1;
1441 case R_X86_64_PLTOFF64
:
1442 /* This tries to form the 'address' of a function relative
1443 to GOT. For global symbols we need a PLT entry. */
1447 h
->plt
.refcount
+= 1;
1455 /* Let's help debug shared library creation. These relocs
1456 cannot be used in shared libs. Don't error out for
1457 sections we don't care about, such as debug sections or
1458 non-constant sections. */
1461 && (sec
->flags
& SEC_ALLOC
) != 0
1462 && (sec
->flags
& SEC_READONLY
) != 0)
1465 name
= h
->root
.root
.string
;
1467 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1468 (*_bfd_error_handler
)
1469 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1470 abfd
, x86_64_elf_howto_table
[r_type
].name
, name
);
1471 bfd_set_error (bfd_error_bad_value
);
1481 if (h
!= NULL
&& info
->executable
)
1483 /* If this reloc is in a read-only section, we might
1484 need a copy reloc. We can't check reliably at this
1485 stage whether the section is read-only, as input
1486 sections have not yet been mapped to output sections.
1487 Tentatively set the flag for now, and correct in
1488 adjust_dynamic_symbol. */
1491 /* We may need a .plt entry if the function this reloc
1492 refers to is in a shared lib. */
1493 h
->plt
.refcount
+= 1;
1494 if (r_type
!= R_X86_64_PC32
&& r_type
!= R_X86_64_PC64
)
1495 h
->pointer_equality_needed
= 1;
1498 /* If we are creating a shared library, and this is a reloc
1499 against a global symbol, or a non PC relative reloc
1500 against a local symbol, then we need to copy the reloc
1501 into the shared library. However, if we are linking with
1502 -Bsymbolic, we do not need to copy a reloc against a
1503 global symbol which is defined in an object we are
1504 including in the link (i.e., DEF_REGULAR is set). At
1505 this point we have not seen all the input files, so it is
1506 possible that DEF_REGULAR is not set now but will be set
1507 later (it is never cleared). In case of a weak definition,
1508 DEF_REGULAR may be cleared later by a strong definition in
1509 a shared library. We account for that possibility below by
1510 storing information in the relocs_copied field of the hash
1511 table entry. A similar situation occurs when creating
1512 shared libraries and symbol visibility changes render the
1515 If on the other hand, we are creating an executable, we
1516 may need to keep relocations for symbols satisfied by a
1517 dynamic library if we manage to avoid copy relocs for the
1520 && (sec
->flags
& SEC_ALLOC
) != 0
1521 && (! IS_X86_64_PCREL_TYPE (r_type
)
1523 && (! SYMBOLIC_BIND (info
, h
)
1524 || h
->root
.type
== bfd_link_hash_defweak
1525 || !h
->def_regular
))))
1526 || (ELIMINATE_COPY_RELOCS
1528 && (sec
->flags
& SEC_ALLOC
) != 0
1530 && (h
->root
.type
== bfd_link_hash_defweak
1531 || !h
->def_regular
)))
1533 struct elf_dyn_relocs
*p
;
1534 struct elf_dyn_relocs
**head
;
1536 /* We must copy these reloc types into the output file.
1537 Create a reloc section in dynobj and make room for
1541 if (htab
->elf
.dynobj
== NULL
)
1542 htab
->elf
.dynobj
= abfd
;
1544 sreloc
= _bfd_elf_make_dynamic_reloc_section
1545 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
1546 abfd
, /*rela?*/ TRUE
);
1552 /* If this is a global symbol, we count the number of
1553 relocations we need for this symbol. */
1556 head
= &((struct elf_x86_64_link_hash_entry
*) h
)->dyn_relocs
;
1560 /* Track dynamic relocs needed for local syms too.
1561 We really need local syms available to do this
1566 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1571 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1575 /* Beware of type punned pointers vs strict aliasing
1577 vpp
= &(elf_section_data (s
)->local_dynrel
);
1578 head
= (struct elf_dyn_relocs
**)vpp
;
1582 if (p
== NULL
|| p
->sec
!= sec
)
1584 bfd_size_type amt
= sizeof *p
;
1586 p
= ((struct elf_dyn_relocs
*)
1587 bfd_alloc (htab
->elf
.dynobj
, amt
));
1598 if (IS_X86_64_PCREL_TYPE (r_type
))
1603 /* This relocation describes the C++ object vtable hierarchy.
1604 Reconstruct it for later use during GC. */
1605 case R_X86_64_GNU_VTINHERIT
:
1606 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1610 /* This relocation describes which C++ vtable entries are actually
1611 used. Record for later use during GC. */
1612 case R_X86_64_GNU_VTENTRY
:
1613 BFD_ASSERT (h
!= NULL
);
1615 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1627 /* Return the section that should be marked against GC for a given
1631 elf_x86_64_gc_mark_hook (asection
*sec
,
1632 struct bfd_link_info
*info
,
1633 Elf_Internal_Rela
*rel
,
1634 struct elf_link_hash_entry
*h
,
1635 Elf_Internal_Sym
*sym
)
1638 switch (ELF32_R_TYPE (rel
->r_info
))
1640 case R_X86_64_GNU_VTINHERIT
:
1641 case R_X86_64_GNU_VTENTRY
:
1645 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1648 /* Update the got entry reference counts for the section being removed. */
1651 elf_x86_64_gc_sweep_hook (bfd
*abfd
, struct bfd_link_info
*info
,
1653 const Elf_Internal_Rela
*relocs
)
1655 struct elf_x86_64_link_hash_table
*htab
;
1656 Elf_Internal_Shdr
*symtab_hdr
;
1657 struct elf_link_hash_entry
**sym_hashes
;
1658 bfd_signed_vma
*local_got_refcounts
;
1659 const Elf_Internal_Rela
*rel
, *relend
;
1661 if (info
->relocatable
)
1664 htab
= elf_x86_64_hash_table (info
);
1668 elf_section_data (sec
)->local_dynrel
= NULL
;
1670 symtab_hdr
= &elf_symtab_hdr (abfd
);
1671 sym_hashes
= elf_sym_hashes (abfd
);
1672 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1674 htab
= elf_x86_64_hash_table (info
);
1675 relend
= relocs
+ sec
->reloc_count
;
1676 for (rel
= relocs
; rel
< relend
; rel
++)
1678 unsigned long r_symndx
;
1679 unsigned int r_type
;
1680 struct elf_link_hash_entry
*h
= NULL
;
1682 r_symndx
= htab
->r_sym (rel
->r_info
);
1683 if (r_symndx
>= symtab_hdr
->sh_info
)
1685 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1686 while (h
->root
.type
== bfd_link_hash_indirect
1687 || h
->root
.type
== bfd_link_hash_warning
)
1688 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1692 /* A local symbol. */
1693 Elf_Internal_Sym
*isym
;
1695 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1698 /* Check relocation against local STT_GNU_IFUNC symbol. */
1700 && ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1702 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
, FALSE
);
1710 struct elf_x86_64_link_hash_entry
*eh
;
1711 struct elf_dyn_relocs
**pp
;
1712 struct elf_dyn_relocs
*p
;
1714 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
1716 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1719 /* Everything must go for SEC. */
1725 r_type
= ELF32_R_TYPE (rel
->r_info
);
1726 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
1727 symtab_hdr
, sym_hashes
,
1728 &r_type
, GOT_UNKNOWN
,
1729 rel
, relend
, h
, r_symndx
))
1734 case R_X86_64_TLSLD
:
1735 if (htab
->tls_ld_got
.refcount
> 0)
1736 htab
->tls_ld_got
.refcount
-= 1;
1739 case R_X86_64_TLSGD
:
1740 case R_X86_64_GOTPC32_TLSDESC
:
1741 case R_X86_64_TLSDESC_CALL
:
1742 case R_X86_64_GOTTPOFF
:
1743 case R_X86_64_GOT32
:
1744 case R_X86_64_GOTPCREL
:
1745 case R_X86_64_GOT64
:
1746 case R_X86_64_GOTPCREL64
:
1747 case R_X86_64_GOTPLT64
:
1750 if (r_type
== R_X86_64_GOTPLT64
&& h
->plt
.refcount
> 0)
1751 h
->plt
.refcount
-= 1;
1752 if (h
->got
.refcount
> 0)
1753 h
->got
.refcount
-= 1;
1754 if (h
->type
== STT_GNU_IFUNC
)
1756 if (h
->plt
.refcount
> 0)
1757 h
->plt
.refcount
-= 1;
1760 else if (local_got_refcounts
!= NULL
)
1762 if (local_got_refcounts
[r_symndx
] > 0)
1763 local_got_refcounts
[r_symndx
] -= 1;
1777 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
1781 case R_X86_64_PLT32
:
1782 case R_X86_64_PLTOFF64
:
1785 if (h
->plt
.refcount
> 0)
1786 h
->plt
.refcount
-= 1;
1798 /* Adjust a symbol defined by a dynamic object and referenced by a
1799 regular object. The current definition is in some section of the
1800 dynamic object, but we're not including those sections. We have to
1801 change the definition to something the rest of the link can
1805 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1806 struct elf_link_hash_entry
*h
)
1808 struct elf_x86_64_link_hash_table
*htab
;
1811 /* STT_GNU_IFUNC symbol must go through PLT. */
1812 if (h
->type
== STT_GNU_IFUNC
)
1814 if (h
->plt
.refcount
<= 0)
1816 h
->plt
.offset
= (bfd_vma
) -1;
1822 /* If this is a function, put it in the procedure linkage table. We
1823 will fill in the contents of the procedure linkage table later,
1824 when we know the address of the .got section. */
1825 if (h
->type
== STT_FUNC
1828 if (h
->plt
.refcount
<= 0
1829 || SYMBOL_CALLS_LOCAL (info
, h
)
1830 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1831 && h
->root
.type
== bfd_link_hash_undefweak
))
1833 /* This case can occur if we saw a PLT32 reloc in an input
1834 file, but the symbol was never referred to by a dynamic
1835 object, or if all references were garbage collected. In
1836 such a case, we don't actually need to build a procedure
1837 linkage table, and we can just do a PC32 reloc instead. */
1838 h
->plt
.offset
= (bfd_vma
) -1;
1845 /* It's possible that we incorrectly decided a .plt reloc was
1846 needed for an R_X86_64_PC32 reloc to a non-function sym in
1847 check_relocs. We can't decide accurately between function and
1848 non-function syms in check-relocs; Objects loaded later in
1849 the link may change h->type. So fix it now. */
1850 h
->plt
.offset
= (bfd_vma
) -1;
1852 /* If this is a weak symbol, and there is a real definition, the
1853 processor independent code will have arranged for us to see the
1854 real definition first, and we can just use the same value. */
1855 if (h
->u
.weakdef
!= NULL
)
1857 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
1858 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
1859 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
1860 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
1861 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
1862 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
1866 /* This is a reference to a symbol defined by a dynamic object which
1867 is not a function. */
1869 /* If we are creating a shared library, we must presume that the
1870 only references to the symbol are via the global offset table.
1871 For such cases we need not do anything here; the relocations will
1872 be handled correctly by relocate_section. */
1876 /* If there are no references to this symbol that do not use the
1877 GOT, we don't need to generate a copy reloc. */
1878 if (!h
->non_got_ref
)
1881 /* If -z nocopyreloc was given, we won't generate them either. */
1882 if (info
->nocopyreloc
)
1888 if (ELIMINATE_COPY_RELOCS
)
1890 struct elf_x86_64_link_hash_entry
* eh
;
1891 struct elf_dyn_relocs
*p
;
1893 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
1894 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1896 s
= p
->sec
->output_section
;
1897 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1901 /* If we didn't find any dynamic relocs in read-only sections, then
1902 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1912 (*_bfd_error_handler
) (_("dynamic variable `%s' is zero size"),
1913 h
->root
.root
.string
);
1917 /* We must allocate the symbol in our .dynbss section, which will
1918 become part of the .bss section of the executable. There will be
1919 an entry for this symbol in the .dynsym section. The dynamic
1920 object will contain position independent code, so all references
1921 from the dynamic object to this symbol will go through the global
1922 offset table. The dynamic linker will use the .dynsym entry to
1923 determine the address it must put in the global offset table, so
1924 both the dynamic object and the regular object will refer to the
1925 same memory location for the variable. */
1927 htab
= elf_x86_64_hash_table (info
);
1931 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
1932 to copy the initial value out of the dynamic object and into the
1933 runtime process image. */
1934 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1936 const struct elf_backend_data
*bed
;
1937 bed
= get_elf_backend_data (info
->output_bfd
);
1938 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
1944 return _bfd_elf_adjust_dynamic_copy (h
, s
);
1947 /* Allocate space in .plt, .got and associated reloc sections for
1951 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
1953 struct bfd_link_info
*info
;
1954 struct elf_x86_64_link_hash_table
*htab
;
1955 struct elf_x86_64_link_hash_entry
*eh
;
1956 struct elf_dyn_relocs
*p
;
1957 const struct elf_backend_data
*bed
;
1959 if (h
->root
.type
== bfd_link_hash_indirect
)
1962 if (h
->root
.type
== bfd_link_hash_warning
)
1963 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1964 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
1966 info
= (struct bfd_link_info
*) inf
;
1967 htab
= elf_x86_64_hash_table (info
);
1970 bed
= get_elf_backend_data (info
->output_bfd
);
1972 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
1973 here if it is defined and referenced in a non-shared object. */
1974 if (h
->type
== STT_GNU_IFUNC
1976 return _bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
1980 else if (htab
->elf
.dynamic_sections_created
1981 && h
->plt
.refcount
> 0)
1983 /* Make sure this symbol is output as a dynamic symbol.
1984 Undefined weak syms won't yet be marked as dynamic. */
1985 if (h
->dynindx
== -1
1986 && !h
->forced_local
)
1988 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1993 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
1995 asection
*s
= htab
->elf
.splt
;
1997 /* If this is the first .plt entry, make room for the special
2000 s
->size
+= PLT_ENTRY_SIZE
;
2002 h
->plt
.offset
= s
->size
;
2004 /* If this symbol is not defined in a regular file, and we are
2005 not generating a shared library, then set the symbol to this
2006 location in the .plt. This is required to make function
2007 pointers compare as equal between the normal executable and
2008 the shared library. */
2012 h
->root
.u
.def
.section
= s
;
2013 h
->root
.u
.def
.value
= h
->plt
.offset
;
2016 /* Make room for this entry. */
2017 s
->size
+= PLT_ENTRY_SIZE
;
2019 /* We also need to make an entry in the .got.plt section, which
2020 will be placed in the .got section by the linker script. */
2021 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
2023 /* We also need to make an entry in the .rela.plt section. */
2024 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2025 htab
->elf
.srelplt
->reloc_count
++;
2029 h
->plt
.offset
= (bfd_vma
) -1;
2035 h
->plt
.offset
= (bfd_vma
) -1;
2039 eh
->tlsdesc_got
= (bfd_vma
) -1;
2041 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2042 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2043 if (h
->got
.refcount
> 0
2046 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
2048 h
->got
.offset
= (bfd_vma
) -1;
2050 else if (h
->got
.refcount
> 0)
2054 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
2056 /* Make sure this symbol is output as a dynamic symbol.
2057 Undefined weak syms won't yet be marked as dynamic. */
2058 if (h
->dynindx
== -1
2059 && !h
->forced_local
)
2061 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2065 if (GOT_TLS_GDESC_P (tls_type
))
2067 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2068 - elf_x86_64_compute_jump_table_size (htab
);
2069 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2070 h
->got
.offset
= (bfd_vma
) -2;
2072 if (! GOT_TLS_GDESC_P (tls_type
)
2073 || GOT_TLS_GD_P (tls_type
))
2076 h
->got
.offset
= s
->size
;
2077 s
->size
+= GOT_ENTRY_SIZE
;
2078 if (GOT_TLS_GD_P (tls_type
))
2079 s
->size
+= GOT_ENTRY_SIZE
;
2081 dyn
= htab
->elf
.dynamic_sections_created
;
2082 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2084 R_X86_64_GOTTPOFF needs one dynamic relocation. */
2085 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2086 || tls_type
== GOT_TLS_IE
)
2087 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2088 else if (GOT_TLS_GD_P (tls_type
))
2089 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
2090 else if (! GOT_TLS_GDESC_P (tls_type
)
2091 && (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2092 || h
->root
.type
!= bfd_link_hash_undefweak
)
2094 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2095 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2096 if (GOT_TLS_GDESC_P (tls_type
))
2098 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2099 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2103 h
->got
.offset
= (bfd_vma
) -1;
2105 if (eh
->dyn_relocs
== NULL
)
2108 /* In the shared -Bsymbolic case, discard space allocated for
2109 dynamic pc-relative relocs against symbols which turn out to be
2110 defined in regular objects. For the normal shared case, discard
2111 space for pc-relative relocs that have become local due to symbol
2112 visibility changes. */
2116 /* Relocs that use pc_count are those that appear on a call
2117 insn, or certain REL relocs that can generated via assembly.
2118 We want calls to protected symbols to resolve directly to the
2119 function rather than going via the plt. If people want
2120 function pointer comparisons to work as expected then they
2121 should avoid writing weird assembly. */
2122 if (SYMBOL_CALLS_LOCAL (info
, h
))
2124 struct elf_dyn_relocs
**pp
;
2126 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2128 p
->count
-= p
->pc_count
;
2137 /* Also discard relocs on undefined weak syms with non-default
2139 if (eh
->dyn_relocs
!= NULL
2140 && h
->root
.type
== bfd_link_hash_undefweak
)
2142 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2143 eh
->dyn_relocs
= NULL
;
2145 /* Make sure undefined weak symbols are output as a dynamic
2147 else if (h
->dynindx
== -1
2148 && ! h
->forced_local
2149 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2154 else if (ELIMINATE_COPY_RELOCS
)
2156 /* For the non-shared case, discard space for relocs against
2157 symbols which turn out to need copy relocs or are not
2163 || (htab
->elf
.dynamic_sections_created
2164 && (h
->root
.type
== bfd_link_hash_undefweak
2165 || h
->root
.type
== bfd_link_hash_undefined
))))
2167 /* Make sure this symbol is output as a dynamic symbol.
2168 Undefined weak syms won't yet be marked as dynamic. */
2169 if (h
->dynindx
== -1
2170 && ! h
->forced_local
2171 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2174 /* If that succeeded, we know we'll be keeping all the
2176 if (h
->dynindx
!= -1)
2180 eh
->dyn_relocs
= NULL
;
2185 /* Finally, allocate space. */
2186 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2190 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2192 BFD_ASSERT (sreloc
!= NULL
);
2194 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2200 /* Allocate space in .plt, .got and associated reloc sections for
2201 local dynamic relocs. */
2204 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
2206 struct elf_link_hash_entry
*h
2207 = (struct elf_link_hash_entry
*) *slot
;
2209 if (h
->type
!= STT_GNU_IFUNC
2213 || h
->root
.type
!= bfd_link_hash_defined
)
2216 return elf_x86_64_allocate_dynrelocs (h
, inf
);
2219 /* Find any dynamic relocs that apply to read-only sections. */
2222 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
2225 struct elf_x86_64_link_hash_entry
*eh
;
2226 struct elf_dyn_relocs
*p
;
2228 if (h
->root
.type
== bfd_link_hash_warning
)
2229 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2231 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2232 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2234 asection
*s
= p
->sec
->output_section
;
2236 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2238 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2240 info
->flags
|= DF_TEXTREL
;
2242 /* Not an error, just cut short the traversal. */
2249 /* Set the sizes of the dynamic sections. */
2252 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
2253 struct bfd_link_info
*info
)
2255 struct elf_x86_64_link_hash_table
*htab
;
2260 const struct elf_backend_data
*bed
;
2262 htab
= elf_x86_64_hash_table (info
);
2265 bed
= get_elf_backend_data (output_bfd
);
2267 dynobj
= htab
->elf
.dynobj
;
2271 if (htab
->elf
.dynamic_sections_created
)
2273 /* Set the contents of the .interp section to the interpreter. */
2274 if (info
->executable
)
2276 s
= bfd_get_section_by_name (dynobj
, ".interp");
2279 s
->size
= htab
->dynamic_interpreter_size
;
2280 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
2284 /* Set up .got offsets for local syms, and space for local dynamic
2286 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
2288 bfd_signed_vma
*local_got
;
2289 bfd_signed_vma
*end_local_got
;
2290 char *local_tls_type
;
2291 bfd_vma
*local_tlsdesc_gotent
;
2292 bfd_size_type locsymcount
;
2293 Elf_Internal_Shdr
*symtab_hdr
;
2296 if (! is_x86_64_elf (ibfd
))
2299 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2301 struct elf_dyn_relocs
*p
;
2303 for (p
= (struct elf_dyn_relocs
*)
2304 (elf_section_data (s
)->local_dynrel
);
2308 if (!bfd_is_abs_section (p
->sec
)
2309 && bfd_is_abs_section (p
->sec
->output_section
))
2311 /* Input section has been discarded, either because
2312 it is a copy of a linkonce section or due to
2313 linker script /DISCARD/, so we'll be discarding
2316 else if (p
->count
!= 0)
2318 srel
= elf_section_data (p
->sec
)->sreloc
;
2319 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2320 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
2321 info
->flags
|= DF_TEXTREL
;
2326 local_got
= elf_local_got_refcounts (ibfd
);
2330 symtab_hdr
= &elf_symtab_hdr (ibfd
);
2331 locsymcount
= symtab_hdr
->sh_info
;
2332 end_local_got
= local_got
+ locsymcount
;
2333 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
2334 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
2336 srel
= htab
->elf
.srelgot
;
2337 for (; local_got
< end_local_got
;
2338 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
2340 *local_tlsdesc_gotent
= (bfd_vma
) -1;
2343 if (GOT_TLS_GDESC_P (*local_tls_type
))
2345 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
2346 - elf_x86_64_compute_jump_table_size (htab
);
2347 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2348 *local_got
= (bfd_vma
) -2;
2350 if (! GOT_TLS_GDESC_P (*local_tls_type
)
2351 || GOT_TLS_GD_P (*local_tls_type
))
2353 *local_got
= s
->size
;
2354 s
->size
+= GOT_ENTRY_SIZE
;
2355 if (GOT_TLS_GD_P (*local_tls_type
))
2356 s
->size
+= GOT_ENTRY_SIZE
;
2359 || GOT_TLS_GD_ANY_P (*local_tls_type
)
2360 || *local_tls_type
== GOT_TLS_IE
)
2362 if (GOT_TLS_GDESC_P (*local_tls_type
))
2364 htab
->elf
.srelplt
->size
2365 += bed
->s
->sizeof_rela
;
2366 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2368 if (! GOT_TLS_GDESC_P (*local_tls_type
)
2369 || GOT_TLS_GD_P (*local_tls_type
))
2370 srel
->size
+= bed
->s
->sizeof_rela
;
2374 *local_got
= (bfd_vma
) -1;
2378 if (htab
->tls_ld_got
.refcount
> 0)
2380 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
2382 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
2383 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
2384 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2387 htab
->tls_ld_got
.offset
= -1;
2389 /* Allocate global sym .plt and .got entries, and space for global
2390 sym dynamic relocs. */
2391 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
2394 /* Allocate .plt and .got entries, and space for local symbols. */
2395 htab_traverse (htab
->loc_hash_table
,
2396 elf_x86_64_allocate_local_dynrelocs
,
2399 /* For every jump slot reserved in the sgotplt, reloc_count is
2400 incremented. However, when we reserve space for TLS descriptors,
2401 it's not incremented, so in order to compute the space reserved
2402 for them, it suffices to multiply the reloc count by the jump
2404 if (htab
->elf
.srelplt
)
2405 htab
->sgotplt_jump_table_size
2406 = elf_x86_64_compute_jump_table_size (htab
);
2408 if (htab
->tlsdesc_plt
)
2410 /* If we're not using lazy TLS relocations, don't generate the
2411 PLT and GOT entries they require. */
2412 if ((info
->flags
& DF_BIND_NOW
))
2413 htab
->tlsdesc_plt
= 0;
2416 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
2417 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
2418 /* Reserve room for the initial entry.
2419 FIXME: we could probably do away with it in this case. */
2420 if (htab
->elf
.splt
->size
== 0)
2421 htab
->elf
.splt
->size
+= PLT_ENTRY_SIZE
;
2422 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
2423 htab
->elf
.splt
->size
+= PLT_ENTRY_SIZE
;
2427 if (htab
->elf
.sgotplt
)
2429 struct elf_link_hash_entry
*got
;
2430 got
= elf_link_hash_lookup (elf_hash_table (info
),
2431 "_GLOBAL_OFFSET_TABLE_",
2432 FALSE
, FALSE
, FALSE
);
2434 /* Don't allocate .got.plt section if there are no GOT nor PLT
2435 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
2437 || !got
->ref_regular_nonweak
)
2438 && (htab
->elf
.sgotplt
->size
2439 == get_elf_backend_data (output_bfd
)->got_header_size
)
2440 && (htab
->elf
.splt
== NULL
2441 || htab
->elf
.splt
->size
== 0)
2442 && (htab
->elf
.sgot
== NULL
2443 || htab
->elf
.sgot
->size
== 0)
2444 && (htab
->elf
.iplt
== NULL
2445 || htab
->elf
.iplt
->size
== 0)
2446 && (htab
->elf
.igotplt
== NULL
2447 || htab
->elf
.igotplt
->size
== 0))
2448 htab
->elf
.sgotplt
->size
= 0;
2451 /* We now have determined the sizes of the various dynamic sections.
2452 Allocate memory for them. */
2454 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2456 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2459 if (s
== htab
->elf
.splt
2460 || s
== htab
->elf
.sgot
2461 || s
== htab
->elf
.sgotplt
2462 || s
== htab
->elf
.iplt
2463 || s
== htab
->elf
.igotplt
2464 || s
== htab
->sdynbss
)
2466 /* Strip this section if we don't need it; see the
2469 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
2471 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
2474 /* We use the reloc_count field as a counter if we need
2475 to copy relocs into the output file. */
2476 if (s
!= htab
->elf
.srelplt
)
2481 /* It's not one of our sections, so don't allocate space. */
2487 /* If we don't need this section, strip it from the
2488 output file. This is mostly to handle .rela.bss and
2489 .rela.plt. We must create both sections in
2490 create_dynamic_sections, because they must be created
2491 before the linker maps input sections to output
2492 sections. The linker does that before
2493 adjust_dynamic_symbol is called, and it is that
2494 function which decides whether anything needs to go
2495 into these sections. */
2497 s
->flags
|= SEC_EXCLUDE
;
2501 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2504 /* Allocate memory for the section contents. We use bfd_zalloc
2505 here in case unused entries are not reclaimed before the
2506 section's contents are written out. This should not happen,
2507 but this way if it does, we get a R_X86_64_NONE reloc instead
2509 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
2510 if (s
->contents
== NULL
)
2514 if (htab
->elf
.dynamic_sections_created
)
2516 /* Add some entries to the .dynamic section. We fill in the
2517 values later, in elf_x86_64_finish_dynamic_sections, but we
2518 must add the entries now so that we get the correct size for
2519 the .dynamic section. The DT_DEBUG entry is filled in by the
2520 dynamic linker and used by the debugger. */
2521 #define add_dynamic_entry(TAG, VAL) \
2522 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2524 if (info
->executable
)
2526 if (!add_dynamic_entry (DT_DEBUG
, 0))
2530 if (htab
->elf
.splt
->size
!= 0)
2532 if (!add_dynamic_entry (DT_PLTGOT
, 0)
2533 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
2534 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
2535 || !add_dynamic_entry (DT_JMPREL
, 0))
2538 if (htab
->tlsdesc_plt
2539 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
2540 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
2546 if (!add_dynamic_entry (DT_RELA
, 0)
2547 || !add_dynamic_entry (DT_RELASZ
, 0)
2548 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
2551 /* If any dynamic relocs apply to a read-only section,
2552 then we need a DT_TEXTREL entry. */
2553 if ((info
->flags
& DF_TEXTREL
) == 0)
2554 elf_link_hash_traverse (&htab
->elf
,
2555 elf_x86_64_readonly_dynrelocs
,
2558 if ((info
->flags
& DF_TEXTREL
) != 0)
2560 if (!add_dynamic_entry (DT_TEXTREL
, 0))
2565 #undef add_dynamic_entry
2571 elf_x86_64_always_size_sections (bfd
*output_bfd
,
2572 struct bfd_link_info
*info
)
2574 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
2578 struct elf_link_hash_entry
*tlsbase
;
2580 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
2581 "_TLS_MODULE_BASE_",
2582 FALSE
, FALSE
, FALSE
);
2584 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
2586 struct elf_x86_64_link_hash_table
*htab
;
2587 struct bfd_link_hash_entry
*bh
= NULL
;
2588 const struct elf_backend_data
*bed
2589 = get_elf_backend_data (output_bfd
);
2591 htab
= elf_x86_64_hash_table (info
);
2595 if (!(_bfd_generic_link_add_one_symbol
2596 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
2597 tls_sec
, 0, NULL
, FALSE
,
2598 bed
->collect
, &bh
)))
2601 htab
->tls_module_base
= bh
;
2603 tlsbase
= (struct elf_link_hash_entry
*)bh
;
2604 tlsbase
->def_regular
= 1;
2605 tlsbase
->other
= STV_HIDDEN
;
2606 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
2613 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
2614 executables. Rather than setting it to the beginning of the TLS
2615 section, we have to set it to the end. This function may be called
2616 multiple times, it is idempotent. */
2619 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
2621 struct elf_x86_64_link_hash_table
*htab
;
2622 struct bfd_link_hash_entry
*base
;
2624 if (!info
->executable
)
2627 htab
= elf_x86_64_hash_table (info
);
2631 base
= htab
->tls_module_base
;
2635 base
->u
.def
.value
= htab
->elf
.tls_size
;
2638 /* Return the base VMA address which should be subtracted from real addresses
2639 when resolving @dtpoff relocation.
2640 This is PT_TLS segment p_vaddr. */
2643 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
2645 /* If tls_sec is NULL, we should have signalled an error already. */
2646 if (elf_hash_table (info
)->tls_sec
== NULL
)
2648 return elf_hash_table (info
)->tls_sec
->vma
;
2651 /* Return the relocation value for @tpoff relocation
2652 if STT_TLS virtual address is ADDRESS. */
2655 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
2657 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2658 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
2659 bfd_vma static_tls_size
;
2661 /* If tls_segment is NULL, we should have signalled an error already. */
2662 if (htab
->tls_sec
== NULL
)
2665 /* Consider special static TLS alignment requirements. */
2666 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
2667 return address
- static_tls_size
- htab
->tls_sec
->vma
;
2670 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
2674 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
2676 /* Opcode Instruction
2679 0x0f 0x8x conditional jump */
2681 && (contents
[offset
- 1] == 0xe8
2682 || contents
[offset
- 1] == 0xe9))
2684 && contents
[offset
- 2] == 0x0f
2685 && (contents
[offset
- 1] & 0xf0) == 0x80));
2688 /* Relocate an x86_64 ELF section. */
2691 elf_x86_64_relocate_section (bfd
*output_bfd
,
2692 struct bfd_link_info
*info
,
2694 asection
*input_section
,
2696 Elf_Internal_Rela
*relocs
,
2697 Elf_Internal_Sym
*local_syms
,
2698 asection
**local_sections
)
2700 struct elf_x86_64_link_hash_table
*htab
;
2701 Elf_Internal_Shdr
*symtab_hdr
;
2702 struct elf_link_hash_entry
**sym_hashes
;
2703 bfd_vma
*local_got_offsets
;
2704 bfd_vma
*local_tlsdesc_gotents
;
2705 Elf_Internal_Rela
*rel
;
2706 Elf_Internal_Rela
*relend
;
2708 BFD_ASSERT (is_x86_64_elf (input_bfd
));
2710 htab
= elf_x86_64_hash_table (info
);
2713 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
2714 sym_hashes
= elf_sym_hashes (input_bfd
);
2715 local_got_offsets
= elf_local_got_offsets (input_bfd
);
2716 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
2718 elf_x86_64_set_tls_module_base (info
);
2721 relend
= relocs
+ input_section
->reloc_count
;
2722 for (; rel
< relend
; rel
++)
2724 unsigned int r_type
;
2725 reloc_howto_type
*howto
;
2726 unsigned long r_symndx
;
2727 struct elf_link_hash_entry
*h
;
2728 Elf_Internal_Sym
*sym
;
2730 bfd_vma off
, offplt
;
2732 bfd_boolean unresolved_reloc
;
2733 bfd_reloc_status_type r
;
2737 r_type
= ELF32_R_TYPE (rel
->r_info
);
2738 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
2739 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
2742 if (r_type
>= R_X86_64_max
)
2744 bfd_set_error (bfd_error_bad_value
);
2748 howto
= x86_64_elf_howto_table
+ r_type
;
2749 r_symndx
= htab
->r_sym (rel
->r_info
);
2753 unresolved_reloc
= FALSE
;
2754 if (r_symndx
< symtab_hdr
->sh_info
)
2756 sym
= local_syms
+ r_symndx
;
2757 sec
= local_sections
[r_symndx
];
2759 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
2762 /* Relocate against local STT_GNU_IFUNC symbol. */
2763 if (!info
->relocatable
2764 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
2766 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
2771 /* Set STT_GNU_IFUNC symbol value. */
2772 h
->root
.u
.def
.value
= sym
->st_value
;
2773 h
->root
.u
.def
.section
= sec
;
2778 bfd_boolean warned ATTRIBUTE_UNUSED
;
2780 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2781 r_symndx
, symtab_hdr
, sym_hashes
,
2783 unresolved_reloc
, warned
);
2786 if (sec
!= NULL
&& elf_discarded_section (sec
))
2787 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
2788 rel
, relend
, howto
, contents
);
2790 if (info
->relocatable
)
2793 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
2794 it here if it is defined in a non-shared object. */
2796 && h
->type
== STT_GNU_IFUNC
2803 if ((input_section
->flags
& SEC_ALLOC
) == 0
2804 || h
->plt
.offset
== (bfd_vma
) -1)
2807 /* STT_GNU_IFUNC symbol must go through PLT. */
2808 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
2809 relocation
= (plt
->output_section
->vma
2810 + plt
->output_offset
+ h
->plt
.offset
);
2815 if (h
->root
.root
.string
)
2816 name
= h
->root
.root
.string
;
2818 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
2820 (*_bfd_error_handler
)
2821 (_("%B: relocation %s against STT_GNU_IFUNC "
2822 "symbol `%s' isn't handled by %s"), input_bfd
,
2823 x86_64_elf_howto_table
[r_type
].name
,
2824 name
, __FUNCTION__
);
2825 bfd_set_error (bfd_error_bad_value
);
2834 if (rel
->r_addend
!= 0)
2836 if (h
->root
.root
.string
)
2837 name
= h
->root
.root
.string
;
2839 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
2841 (*_bfd_error_handler
)
2842 (_("%B: relocation %s against STT_GNU_IFUNC "
2843 "symbol `%s' has non-zero addend: %d"),
2844 input_bfd
, x86_64_elf_howto_table
[r_type
].name
,
2845 name
, rel
->r_addend
);
2846 bfd_set_error (bfd_error_bad_value
);
2850 /* Generate dynamic relcoation only when there is a
2851 non-GOF reference in a shared object. */
2852 if (info
->shared
&& h
->non_got_ref
)
2854 Elf_Internal_Rela outrel
;
2857 /* Need a dynamic relocation to get the real function
2859 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
2863 if (outrel
.r_offset
== (bfd_vma
) -1
2864 || outrel
.r_offset
== (bfd_vma
) -2)
2867 outrel
.r_offset
+= (input_section
->output_section
->vma
2868 + input_section
->output_offset
);
2870 if (h
->dynindx
== -1
2872 || info
->executable
)
2874 /* This symbol is resolved locally. */
2875 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
2876 outrel
.r_addend
= (h
->root
.u
.def
.value
2877 + h
->root
.u
.def
.section
->output_section
->vma
2878 + h
->root
.u
.def
.section
->output_offset
);
2882 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
2883 outrel
.r_addend
= 0;
2886 sreloc
= htab
->elf
.irelifunc
;
2887 elf_append_rela (output_bfd
, sreloc
, &outrel
);
2889 /* If this reloc is against an external symbol, we
2890 do not want to fiddle with the addend. Otherwise,
2891 we need to include the symbol value so that it
2892 becomes an addend for the dynamic reloc. For an
2893 internal symbol, we have updated addend. */
2900 case R_X86_64_PLT32
:
2903 case R_X86_64_GOTPCREL
:
2904 case R_X86_64_GOTPCREL64
:
2905 base_got
= htab
->elf
.sgot
;
2906 off
= h
->got
.offset
;
2908 if (base_got
== NULL
)
2911 if (off
== (bfd_vma
) -1)
2913 /* We can't use h->got.offset here to save state, or
2914 even just remember the offset, as finish_dynamic_symbol
2915 would use that as offset into .got. */
2917 if (htab
->elf
.splt
!= NULL
)
2919 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
2920 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
2921 base_got
= htab
->elf
.sgotplt
;
2925 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
;
2926 off
= plt_index
* GOT_ENTRY_SIZE
;
2927 base_got
= htab
->elf
.igotplt
;
2930 if (h
->dynindx
== -1
2934 /* This references the local defitionion. We must
2935 initialize this entry in the global offset table.
2936 Since the offset must always be a multiple of 8,
2937 we use the least significant bit to record
2938 whether we have initialized it already.
2940 When doing a dynamic link, we create a .rela.got
2941 relocation entry to initialize the value. This
2942 is done in the finish_dynamic_symbol routine. */
2947 bfd_put_64 (output_bfd
, relocation
,
2948 base_got
->contents
+ off
);
2949 /* Note that this is harmless for the GOTPLT64
2950 case, as -1 | 1 still is -1. */
2956 relocation
= (base_got
->output_section
->vma
2957 + base_got
->output_offset
+ off
);
2959 if (r_type
!= R_X86_64_GOTPCREL
2960 && r_type
!= R_X86_64_GOTPCREL64
)
2963 if (htab
->elf
.splt
!= NULL
)
2964 gotplt
= htab
->elf
.sgotplt
;
2966 gotplt
= htab
->elf
.igotplt
;
2967 relocation
-= (gotplt
->output_section
->vma
2968 - gotplt
->output_offset
);
2975 /* When generating a shared object, the relocations handled here are
2976 copied into the output file to be resolved at run time. */
2979 case R_X86_64_GOT32
:
2980 case R_X86_64_GOT64
:
2981 /* Relocation is to the entry for this symbol in the global
2983 case R_X86_64_GOTPCREL
:
2984 case R_X86_64_GOTPCREL64
:
2985 /* Use global offset table entry as symbol value. */
2986 case R_X86_64_GOTPLT64
:
2987 /* This is the same as GOT64 for relocation purposes, but
2988 indicates the existence of a PLT entry. The difficulty is,
2989 that we must calculate the GOT slot offset from the PLT
2990 offset, if this symbol got a PLT entry (it was global).
2991 Additionally if it's computed from the PLT entry, then that
2992 GOT offset is relative to .got.plt, not to .got. */
2993 base_got
= htab
->elf
.sgot
;
2995 if (htab
->elf
.sgot
== NULL
)
3002 off
= h
->got
.offset
;
3004 && h
->plt
.offset
!= (bfd_vma
)-1
3005 && off
== (bfd_vma
)-1)
3007 /* We can't use h->got.offset here to save
3008 state, or even just remember the offset, as
3009 finish_dynamic_symbol would use that as offset into
3011 bfd_vma plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
3012 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
3013 base_got
= htab
->elf
.sgotplt
;
3016 dyn
= htab
->elf
.dynamic_sections_created
;
3018 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
3020 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3021 || (ELF_ST_VISIBILITY (h
->other
)
3022 && h
->root
.type
== bfd_link_hash_undefweak
))
3024 /* This is actually a static link, or it is a -Bsymbolic
3025 link and the symbol is defined locally, or the symbol
3026 was forced to be local because of a version file. We
3027 must initialize this entry in the global offset table.
3028 Since the offset must always be a multiple of 8, we
3029 use the least significant bit to record whether we
3030 have initialized it already.
3032 When doing a dynamic link, we create a .rela.got
3033 relocation entry to initialize the value. This is
3034 done in the finish_dynamic_symbol routine. */
3039 bfd_put_64 (output_bfd
, relocation
,
3040 base_got
->contents
+ off
);
3041 /* Note that this is harmless for the GOTPLT64 case,
3042 as -1 | 1 still is -1. */
3047 unresolved_reloc
= FALSE
;
3051 if (local_got_offsets
== NULL
)
3054 off
= local_got_offsets
[r_symndx
];
3056 /* The offset must always be a multiple of 8. We use
3057 the least significant bit to record whether we have
3058 already generated the necessary reloc. */
3063 bfd_put_64 (output_bfd
, relocation
,
3064 base_got
->contents
+ off
);
3069 Elf_Internal_Rela outrel
;
3071 /* We need to generate a R_X86_64_RELATIVE reloc
3072 for the dynamic linker. */
3073 s
= htab
->elf
.srelgot
;
3077 outrel
.r_offset
= (base_got
->output_section
->vma
3078 + base_got
->output_offset
3080 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
3081 outrel
.r_addend
= relocation
;
3082 elf_append_rela (output_bfd
, s
, &outrel
);
3085 local_got_offsets
[r_symndx
] |= 1;
3089 if (off
>= (bfd_vma
) -2)
3092 relocation
= base_got
->output_section
->vma
3093 + base_got
->output_offset
+ off
;
3094 if (r_type
!= R_X86_64_GOTPCREL
&& r_type
!= R_X86_64_GOTPCREL64
)
3095 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3096 - htab
->elf
.sgotplt
->output_offset
;
3100 case R_X86_64_GOTOFF64
:
3101 /* Relocation is relative to the start of the global offset
3104 /* Check to make sure it isn't a protected function symbol
3105 for shared library since it may not be local when used
3106 as function address. */
3110 && h
->type
== STT_FUNC
3111 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
3113 (*_bfd_error_handler
)
3114 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
3115 input_bfd
, h
->root
.root
.string
);
3116 bfd_set_error (bfd_error_bad_value
);
3120 /* Note that sgot is not involved in this
3121 calculation. We always want the start of .got.plt. If we
3122 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3123 permitted by the ABI, we might have to change this
3125 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3126 + htab
->elf
.sgotplt
->output_offset
;
3129 case R_X86_64_GOTPC32
:
3130 case R_X86_64_GOTPC64
:
3131 /* Use global offset table as symbol value. */
3132 relocation
= htab
->elf
.sgotplt
->output_section
->vma
3133 + htab
->elf
.sgotplt
->output_offset
;
3134 unresolved_reloc
= FALSE
;
3137 case R_X86_64_PLTOFF64
:
3138 /* Relocation is PLT entry relative to GOT. For local
3139 symbols it's the symbol itself relative to GOT. */
3141 /* See PLT32 handling. */
3142 && h
->plt
.offset
!= (bfd_vma
) -1
3143 && htab
->elf
.splt
!= NULL
)
3145 relocation
= (htab
->elf
.splt
->output_section
->vma
3146 + htab
->elf
.splt
->output_offset
3148 unresolved_reloc
= FALSE
;
3151 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3152 + htab
->elf
.sgotplt
->output_offset
;
3155 case R_X86_64_PLT32
:
3156 /* Relocation is to the entry for this symbol in the
3157 procedure linkage table. */
3159 /* Resolve a PLT32 reloc against a local symbol directly,
3160 without using the procedure linkage table. */
3164 if (h
->plt
.offset
== (bfd_vma
) -1
3165 || htab
->elf
.splt
== NULL
)
3167 /* We didn't make a PLT entry for this symbol. This
3168 happens when statically linking PIC code, or when
3169 using -Bsymbolic. */
3173 relocation
= (htab
->elf
.splt
->output_section
->vma
3174 + htab
->elf
.splt
->output_offset
3176 unresolved_reloc
= FALSE
;
3183 && ABI_64_P (output_bfd
)
3184 && (input_section
->flags
& SEC_ALLOC
) != 0
3185 && (input_section
->flags
& SEC_READONLY
) != 0
3188 bfd_boolean fail
= FALSE
;
3190 = (r_type
== R_X86_64_PC32
3191 && is_32bit_relative_branch (contents
, rel
->r_offset
));
3193 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
3195 /* Symbol is referenced locally. Make sure it is
3196 defined locally or for a branch. */
3197 fail
= !h
->def_regular
&& !branch
;
3201 /* Symbol isn't referenced locally. We only allow
3202 branch to symbol with non-default visibility. */
3204 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
3211 const char *pic
= "";
3213 switch (ELF_ST_VISIBILITY (h
->other
))
3216 v
= _("hidden symbol");
3219 v
= _("internal symbol");
3222 v
= _("protected symbol");
3226 pic
= _("; recompile with -fPIC");
3231 fmt
= _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
3233 fmt
= _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
3235 (*_bfd_error_handler
) (fmt
, input_bfd
,
3236 x86_64_elf_howto_table
[r_type
].name
,
3237 v
, h
->root
.root
.string
, pic
);
3238 bfd_set_error (bfd_error_bad_value
);
3249 /* FIXME: The ABI says the linker should make sure the value is
3250 the same when it's zeroextended to 64 bit. */
3252 if ((input_section
->flags
& SEC_ALLOC
) == 0)
3257 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3258 || h
->root
.type
!= bfd_link_hash_undefweak
)
3259 && (! IS_X86_64_PCREL_TYPE (r_type
)
3260 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
3261 || (ELIMINATE_COPY_RELOCS
3268 || h
->root
.type
== bfd_link_hash_undefweak
3269 || h
->root
.type
== bfd_link_hash_undefined
)))
3271 Elf_Internal_Rela outrel
;
3272 bfd_boolean skip
, relocate
;
3275 /* When generating a shared object, these relocations
3276 are copied into the output file to be resolved at run
3282 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3284 if (outrel
.r_offset
== (bfd_vma
) -1)
3286 else if (outrel
.r_offset
== (bfd_vma
) -2)
3287 skip
= TRUE
, relocate
= TRUE
;
3289 outrel
.r_offset
+= (input_section
->output_section
->vma
3290 + input_section
->output_offset
);
3293 memset (&outrel
, 0, sizeof outrel
);
3295 /* h->dynindx may be -1 if this symbol was marked to
3299 && (IS_X86_64_PCREL_TYPE (r_type
)
3301 || ! SYMBOLIC_BIND (info
, h
)
3302 || ! h
->def_regular
))
3304 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
3305 outrel
.r_addend
= rel
->r_addend
;
3309 /* This symbol is local, or marked to become local. */
3310 if (r_type
== R_X86_64_64
)
3313 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
3314 outrel
.r_addend
= relocation
+ rel
->r_addend
;
3320 if (bfd_is_abs_section (sec
))
3322 else if (sec
== NULL
|| sec
->owner
== NULL
)
3324 bfd_set_error (bfd_error_bad_value
);
3331 /* We are turning this relocation into one
3332 against a section symbol. It would be
3333 proper to subtract the symbol's value,
3334 osec->vma, from the emitted reloc addend,
3335 but ld.so expects buggy relocs. */
3336 osec
= sec
->output_section
;
3337 sindx
= elf_section_data (osec
)->dynindx
;
3340 asection
*oi
= htab
->elf
.text_index_section
;
3341 sindx
= elf_section_data (oi
)->dynindx
;
3343 BFD_ASSERT (sindx
!= 0);
3346 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
3347 outrel
.r_addend
= relocation
+ rel
->r_addend
;
3351 sreloc
= elf_section_data (input_section
)->sreloc
;
3353 BFD_ASSERT (sreloc
!= NULL
&& sreloc
->contents
!= NULL
);
3355 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3357 /* If this reloc is against an external symbol, we do
3358 not want to fiddle with the addend. Otherwise, we
3359 need to include the symbol value so that it becomes
3360 an addend for the dynamic reloc. */
3367 case R_X86_64_TLSGD
:
3368 case R_X86_64_GOTPC32_TLSDESC
:
3369 case R_X86_64_TLSDESC_CALL
:
3370 case R_X86_64_GOTTPOFF
:
3371 tls_type
= GOT_UNKNOWN
;
3372 if (h
== NULL
&& local_got_offsets
)
3373 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
3375 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
3377 if (! elf_x86_64_tls_transition (info
, input_bfd
,
3378 input_section
, contents
,
3379 symtab_hdr
, sym_hashes
,
3380 &r_type
, tls_type
, rel
,
3381 relend
, h
, r_symndx
))
3384 if (r_type
== R_X86_64_TPOFF32
)
3386 bfd_vma roff
= rel
->r_offset
;
3388 BFD_ASSERT (! unresolved_reloc
);
3390 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
3392 /* GD->LE transition.
3393 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3394 .word 0x6666; rex64; call __tls_get_addr
3397 leaq foo@tpoff(%rax), %rax */
3398 memcpy (contents
+ roff
- 4,
3399 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3401 bfd_put_32 (output_bfd
,
3402 elf_x86_64_tpoff (info
, relocation
),
3403 contents
+ roff
+ 8);
3404 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
3408 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
3410 /* GDesc -> LE transition.
3411 It's originally something like:
3412 leaq x@tlsdesc(%rip), %rax
3415 movl $x@tpoff, %rax. */
3417 unsigned int val
, type
;
3419 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
3420 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
3421 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
3422 contents
+ roff
- 3);
3423 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
3424 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
3425 contents
+ roff
- 1);
3426 bfd_put_32 (output_bfd
,
3427 elf_x86_64_tpoff (info
, relocation
),
3431 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
3433 /* GDesc -> LE transition.
3438 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
3439 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
3442 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
3444 /* IE->LE transition:
3445 Originally it can be one of:
3446 movq foo@gottpoff(%rip), %reg
3447 addq foo@gottpoff(%rip), %reg
3450 leaq foo(%reg), %reg
3453 unsigned int val
, type
, reg
;
3455 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
3456 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
3457 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
3463 bfd_put_8 (output_bfd
, 0x49,
3464 contents
+ roff
- 3);
3465 bfd_put_8 (output_bfd
, 0xc7,
3466 contents
+ roff
- 2);
3467 bfd_put_8 (output_bfd
, 0xc0 | reg
,
3468 contents
+ roff
- 1);
3472 /* addq -> addq - addressing with %rsp/%r12 is
3475 bfd_put_8 (output_bfd
, 0x49,
3476 contents
+ roff
- 3);
3477 bfd_put_8 (output_bfd
, 0x81,
3478 contents
+ roff
- 2);
3479 bfd_put_8 (output_bfd
, 0xc0 | reg
,
3480 contents
+ roff
- 1);
3486 bfd_put_8 (output_bfd
, 0x4d,
3487 contents
+ roff
- 3);
3488 bfd_put_8 (output_bfd
, 0x8d,
3489 contents
+ roff
- 2);
3490 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
3491 contents
+ roff
- 1);
3493 bfd_put_32 (output_bfd
,
3494 elf_x86_64_tpoff (info
, relocation
),
3502 if (htab
->elf
.sgot
== NULL
)
3507 off
= h
->got
.offset
;
3508 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
3512 if (local_got_offsets
== NULL
)
3515 off
= local_got_offsets
[r_symndx
];
3516 offplt
= local_tlsdesc_gotents
[r_symndx
];
3523 Elf_Internal_Rela outrel
;
3527 if (htab
->elf
.srelgot
== NULL
)
3530 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
3532 if (GOT_TLS_GDESC_P (tls_type
))
3534 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
3535 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
3536 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
3537 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
3538 + htab
->elf
.sgotplt
->output_offset
3540 + htab
->sgotplt_jump_table_size
);
3541 sreloc
= htab
->elf
.srelplt
;
3543 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
3545 outrel
.r_addend
= 0;
3546 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3549 sreloc
= htab
->elf
.srelgot
;
3551 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
3552 + htab
->elf
.sgot
->output_offset
+ off
);
3554 if (GOT_TLS_GD_P (tls_type
))
3555 dr_type
= R_X86_64_DTPMOD64
;
3556 else if (GOT_TLS_GDESC_P (tls_type
))
3559 dr_type
= R_X86_64_TPOFF64
;
3561 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
3562 outrel
.r_addend
= 0;
3563 if ((dr_type
== R_X86_64_TPOFF64
3564 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
3565 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
3566 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
3568 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3570 if (GOT_TLS_GD_P (tls_type
))
3574 BFD_ASSERT (! unresolved_reloc
);
3575 bfd_put_64 (output_bfd
,
3576 relocation
- elf_x86_64_dtpoff_base (info
),
3577 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
3581 bfd_put_64 (output_bfd
, 0,
3582 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
3583 outrel
.r_info
= htab
->r_info (indx
,
3585 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
3586 elf_append_rela (output_bfd
, sreloc
,
3595 local_got_offsets
[r_symndx
] |= 1;
3598 if (off
>= (bfd_vma
) -2
3599 && ! GOT_TLS_GDESC_P (tls_type
))
3601 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
3603 if (r_type
== R_X86_64_GOTPC32_TLSDESC
3604 || r_type
== R_X86_64_TLSDESC_CALL
)
3605 relocation
= htab
->elf
.sgotplt
->output_section
->vma
3606 + htab
->elf
.sgotplt
->output_offset
3607 + offplt
+ htab
->sgotplt_jump_table_size
;
3609 relocation
= htab
->elf
.sgot
->output_section
->vma
3610 + htab
->elf
.sgot
->output_offset
+ off
;
3611 unresolved_reloc
= FALSE
;
3615 bfd_vma roff
= rel
->r_offset
;
3617 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
3619 /* GD->IE transition.
3620 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3621 .word 0x6666; rex64; call __tls_get_addr@plt
3624 addq foo@gottpoff(%rip), %rax */
3625 memcpy (contents
+ roff
- 4,
3626 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
3629 relocation
= (htab
->elf
.sgot
->output_section
->vma
3630 + htab
->elf
.sgot
->output_offset
+ off
3632 - input_section
->output_section
->vma
3633 - input_section
->output_offset
3635 bfd_put_32 (output_bfd
, relocation
,
3636 contents
+ roff
+ 8);
3637 /* Skip R_X86_64_PLT32. */
3641 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
3643 /* GDesc -> IE transition.
3644 It's originally something like:
3645 leaq x@tlsdesc(%rip), %rax
3648 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
3650 /* Now modify the instruction as appropriate. To
3651 turn a leaq into a movq in the form we use it, it
3652 suffices to change the second byte from 0x8d to
3654 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
3656 bfd_put_32 (output_bfd
,
3657 htab
->elf
.sgot
->output_section
->vma
3658 + htab
->elf
.sgot
->output_offset
+ off
3660 - input_section
->output_section
->vma
3661 - input_section
->output_offset
3666 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
3668 /* GDesc -> IE transition.
3675 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
3676 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
3684 case R_X86_64_TLSLD
:
3685 if (! elf_x86_64_tls_transition (info
, input_bfd
,
3686 input_section
, contents
,
3687 symtab_hdr
, sym_hashes
,
3688 &r_type
, GOT_UNKNOWN
,
3689 rel
, relend
, h
, r_symndx
))
3692 if (r_type
!= R_X86_64_TLSLD
)
3694 /* LD->LE transition:
3695 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
3697 .word 0x6666; .byte 0x66; movl %fs:0, %rax. */
3699 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
3700 memcpy (contents
+ rel
->r_offset
- 3,
3701 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
3702 /* Skip R_X86_64_PC32/R_X86_64_PLT32. */
3707 if (htab
->elf
.sgot
== NULL
)
3710 off
= htab
->tls_ld_got
.offset
;
3715 Elf_Internal_Rela outrel
;
3717 if (htab
->elf
.srelgot
== NULL
)
3720 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
3721 + htab
->elf
.sgot
->output_offset
+ off
);
3723 bfd_put_64 (output_bfd
, 0,
3724 htab
->elf
.sgot
->contents
+ off
);
3725 bfd_put_64 (output_bfd
, 0,
3726 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
3727 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
3728 outrel
.r_addend
= 0;
3729 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
3731 htab
->tls_ld_got
.offset
|= 1;
3733 relocation
= htab
->elf
.sgot
->output_section
->vma
3734 + htab
->elf
.sgot
->output_offset
+ off
;
3735 unresolved_reloc
= FALSE
;
3738 case R_X86_64_DTPOFF32
:
3739 if (!info
->executable
|| (input_section
->flags
& SEC_CODE
) == 0)
3740 relocation
-= elf_x86_64_dtpoff_base (info
);
3742 relocation
= elf_x86_64_tpoff (info
, relocation
);
3745 case R_X86_64_TPOFF32
:
3746 BFD_ASSERT (info
->executable
);
3747 relocation
= elf_x86_64_tpoff (info
, relocation
);
3754 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3755 because such sections are not SEC_ALLOC and thus ld.so will
3756 not process them. */
3757 if (unresolved_reloc
3758 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
3760 (*_bfd_error_handler
)
3761 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3764 (long) rel
->r_offset
,
3766 h
->root
.root
.string
);
3769 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
3770 contents
, rel
->r_offset
,
3771 relocation
, rel
->r_addend
);
3773 if (r
!= bfd_reloc_ok
)
3778 name
= h
->root
.root
.string
;
3781 name
= bfd_elf_string_from_elf_section (input_bfd
,
3782 symtab_hdr
->sh_link
,
3787 name
= bfd_section_name (input_bfd
, sec
);
3790 if (r
== bfd_reloc_overflow
)
3792 if (! ((*info
->callbacks
->reloc_overflow
)
3793 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
3794 (bfd_vma
) 0, input_bfd
, input_section
,
3800 (*_bfd_error_handler
)
3801 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3802 input_bfd
, input_section
,
3803 (long) rel
->r_offset
, name
, (int) r
);
3812 /* Finish up dynamic symbol handling. We set the contents of various
3813 dynamic sections here. */
3816 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
3817 struct bfd_link_info
*info
,
3818 struct elf_link_hash_entry
*h
,
3819 Elf_Internal_Sym
*sym
)
3821 struct elf_x86_64_link_hash_table
*htab
;
3823 htab
= elf_x86_64_hash_table (info
);
3827 if (h
->plt
.offset
!= (bfd_vma
) -1)
3831 Elf_Internal_Rela rela
;
3833 asection
*plt
, *gotplt
, *relplt
;
3834 const struct elf_backend_data
*bed
;
3836 /* When building a static executable, use .iplt, .igot.plt and
3837 .rela.iplt sections for STT_GNU_IFUNC symbols. */
3838 if (htab
->elf
.splt
!= NULL
)
3840 plt
= htab
->elf
.splt
;
3841 gotplt
= htab
->elf
.sgotplt
;
3842 relplt
= htab
->elf
.srelplt
;
3846 plt
= htab
->elf
.iplt
;
3847 gotplt
= htab
->elf
.igotplt
;
3848 relplt
= htab
->elf
.irelplt
;
3851 /* This symbol has an entry in the procedure linkage table. Set
3853 if ((h
->dynindx
== -1
3854 && !((h
->forced_local
|| info
->executable
)
3856 && h
->type
== STT_GNU_IFUNC
))
3862 /* Get the index in the procedure linkage table which
3863 corresponds to this symbol. This is the index of this symbol
3864 in all the symbols for which we are making plt entries. The
3865 first entry in the procedure linkage table is reserved.
3867 Get the offset into the .got table of the entry that
3868 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
3869 bytes. The first three are reserved for the dynamic linker.
3871 For static executables, we don't reserve anything. */
3873 if (plt
== htab
->elf
.splt
)
3875 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
3876 got_offset
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
3880 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
;
3881 got_offset
= plt_index
* GOT_ENTRY_SIZE
;
3884 /* Fill in the entry in the procedure linkage table. */
3885 memcpy (plt
->contents
+ h
->plt
.offset
, elf_x86_64_plt_entry
,
3888 /* Insert the relocation positions of the plt section. The magic
3889 numbers at the end of the statements are the positions of the
3890 relocations in the plt section. */
3891 /* Put offset for jmp *name@GOTPCREL(%rip), since the
3892 instruction uses 6 bytes, subtract this value. */
3893 bfd_put_32 (output_bfd
,
3894 (gotplt
->output_section
->vma
3895 + gotplt
->output_offset
3897 - plt
->output_section
->vma
3898 - plt
->output_offset
3901 plt
->contents
+ h
->plt
.offset
+ 2);
3903 /* Don't fill PLT entry for static executables. */
3904 if (plt
== htab
->elf
.splt
)
3906 /* Put relocation index. */
3907 bfd_put_32 (output_bfd
, plt_index
,
3908 plt
->contents
+ h
->plt
.offset
+ 7);
3909 /* Put offset for jmp .PLT0. */
3910 bfd_put_32 (output_bfd
, - (h
->plt
.offset
+ PLT_ENTRY_SIZE
),
3911 plt
->contents
+ h
->plt
.offset
+ 12);
3914 /* Fill in the entry in the global offset table, initially this
3915 points to the pushq instruction in the PLT which is at offset 6. */
3916 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
3917 + plt
->output_offset
3918 + h
->plt
.offset
+ 6),
3919 gotplt
->contents
+ got_offset
);
3921 /* Fill in the entry in the .rela.plt section. */
3922 rela
.r_offset
= (gotplt
->output_section
->vma
3923 + gotplt
->output_offset
3925 if (h
->dynindx
== -1
3926 || ((info
->executable
3927 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
3929 && h
->type
== STT_GNU_IFUNC
))
3931 /* If an STT_GNU_IFUNC symbol is locally defined, generate
3932 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
3933 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
3934 rela
.r_addend
= (h
->root
.u
.def
.value
3935 + h
->root
.u
.def
.section
->output_section
->vma
3936 + h
->root
.u
.def
.section
->output_offset
);
3940 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
3944 bed
= get_elf_backend_data (output_bfd
);
3945 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
3946 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
3948 if (!h
->def_regular
)
3950 /* Mark the symbol as undefined, rather than as defined in
3951 the .plt section. Leave the value if there were any
3952 relocations where pointer equality matters (this is a clue
3953 for the dynamic linker, to make function pointer
3954 comparisons work between an application and shared
3955 library), otherwise set it to zero. If a function is only
3956 called from a binary, there is no need to slow down
3957 shared libraries because of that. */
3958 sym
->st_shndx
= SHN_UNDEF
;
3959 if (!h
->pointer_equality_needed
)
3964 if (h
->got
.offset
!= (bfd_vma
) -1
3965 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
3966 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
)
3968 Elf_Internal_Rela rela
;
3970 /* This symbol has an entry in the global offset table. Set it
3972 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
3975 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
3976 + htab
->elf
.sgot
->output_offset
3977 + (h
->got
.offset
&~ (bfd_vma
) 1));
3979 /* If this is a static link, or it is a -Bsymbolic link and the
3980 symbol is defined locally or was forced to be local because
3981 of a version file, we just want to emit a RELATIVE reloc.
3982 The entry in the global offset table will already have been
3983 initialized in the relocate_section function. */
3985 && h
->type
== STT_GNU_IFUNC
)
3989 /* Generate R_X86_64_GLOB_DAT. */
3996 if (!h
->pointer_equality_needed
)
3999 /* For non-shared object, we can't use .got.plt, which
4000 contains the real function addres if we need pointer
4001 equality. We load the GOT entry with the PLT entry. */
4002 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
4003 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
4004 + plt
->output_offset
4006 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
4010 else if (info
->shared
4011 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4013 if (!h
->def_regular
)
4015 BFD_ASSERT((h
->got
.offset
& 1) != 0);
4016 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4017 rela
.r_addend
= (h
->root
.u
.def
.value
4018 + h
->root
.u
.def
.section
->output_section
->vma
4019 + h
->root
.u
.def
.section
->output_offset
);
4023 BFD_ASSERT((h
->got
.offset
& 1) == 0);
4025 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
4026 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
4027 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
4031 elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &rela
);
4036 Elf_Internal_Rela rela
;
4038 /* This symbol needs a copy reloc. Set it up. */
4040 if (h
->dynindx
== -1
4041 || (h
->root
.type
!= bfd_link_hash_defined
4042 && h
->root
.type
!= bfd_link_hash_defweak
)
4043 || htab
->srelbss
== NULL
)
4046 rela
.r_offset
= (h
->root
.u
.def
.value
4047 + h
->root
.u
.def
.section
->output_section
->vma
4048 + h
->root
.u
.def
.section
->output_offset
);
4049 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
4051 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
4054 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. SYM may
4055 be NULL for local symbols. */
4057 && (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
4058 || h
== htab
->elf
.hgot
))
4059 sym
->st_shndx
= SHN_ABS
;
4064 /* Finish up local dynamic symbol handling. We set the contents of
4065 various dynamic sections here. */
4068 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
4070 struct elf_link_hash_entry
*h
4071 = (struct elf_link_hash_entry
*) *slot
;
4072 struct bfd_link_info
*info
4073 = (struct bfd_link_info
*) inf
;
4075 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
4079 /* Used to decide how to sort relocs in an optimal manner for the
4080 dynamic linker, before writing them out. */
4082 static enum elf_reloc_type_class
4083 elf_x86_64_reloc_type_class (const Elf_Internal_Rela
*rela
)
4085 switch ((int) ELF32_R_TYPE (rela
->r_info
))
4087 case R_X86_64_RELATIVE
:
4088 return reloc_class_relative
;
4089 case R_X86_64_JUMP_SLOT
:
4090 return reloc_class_plt
;
4092 return reloc_class_copy
;
4094 return reloc_class_normal
;
4098 /* Finish up the dynamic sections. */
4101 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
4102 struct bfd_link_info
*info
)
4104 struct elf_x86_64_link_hash_table
*htab
;
4108 htab
= elf_x86_64_hash_table (info
);
4112 dynobj
= htab
->elf
.dynobj
;
4113 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
4115 if (htab
->elf
.dynamic_sections_created
)
4117 bfd_byte
*dyncon
, *dynconend
;
4118 const struct elf_backend_data
*bed
;
4119 bfd_size_type sizeof_dyn
;
4121 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
4124 bed
= get_elf_backend_data (dynobj
);
4125 sizeof_dyn
= bed
->s
->sizeof_dyn
;
4126 dyncon
= sdyn
->contents
;
4127 dynconend
= sdyn
->contents
+ sdyn
->size
;
4128 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
4130 Elf_Internal_Dyn dyn
;
4133 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
4141 s
= htab
->elf
.sgotplt
;
4142 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
4146 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
4150 s
= htab
->elf
.srelplt
->output_section
;
4151 dyn
.d_un
.d_val
= s
->size
;
4155 /* The procedure linkage table relocs (DT_JMPREL) should
4156 not be included in the overall relocs (DT_RELA).
4157 Therefore, we override the DT_RELASZ entry here to
4158 make it not include the JMPREL relocs. Since the
4159 linker script arranges for .rela.plt to follow all
4160 other relocation sections, we don't have to worry
4161 about changing the DT_RELA entry. */
4162 if (htab
->elf
.srelplt
!= NULL
)
4164 s
= htab
->elf
.srelplt
->output_section
;
4165 dyn
.d_un
.d_val
-= s
->size
;
4169 case DT_TLSDESC_PLT
:
4171 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
4172 + htab
->tlsdesc_plt
;
4175 case DT_TLSDESC_GOT
:
4177 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
4178 + htab
->tlsdesc_got
;
4182 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
4185 /* Fill in the special first entry in the procedure linkage table. */
4186 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
4188 /* Fill in the first entry in the procedure linkage table. */
4189 memcpy (htab
->elf
.splt
->contents
, elf_x86_64_plt0_entry
,
4191 /* Add offset for pushq GOT+8(%rip), since the instruction
4192 uses 6 bytes subtract this value. */
4193 bfd_put_32 (output_bfd
,
4194 (htab
->elf
.sgotplt
->output_section
->vma
4195 + htab
->elf
.sgotplt
->output_offset
4197 - htab
->elf
.splt
->output_section
->vma
4198 - htab
->elf
.splt
->output_offset
4200 htab
->elf
.splt
->contents
+ 2);
4201 /* Add offset for jmp *GOT+16(%rip). The 12 is the offset to
4202 the end of the instruction. */
4203 bfd_put_32 (output_bfd
,
4204 (htab
->elf
.sgotplt
->output_section
->vma
4205 + htab
->elf
.sgotplt
->output_offset
4207 - htab
->elf
.splt
->output_section
->vma
4208 - htab
->elf
.splt
->output_offset
4210 htab
->elf
.splt
->contents
+ 8);
4212 elf_section_data (htab
->elf
.splt
->output_section
)->this_hdr
.sh_entsize
=
4215 if (htab
->tlsdesc_plt
)
4217 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
4218 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
4220 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
4221 elf_x86_64_plt0_entry
,
4224 /* Add offset for pushq GOT+8(%rip), since the
4225 instruction uses 6 bytes subtract this value. */
4226 bfd_put_32 (output_bfd
,
4227 (htab
->elf
.sgotplt
->output_section
->vma
4228 + htab
->elf
.sgotplt
->output_offset
4230 - htab
->elf
.splt
->output_section
->vma
4231 - htab
->elf
.splt
->output_offset
4234 htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
+ 2);
4235 /* Add offset for jmp *GOT+TDG(%rip), where TGD stands for
4236 htab->tlsdesc_got. The 12 is the offset to the end of
4238 bfd_put_32 (output_bfd
,
4239 (htab
->elf
.sgot
->output_section
->vma
4240 + htab
->elf
.sgot
->output_offset
4242 - htab
->elf
.splt
->output_section
->vma
4243 - htab
->elf
.splt
->output_offset
4246 htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
+ 8);
4251 if (htab
->elf
.sgotplt
)
4253 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
4255 (*_bfd_error_handler
)
4256 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
4260 /* Fill in the first three entries in the global offset table. */
4261 if (htab
->elf
.sgotplt
->size
> 0)
4263 /* Set the first entry in the global offset table to the address of
4264 the dynamic section. */
4266 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
4268 bfd_put_64 (output_bfd
,
4269 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
4270 htab
->elf
.sgotplt
->contents
);
4271 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
4272 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
4273 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
4276 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
4280 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
4281 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
4284 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4285 htab_traverse (htab
->loc_hash_table
,
4286 elf_x86_64_finish_local_dynamic_symbol
,
4292 /* Return address for Ith PLT stub in section PLT, for relocation REL
4293 or (bfd_vma) -1 if it should not be included. */
4296 elf_x86_64_plt_sym_val (bfd_vma i
, const asection
*plt
,
4297 const arelent
*rel ATTRIBUTE_UNUSED
)
4299 return plt
->vma
+ (i
+ 1) * PLT_ENTRY_SIZE
;
4302 /* Handle an x86-64 specific section when reading an object file. This
4303 is called when elfcode.h finds a section with an unknown type. */
4306 elf_x86_64_section_from_shdr (bfd
*abfd
,
4307 Elf_Internal_Shdr
*hdr
,
4311 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
4314 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
4320 /* Hook called by the linker routine which adds symbols from an object
4321 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
4325 elf_x86_64_add_symbol_hook (bfd
*abfd
,
4326 struct bfd_link_info
*info
,
4327 Elf_Internal_Sym
*sym
,
4328 const char **namep ATTRIBUTE_UNUSED
,
4329 flagword
*flagsp ATTRIBUTE_UNUSED
,
4335 switch (sym
->st_shndx
)
4337 case SHN_X86_64_LCOMMON
:
4338 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
4341 lcomm
= bfd_make_section_with_flags (abfd
,
4345 | SEC_LINKER_CREATED
));
4348 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
4351 *valp
= sym
->st_size
;
4355 if ((abfd
->flags
& DYNAMIC
) == 0
4356 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
4357 elf_tdata (info
->output_bfd
)->has_ifunc_symbols
= TRUE
;
4363 /* Given a BFD section, try to locate the corresponding ELF section
4367 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
4368 asection
*sec
, int *index_return
)
4370 if (sec
== &_bfd_elf_large_com_section
)
4372 *index_return
= SHN_X86_64_LCOMMON
;
4378 /* Process a symbol. */
4381 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
4384 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
4386 switch (elfsym
->internal_elf_sym
.st_shndx
)
4388 case SHN_X86_64_LCOMMON
:
4389 asym
->section
= &_bfd_elf_large_com_section
;
4390 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
4391 /* Common symbol doesn't set BSF_GLOBAL. */
4392 asym
->flags
&= ~BSF_GLOBAL
;
4398 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
4400 return (sym
->st_shndx
== SHN_COMMON
4401 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
4405 elf_x86_64_common_section_index (asection
*sec
)
4407 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
4410 return SHN_X86_64_LCOMMON
;
4414 elf_x86_64_common_section (asection
*sec
)
4416 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
4417 return bfd_com_section_ptr
;
4419 return &_bfd_elf_large_com_section
;
4423 elf_x86_64_merge_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4424 struct elf_link_hash_entry
**sym_hash ATTRIBUTE_UNUSED
,
4425 struct elf_link_hash_entry
*h
,
4426 Elf_Internal_Sym
*sym
,
4428 bfd_vma
*pvalue ATTRIBUTE_UNUSED
,
4429 unsigned int *pold_alignment ATTRIBUTE_UNUSED
,
4430 bfd_boolean
*skip ATTRIBUTE_UNUSED
,
4431 bfd_boolean
*override ATTRIBUTE_UNUSED
,
4432 bfd_boolean
*type_change_ok ATTRIBUTE_UNUSED
,
4433 bfd_boolean
*size_change_ok ATTRIBUTE_UNUSED
,
4434 bfd_boolean
*newdef ATTRIBUTE_UNUSED
,
4435 bfd_boolean
*newdyn
,
4436 bfd_boolean
*newdyncommon ATTRIBUTE_UNUSED
,
4437 bfd_boolean
*newweak ATTRIBUTE_UNUSED
,
4438 bfd
*abfd ATTRIBUTE_UNUSED
,
4440 bfd_boolean
*olddef ATTRIBUTE_UNUSED
,
4441 bfd_boolean
*olddyn
,
4442 bfd_boolean
*olddyncommon ATTRIBUTE_UNUSED
,
4443 bfd_boolean
*oldweak ATTRIBUTE_UNUSED
,
4447 /* A normal common symbol and a large common symbol result in a
4448 normal common symbol. We turn the large common symbol into a
4451 && h
->root
.type
== bfd_link_hash_common
4453 && bfd_is_com_section (*sec
)
4456 if (sym
->st_shndx
== SHN_COMMON
4457 && (elf_section_flags (*oldsec
) & SHF_X86_64_LARGE
) != 0)
4459 h
->root
.u
.c
.p
->section
4460 = bfd_make_section_old_way (oldbfd
, "COMMON");
4461 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
4463 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
4464 && (elf_section_flags (*oldsec
) & SHF_X86_64_LARGE
) == 0)
4465 *psec
= *sec
= bfd_com_section_ptr
;
4472 elf_x86_64_additional_program_headers (bfd
*abfd
,
4473 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
4478 /* Check to see if we need a large readonly segment. */
4479 s
= bfd_get_section_by_name (abfd
, ".lrodata");
4480 if (s
&& (s
->flags
& SEC_LOAD
))
4483 /* Check to see if we need a large data segment. Since .lbss sections
4484 is placed right after the .bss section, there should be no need for
4485 a large data segment just because of .lbss. */
4486 s
= bfd_get_section_by_name (abfd
, ".ldata");
4487 if (s
&& (s
->flags
& SEC_LOAD
))
4493 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
4496 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
4498 if (h
->plt
.offset
!= (bfd_vma
) -1
4500 && !h
->pointer_equality_needed
)
4503 return _bfd_elf_hash_symbol (h
);
4506 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
4509 elf_x86_64_relocs_compatible (const bfd_target
*input
,
4510 const bfd_target
*output
)
4512 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
4513 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
4514 && _bfd_elf_relocs_compatible (input
, output
));
4517 static const struct bfd_elf_special_section
4518 elf_x86_64_special_sections
[]=
4520 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
4521 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
4522 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
4523 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
4524 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
4525 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
4526 { NULL
, 0, 0, 0, 0 }
4529 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_vec
4530 #define TARGET_LITTLE_NAME "elf64-x86-64"
4531 #define ELF_ARCH bfd_arch_i386
4532 #define ELF_TARGET_ID X86_64_ELF_DATA
4533 #define ELF_MACHINE_CODE EM_X86_64
4534 #define ELF_MAXPAGESIZE 0x200000
4535 #define ELF_MINPAGESIZE 0x1000
4536 #define ELF_COMMONPAGESIZE 0x1000
4538 #define elf_backend_can_gc_sections 1
4539 #define elf_backend_can_refcount 1
4540 #define elf_backend_want_got_plt 1
4541 #define elf_backend_plt_readonly 1
4542 #define elf_backend_want_plt_sym 0
4543 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
4544 #define elf_backend_rela_normal 1
4546 #define elf_info_to_howto elf_x86_64_info_to_howto
4548 #define bfd_elf64_bfd_link_hash_table_create \
4549 elf_x86_64_link_hash_table_create
4550 #define bfd_elf64_bfd_link_hash_table_free \
4551 elf_x86_64_link_hash_table_free
4552 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
4553 #define bfd_elf64_bfd_reloc_name_lookup \
4554 elf_x86_64_reloc_name_lookup
4556 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
4557 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
4558 #define elf_backend_check_relocs elf_x86_64_check_relocs
4559 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
4560 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
4561 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
4562 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
4563 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
4564 #define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
4565 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
4566 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
4567 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
4568 #define elf_backend_relocate_section elf_x86_64_relocate_section
4569 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
4570 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
4571 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
4572 #define elf_backend_plt_sym_val elf_x86_64_plt_sym_val
4573 #define elf_backend_object_p elf64_x86_64_elf_object_p
4574 #define bfd_elf64_mkobject elf_x86_64_mkobject
4576 #define elf_backend_section_from_shdr \
4577 elf_x86_64_section_from_shdr
4579 #define elf_backend_section_from_bfd_section \
4580 elf_x86_64_elf_section_from_bfd_section
4581 #define elf_backend_add_symbol_hook \
4582 elf_x86_64_add_symbol_hook
4583 #define elf_backend_symbol_processing \
4584 elf_x86_64_symbol_processing
4585 #define elf_backend_common_section_index \
4586 elf_x86_64_common_section_index
4587 #define elf_backend_common_section \
4588 elf_x86_64_common_section
4589 #define elf_backend_common_definition \
4590 elf_x86_64_common_definition
4591 #define elf_backend_merge_symbol \
4592 elf_x86_64_merge_symbol
4593 #define elf_backend_special_sections \
4594 elf_x86_64_special_sections
4595 #define elf_backend_additional_program_headers \
4596 elf_x86_64_additional_program_headers
4597 #define elf_backend_hash_symbol \
4598 elf_x86_64_hash_symbol
4600 #undef elf_backend_post_process_headers
4601 #define elf_backend_post_process_headers _bfd_elf_set_osabi
4603 #include "elf64-target.h"
4605 /* FreeBSD support. */
4607 #undef TARGET_LITTLE_SYM
4608 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_freebsd_vec
4609 #undef TARGET_LITTLE_NAME
4610 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
4613 #define ELF_OSABI ELFOSABI_FREEBSD
4616 #define elf64_bed elf64_x86_64_fbsd_bed
4618 #include "elf64-target.h"
4620 /* Solaris 2 support. */
4622 #undef TARGET_LITTLE_SYM
4623 #define TARGET_LITTLE_SYM bfd_elf64_x86_64_sol2_vec
4624 #undef TARGET_LITTLE_NAME
4625 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
4627 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
4628 objects won't be recognized. */
4632 #define elf64_bed elf64_x86_64_sol2_bed
4634 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
4636 #undef elf_backend_static_tls_alignment
4637 #define elf_backend_static_tls_alignment 16
4639 /* The Solaris 2 ABI requires a plt symbol on all platforms.
4641 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
4643 #undef elf_backend_want_plt_sym
4644 #define elf_backend_want_plt_sym 1
4646 #include "elf64-target.h"
4648 /* Intel L1OM support. */
4651 elf64_l1om_elf_object_p (bfd
*abfd
)
4653 /* Set the right machine number for an L1OM elf64 file. */
4654 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
4658 #undef TARGET_LITTLE_SYM
4659 #define TARGET_LITTLE_SYM bfd_elf64_l1om_vec
4660 #undef TARGET_LITTLE_NAME
4661 #define TARGET_LITTLE_NAME "elf64-l1om"
4663 #define ELF_ARCH bfd_arch_l1om
4665 #undef ELF_MACHINE_CODE
4666 #define ELF_MACHINE_CODE EM_L1OM
4671 #define elf64_bed elf64_l1om_bed
4673 #undef elf_backend_object_p
4674 #define elf_backend_object_p elf64_l1om_elf_object_p
4676 #undef elf_backend_post_process_headers
4677 #undef elf_backend_static_tls_alignment
4679 #include "elf64-target.h"
4681 /* FreeBSD L1OM support. */
4683 #undef TARGET_LITTLE_SYM
4684 #define TARGET_LITTLE_SYM bfd_elf64_l1om_freebsd_vec
4685 #undef TARGET_LITTLE_NAME
4686 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
4689 #define ELF_OSABI ELFOSABI_FREEBSD
4692 #define elf64_bed elf64_l1om_fbsd_bed
4694 #undef elf_backend_post_process_headers
4695 #define elf_backend_post_process_headers _bfd_elf_set_osabi
4697 #include "elf64-target.h"
4699 /* 32bit x86-64 support. */
4702 elf32_x86_64_elf_object_p (bfd
*abfd
)
4704 /* Set the right machine number for an x86-64 elf32 file. */
4705 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
4709 #undef TARGET_LITTLE_SYM
4710 #define TARGET_LITTLE_SYM bfd_elf32_x86_64_vec
4711 #undef TARGET_LITTLE_NAME
4712 #define TARGET_LITTLE_NAME "elf32-x86-64"
4715 #define ELF_ARCH bfd_arch_i386
4717 #undef ELF_MACHINE_CODE
4718 #define ELF_MACHINE_CODE EM_X86_64
4720 #define bfd_elf32_bfd_link_hash_table_create \
4721 elf_x86_64_link_hash_table_create
4722 #define bfd_elf32_bfd_link_hash_table_free \
4723 elf_x86_64_link_hash_table_free
4724 #define bfd_elf32_bfd_reloc_type_lookup \
4725 elf_x86_64_reloc_type_lookup
4726 #define bfd_elf32_bfd_reloc_name_lookup \
4727 elf_x86_64_reloc_name_lookup
4728 #define bfd_elf32_mkobject \
4733 #undef elf_backend_post_process_headers
4735 #undef elf_backend_object_p
4736 #define elf_backend_object_p \
4737 elf32_x86_64_elf_object_p
4739 #undef elf_backend_bfd_from_remote_memory
4740 #define elf_backend_bfd_from_remote_memory \
4741 _bfd_elf32_bfd_from_remote_memory
4743 #undef elf_backend_size_info
4744 #define elf_backend_size_info \
4745 _bfd_elf32_size_info
4747 #include "elf32-target.h"