1 /* X86-64 specific support for ELF
2 Copyright (C) 2000-2016 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka <jh@suse.cz>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
28 #include "bfd_stdint.h"
32 #include "libiberty.h"
34 #include "opcode/i386.h"
35 #include "elf/x86-64.h"
42 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
43 #define MINUS_ONE (~ (bfd_vma) 0)
45 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
46 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
47 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
48 since they are the same. */
50 #define ABI_64_P(abfd) \
51 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
53 /* The relocation "howto" table. Order of fields:
54 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
55 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
56 static reloc_howto_type x86_64_elf_howto_table
[] =
58 HOWTO(R_X86_64_NONE
, 0, 3, 0, FALSE
, 0, complain_overflow_dont
,
59 bfd_elf_generic_reloc
, "R_X86_64_NONE", FALSE
, 0x00000000, 0x00000000,
61 HOWTO(R_X86_64_64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
62 bfd_elf_generic_reloc
, "R_X86_64_64", FALSE
, MINUS_ONE
, MINUS_ONE
,
64 HOWTO(R_X86_64_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
65 bfd_elf_generic_reloc
, "R_X86_64_PC32", FALSE
, 0xffffffff, 0xffffffff,
67 HOWTO(R_X86_64_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
68 bfd_elf_generic_reloc
, "R_X86_64_GOT32", FALSE
, 0xffffffff, 0xffffffff,
70 HOWTO(R_X86_64_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
71 bfd_elf_generic_reloc
, "R_X86_64_PLT32", FALSE
, 0xffffffff, 0xffffffff,
73 HOWTO(R_X86_64_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
74 bfd_elf_generic_reloc
, "R_X86_64_COPY", FALSE
, 0xffffffff, 0xffffffff,
76 HOWTO(R_X86_64_GLOB_DAT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
77 bfd_elf_generic_reloc
, "R_X86_64_GLOB_DAT", FALSE
, MINUS_ONE
,
79 HOWTO(R_X86_64_JUMP_SLOT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
80 bfd_elf_generic_reloc
, "R_X86_64_JUMP_SLOT", FALSE
, MINUS_ONE
,
82 HOWTO(R_X86_64_RELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
83 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE", FALSE
, MINUS_ONE
,
85 HOWTO(R_X86_64_GOTPCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
86 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL", FALSE
, 0xffffffff,
88 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
89 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
91 HOWTO(R_X86_64_32S
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
92 bfd_elf_generic_reloc
, "R_X86_64_32S", FALSE
, 0xffffffff, 0xffffffff,
94 HOWTO(R_X86_64_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
95 bfd_elf_generic_reloc
, "R_X86_64_16", FALSE
, 0xffff, 0xffff, FALSE
),
96 HOWTO(R_X86_64_PC16
,0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
97 bfd_elf_generic_reloc
, "R_X86_64_PC16", FALSE
, 0xffff, 0xffff, TRUE
),
98 HOWTO(R_X86_64_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
99 bfd_elf_generic_reloc
, "R_X86_64_8", FALSE
, 0xff, 0xff, FALSE
),
100 HOWTO(R_X86_64_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
101 bfd_elf_generic_reloc
, "R_X86_64_PC8", FALSE
, 0xff, 0xff, TRUE
),
102 HOWTO(R_X86_64_DTPMOD64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
103 bfd_elf_generic_reloc
, "R_X86_64_DTPMOD64", FALSE
, MINUS_ONE
,
105 HOWTO(R_X86_64_DTPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
106 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF64", FALSE
, MINUS_ONE
,
108 HOWTO(R_X86_64_TPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
109 bfd_elf_generic_reloc
, "R_X86_64_TPOFF64", FALSE
, MINUS_ONE
,
111 HOWTO(R_X86_64_TLSGD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
112 bfd_elf_generic_reloc
, "R_X86_64_TLSGD", FALSE
, 0xffffffff,
114 HOWTO(R_X86_64_TLSLD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
115 bfd_elf_generic_reloc
, "R_X86_64_TLSLD", FALSE
, 0xffffffff,
117 HOWTO(R_X86_64_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
118 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF32", FALSE
, 0xffffffff,
120 HOWTO(R_X86_64_GOTTPOFF
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
121 bfd_elf_generic_reloc
, "R_X86_64_GOTTPOFF", FALSE
, 0xffffffff,
123 HOWTO(R_X86_64_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
124 bfd_elf_generic_reloc
, "R_X86_64_TPOFF32", FALSE
, 0xffffffff,
126 HOWTO(R_X86_64_PC64
, 0, 4, 64, TRUE
, 0, complain_overflow_bitfield
,
127 bfd_elf_generic_reloc
, "R_X86_64_PC64", FALSE
, MINUS_ONE
, MINUS_ONE
,
129 HOWTO(R_X86_64_GOTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
130 bfd_elf_generic_reloc
, "R_X86_64_GOTOFF64",
131 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
132 HOWTO(R_X86_64_GOTPC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
133 bfd_elf_generic_reloc
, "R_X86_64_GOTPC32",
134 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
135 HOWTO(R_X86_64_GOT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
136 bfd_elf_generic_reloc
, "R_X86_64_GOT64", FALSE
, MINUS_ONE
, MINUS_ONE
,
138 HOWTO(R_X86_64_GOTPCREL64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
139 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL64", FALSE
, MINUS_ONE
,
141 HOWTO(R_X86_64_GOTPC64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
142 bfd_elf_generic_reloc
, "R_X86_64_GOTPC64",
143 FALSE
, MINUS_ONE
, MINUS_ONE
, TRUE
),
144 HOWTO(R_X86_64_GOTPLT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
145 bfd_elf_generic_reloc
, "R_X86_64_GOTPLT64", FALSE
, MINUS_ONE
,
147 HOWTO(R_X86_64_PLTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
148 bfd_elf_generic_reloc
, "R_X86_64_PLTOFF64", FALSE
, MINUS_ONE
,
150 HOWTO(R_X86_64_SIZE32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
151 bfd_elf_generic_reloc
, "R_X86_64_SIZE32", FALSE
, 0xffffffff, 0xffffffff,
153 HOWTO(R_X86_64_SIZE64
, 0, 4, 64, FALSE
, 0, complain_overflow_unsigned
,
154 bfd_elf_generic_reloc
, "R_X86_64_SIZE64", FALSE
, MINUS_ONE
, MINUS_ONE
,
156 HOWTO(R_X86_64_GOTPC32_TLSDESC
, 0, 2, 32, TRUE
, 0,
157 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
158 "R_X86_64_GOTPC32_TLSDESC",
159 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
160 HOWTO(R_X86_64_TLSDESC_CALL
, 0, 0, 0, FALSE
, 0,
161 complain_overflow_dont
, bfd_elf_generic_reloc
,
162 "R_X86_64_TLSDESC_CALL",
164 HOWTO(R_X86_64_TLSDESC
, 0, 4, 64, FALSE
, 0,
165 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
167 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
168 HOWTO(R_X86_64_IRELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
169 bfd_elf_generic_reloc
, "R_X86_64_IRELATIVE", FALSE
, MINUS_ONE
,
171 HOWTO(R_X86_64_RELATIVE64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
172 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE64", FALSE
, MINUS_ONE
,
174 HOWTO(R_X86_64_PC32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
175 bfd_elf_generic_reloc
, "R_X86_64_PC32_BND", FALSE
, 0xffffffff, 0xffffffff,
177 HOWTO(R_X86_64_PLT32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
178 bfd_elf_generic_reloc
, "R_X86_64_PLT32_BND", FALSE
, 0xffffffff, 0xffffffff,
180 HOWTO(R_X86_64_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
181 bfd_elf_generic_reloc
, "R_X86_64_GOTPCRELX", FALSE
, 0xffffffff,
183 HOWTO(R_X86_64_REX_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
184 bfd_elf_generic_reloc
, "R_X86_64_REX_GOTPCRELX", FALSE
, 0xffffffff,
187 /* We have a gap in the reloc numbers here.
188 R_X86_64_standard counts the number up to this point, and
189 R_X86_64_vt_offset is the value to subtract from a reloc type of
190 R_X86_64_GNU_VT* to form an index into this table. */
191 #define R_X86_64_standard (R_X86_64_REX_GOTPCRELX + 1)
192 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
194 /* GNU extension to record C++ vtable hierarchy. */
195 HOWTO (R_X86_64_GNU_VTINHERIT
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
196 NULL
, "R_X86_64_GNU_VTINHERIT", FALSE
, 0, 0, FALSE
),
198 /* GNU extension to record C++ vtable member usage. */
199 HOWTO (R_X86_64_GNU_VTENTRY
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
200 _bfd_elf_rel_vtable_reloc_fn
, "R_X86_64_GNU_VTENTRY", FALSE
, 0, 0,
203 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
204 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
205 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
209 #define IS_X86_64_PCREL_TYPE(TYPE) \
210 ( ((TYPE) == R_X86_64_PC8) \
211 || ((TYPE) == R_X86_64_PC16) \
212 || ((TYPE) == R_X86_64_PC32) \
213 || ((TYPE) == R_X86_64_PC32_BND) \
214 || ((TYPE) == R_X86_64_PC64))
216 /* Map BFD relocs to the x86_64 elf relocs. */
219 bfd_reloc_code_real_type bfd_reloc_val
;
220 unsigned char elf_reloc_val
;
223 static const struct elf_reloc_map x86_64_reloc_map
[] =
225 { BFD_RELOC_NONE
, R_X86_64_NONE
, },
226 { BFD_RELOC_64
, R_X86_64_64
, },
227 { BFD_RELOC_32_PCREL
, R_X86_64_PC32
, },
228 { BFD_RELOC_X86_64_GOT32
, R_X86_64_GOT32
,},
229 { BFD_RELOC_X86_64_PLT32
, R_X86_64_PLT32
,},
230 { BFD_RELOC_X86_64_COPY
, R_X86_64_COPY
, },
231 { BFD_RELOC_X86_64_GLOB_DAT
, R_X86_64_GLOB_DAT
, },
232 { BFD_RELOC_X86_64_JUMP_SLOT
, R_X86_64_JUMP_SLOT
, },
233 { BFD_RELOC_X86_64_RELATIVE
, R_X86_64_RELATIVE
, },
234 { BFD_RELOC_X86_64_GOTPCREL
, R_X86_64_GOTPCREL
, },
235 { BFD_RELOC_32
, R_X86_64_32
, },
236 { BFD_RELOC_X86_64_32S
, R_X86_64_32S
, },
237 { BFD_RELOC_16
, R_X86_64_16
, },
238 { BFD_RELOC_16_PCREL
, R_X86_64_PC16
, },
239 { BFD_RELOC_8
, R_X86_64_8
, },
240 { BFD_RELOC_8_PCREL
, R_X86_64_PC8
, },
241 { BFD_RELOC_X86_64_DTPMOD64
, R_X86_64_DTPMOD64
, },
242 { BFD_RELOC_X86_64_DTPOFF64
, R_X86_64_DTPOFF64
, },
243 { BFD_RELOC_X86_64_TPOFF64
, R_X86_64_TPOFF64
, },
244 { BFD_RELOC_X86_64_TLSGD
, R_X86_64_TLSGD
, },
245 { BFD_RELOC_X86_64_TLSLD
, R_X86_64_TLSLD
, },
246 { BFD_RELOC_X86_64_DTPOFF32
, R_X86_64_DTPOFF32
, },
247 { BFD_RELOC_X86_64_GOTTPOFF
, R_X86_64_GOTTPOFF
, },
248 { BFD_RELOC_X86_64_TPOFF32
, R_X86_64_TPOFF32
, },
249 { BFD_RELOC_64_PCREL
, R_X86_64_PC64
, },
250 { BFD_RELOC_X86_64_GOTOFF64
, R_X86_64_GOTOFF64
, },
251 { BFD_RELOC_X86_64_GOTPC32
, R_X86_64_GOTPC32
, },
252 { BFD_RELOC_X86_64_GOT64
, R_X86_64_GOT64
, },
253 { BFD_RELOC_X86_64_GOTPCREL64
,R_X86_64_GOTPCREL64
, },
254 { BFD_RELOC_X86_64_GOTPC64
, R_X86_64_GOTPC64
, },
255 { BFD_RELOC_X86_64_GOTPLT64
, R_X86_64_GOTPLT64
, },
256 { BFD_RELOC_X86_64_PLTOFF64
, R_X86_64_PLTOFF64
, },
257 { BFD_RELOC_SIZE32
, R_X86_64_SIZE32
, },
258 { BFD_RELOC_SIZE64
, R_X86_64_SIZE64
, },
259 { BFD_RELOC_X86_64_GOTPC32_TLSDESC
, R_X86_64_GOTPC32_TLSDESC
, },
260 { BFD_RELOC_X86_64_TLSDESC_CALL
, R_X86_64_TLSDESC_CALL
, },
261 { BFD_RELOC_X86_64_TLSDESC
, R_X86_64_TLSDESC
, },
262 { BFD_RELOC_X86_64_IRELATIVE
, R_X86_64_IRELATIVE
, },
263 { BFD_RELOC_X86_64_PC32_BND
, R_X86_64_PC32_BND
, },
264 { BFD_RELOC_X86_64_PLT32_BND
, R_X86_64_PLT32_BND
, },
265 { BFD_RELOC_X86_64_GOTPCRELX
, R_X86_64_GOTPCRELX
, },
266 { BFD_RELOC_X86_64_REX_GOTPCRELX
, R_X86_64_REX_GOTPCRELX
, },
267 { BFD_RELOC_VTABLE_INHERIT
, R_X86_64_GNU_VTINHERIT
, },
268 { BFD_RELOC_VTABLE_ENTRY
, R_X86_64_GNU_VTENTRY
, },
271 static reloc_howto_type
*
272 elf_x86_64_rtype_to_howto (bfd
*abfd
, unsigned r_type
)
276 if (r_type
== (unsigned int) R_X86_64_32
)
281 i
= ARRAY_SIZE (x86_64_elf_howto_table
) - 1;
283 else if (r_type
< (unsigned int) R_X86_64_GNU_VTINHERIT
284 || r_type
>= (unsigned int) R_X86_64_max
)
286 if (r_type
>= (unsigned int) R_X86_64_standard
)
288 (*_bfd_error_handler
) (_("%B: invalid relocation type %d"),
290 r_type
= R_X86_64_NONE
;
295 i
= r_type
- (unsigned int) R_X86_64_vt_offset
;
296 BFD_ASSERT (x86_64_elf_howto_table
[i
].type
== r_type
);
297 return &x86_64_elf_howto_table
[i
];
300 /* Given a BFD reloc type, return a HOWTO structure. */
301 static reloc_howto_type
*
302 elf_x86_64_reloc_type_lookup (bfd
*abfd
,
303 bfd_reloc_code_real_type code
)
307 for (i
= 0; i
< sizeof (x86_64_reloc_map
) / sizeof (struct elf_reloc_map
);
310 if (x86_64_reloc_map
[i
].bfd_reloc_val
== code
)
311 return elf_x86_64_rtype_to_howto (abfd
,
312 x86_64_reloc_map
[i
].elf_reloc_val
);
317 static reloc_howto_type
*
318 elf_x86_64_reloc_name_lookup (bfd
*abfd
,
323 if (!ABI_64_P (abfd
) && strcasecmp (r_name
, "R_X86_64_32") == 0)
325 /* Get x32 R_X86_64_32. */
326 reloc_howto_type
*reloc
327 = &x86_64_elf_howto_table
[ARRAY_SIZE (x86_64_elf_howto_table
) - 1];
328 BFD_ASSERT (reloc
->type
== (unsigned int) R_X86_64_32
);
332 for (i
= 0; i
< ARRAY_SIZE (x86_64_elf_howto_table
); i
++)
333 if (x86_64_elf_howto_table
[i
].name
!= NULL
334 && strcasecmp (x86_64_elf_howto_table
[i
].name
, r_name
) == 0)
335 return &x86_64_elf_howto_table
[i
];
340 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
343 elf_x86_64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
344 Elf_Internal_Rela
*dst
)
348 r_type
= ELF32_R_TYPE (dst
->r_info
);
349 cache_ptr
->howto
= elf_x86_64_rtype_to_howto (abfd
, r_type
);
350 BFD_ASSERT (r_type
== cache_ptr
->howto
->type
);
353 /* Support for core dump NOTE sections. */
355 elf_x86_64_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
360 switch (note
->descsz
)
365 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
367 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
370 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
378 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
380 elf_tdata (abfd
)->core
->signal
381 = bfd_get_16 (abfd
, note
->descdata
+ 12);
384 elf_tdata (abfd
)->core
->lwpid
385 = bfd_get_32 (abfd
, note
->descdata
+ 32);
394 /* Make a ".reg/999" section. */
395 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
396 size
, note
->descpos
+ offset
);
400 elf_x86_64_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
402 switch (note
->descsz
)
407 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
408 elf_tdata (abfd
)->core
->pid
409 = bfd_get_32 (abfd
, note
->descdata
+ 12);
410 elf_tdata (abfd
)->core
->program
411 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
412 elf_tdata (abfd
)->core
->command
413 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
416 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
417 elf_tdata (abfd
)->core
->pid
418 = bfd_get_32 (abfd
, note
->descdata
+ 24);
419 elf_tdata (abfd
)->core
->program
420 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
421 elf_tdata (abfd
)->core
->command
422 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
425 /* Note that for some reason, a spurious space is tacked
426 onto the end of the args in some (at least one anyway)
427 implementations, so strip it off if it exists. */
430 char *command
= elf_tdata (abfd
)->core
->command
;
431 int n
= strlen (command
);
433 if (0 < n
&& command
[n
- 1] == ' ')
434 command
[n
- 1] = '\0';
442 elf_x86_64_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
,
445 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
447 const char *fname
, *psargs
;
458 va_start (ap
, note_type
);
459 fname
= va_arg (ap
, const char *);
460 psargs
= va_arg (ap
, const char *);
463 if (bed
->s
->elfclass
== ELFCLASS32
)
466 memset (&data
, 0, sizeof (data
));
467 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
468 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
469 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
470 &data
, sizeof (data
));
475 memset (&data
, 0, sizeof (data
));
476 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
477 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
478 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
479 &data
, sizeof (data
));
484 va_start (ap
, note_type
);
485 pid
= va_arg (ap
, long);
486 cursig
= va_arg (ap
, int);
487 gregs
= va_arg (ap
, const void *);
490 if (bed
->s
->elfclass
== ELFCLASS32
)
492 if (bed
->elf_machine_code
== EM_X86_64
)
494 prstatusx32_t prstat
;
495 memset (&prstat
, 0, sizeof (prstat
));
497 prstat
.pr_cursig
= cursig
;
498 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
499 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
500 &prstat
, sizeof (prstat
));
505 memset (&prstat
, 0, sizeof (prstat
));
507 prstat
.pr_cursig
= cursig
;
508 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
509 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
510 &prstat
, sizeof (prstat
));
516 memset (&prstat
, 0, sizeof (prstat
));
518 prstat
.pr_cursig
= cursig
;
519 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
520 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
521 &prstat
, sizeof (prstat
));
528 /* Functions for the x86-64 ELF linker. */
530 /* The name of the dynamic interpreter. This is put in the .interp
533 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
534 #define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
536 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
537 copying dynamic variables from a shared lib into an app's dynbss
538 section, and instead use a dynamic relocation to point into the
540 #define ELIMINATE_COPY_RELOCS 1
542 /* The size in bytes of an entry in the global offset table. */
544 #define GOT_ENTRY_SIZE 8
546 /* The size in bytes of an entry in the procedure linkage table. */
548 #define PLT_ENTRY_SIZE 16
550 /* The first entry in a procedure linkage table looks like this. See the
551 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
553 static const bfd_byte elf_x86_64_plt0_entry
[PLT_ENTRY_SIZE
] =
555 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
556 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
557 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
560 /* Subsequent entries in a procedure linkage table look like this. */
562 static const bfd_byte elf_x86_64_plt_entry
[PLT_ENTRY_SIZE
] =
564 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
565 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
566 0x68, /* pushq immediate */
567 0, 0, 0, 0, /* replaced with index into relocation table. */
568 0xe9, /* jmp relative */
569 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
572 /* The first entry in a procedure linkage table with BND relocations
575 static const bfd_byte elf_x86_64_bnd_plt0_entry
[PLT_ENTRY_SIZE
] =
577 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
578 0xf2, 0xff, 0x25, 16, 0, 0, 0, /* bnd jmpq *GOT+16(%rip) */
579 0x0f, 0x1f, 0 /* nopl (%rax) */
582 /* Subsequent entries for legacy branches in a procedure linkage table
583 with BND relocations look like this. */
585 static const bfd_byte elf_x86_64_legacy_plt_entry
[PLT_ENTRY_SIZE
] =
587 0x68, 0, 0, 0, 0, /* pushq immediate */
588 0xe9, 0, 0, 0, 0, /* jmpq relative */
589 0x66, 0x0f, 0x1f, 0x44, 0, 0 /* nopw (%rax,%rax,1) */
592 /* Subsequent entries for branches with BND prefx in a procedure linkage
593 table with BND relocations look like this. */
595 static const bfd_byte elf_x86_64_bnd_plt_entry
[PLT_ENTRY_SIZE
] =
597 0x68, 0, 0, 0, 0, /* pushq immediate */
598 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
599 0x0f, 0x1f, 0x44, 0, 0 /* nopl 0(%rax,%rax,1) */
602 /* Entries for legacy branches in the second procedure linkage table
605 static const bfd_byte elf_x86_64_legacy_plt2_entry
[8] =
607 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
608 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
609 0x66, 0x90 /* xchg %ax,%ax */
612 /* Entries for branches with BND prefix in the second procedure linkage
613 table look like this. */
615 static const bfd_byte elf_x86_64_bnd_plt2_entry
[8] =
617 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
618 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
622 /* .eh_frame covering the .plt section. */
624 static const bfd_byte elf_x86_64_eh_frame_plt
[] =
626 #define PLT_CIE_LENGTH 20
627 #define PLT_FDE_LENGTH 36
628 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
629 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
630 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
631 0, 0, 0, 0, /* CIE ID */
633 'z', 'R', 0, /* Augmentation string */
634 1, /* Code alignment factor */
635 0x78, /* Data alignment factor */
636 16, /* Return address column */
637 1, /* Augmentation size */
638 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
639 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
640 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
641 DW_CFA_nop
, DW_CFA_nop
,
643 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
644 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
645 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
646 0, 0, 0, 0, /* .plt size goes here */
647 0, /* Augmentation size */
648 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
649 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
650 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
651 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
652 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
653 11, /* Block length */
654 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
655 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
656 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
657 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
658 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
661 /* Architecture-specific backend data for x86-64. */
663 struct elf_x86_64_backend_data
665 /* Templates for the initial PLT entry and for subsequent entries. */
666 const bfd_byte
*plt0_entry
;
667 const bfd_byte
*plt_entry
;
668 unsigned int plt_entry_size
; /* Size of each PLT entry. */
670 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
671 unsigned int plt0_got1_offset
;
672 unsigned int plt0_got2_offset
;
674 /* Offset of the end of the PC-relative instruction containing
676 unsigned int plt0_got2_insn_end
;
678 /* Offsets into plt_entry that are to be replaced with... */
679 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
680 unsigned int plt_reloc_offset
; /* ... offset into relocation table. */
681 unsigned int plt_plt_offset
; /* ... offset to start of .plt. */
683 /* Length of the PC-relative instruction containing plt_got_offset. */
684 unsigned int plt_got_insn_size
;
686 /* Offset of the end of the PC-relative jump to plt0_entry. */
687 unsigned int plt_plt_insn_end
;
689 /* Offset into plt_entry where the initial value of the GOT entry points. */
690 unsigned int plt_lazy_offset
;
692 /* .eh_frame covering the .plt section. */
693 const bfd_byte
*eh_frame_plt
;
694 unsigned int eh_frame_plt_size
;
697 #define get_elf_x86_64_arch_data(bed) \
698 ((const struct elf_x86_64_backend_data *) (bed)->arch_data)
700 #define get_elf_x86_64_backend_data(abfd) \
701 get_elf_x86_64_arch_data (get_elf_backend_data (abfd))
703 #define GET_PLT_ENTRY_SIZE(abfd) \
704 get_elf_x86_64_backend_data (abfd)->plt_entry_size
706 /* These are the standard parameters. */
707 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed
=
709 elf_x86_64_plt0_entry
, /* plt0_entry */
710 elf_x86_64_plt_entry
, /* plt_entry */
711 sizeof (elf_x86_64_plt_entry
), /* plt_entry_size */
712 2, /* plt0_got1_offset */
713 8, /* plt0_got2_offset */
714 12, /* plt0_got2_insn_end */
715 2, /* plt_got_offset */
716 7, /* plt_reloc_offset */
717 12, /* plt_plt_offset */
718 6, /* plt_got_insn_size */
719 PLT_ENTRY_SIZE
, /* plt_plt_insn_end */
720 6, /* plt_lazy_offset */
721 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
722 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
725 static const struct elf_x86_64_backend_data elf_x86_64_bnd_arch_bed
=
727 elf_x86_64_bnd_plt0_entry
, /* plt0_entry */
728 elf_x86_64_bnd_plt_entry
, /* plt_entry */
729 sizeof (elf_x86_64_bnd_plt_entry
), /* plt_entry_size */
730 2, /* plt0_got1_offset */
731 1+8, /* plt0_got2_offset */
732 1+12, /* plt0_got2_insn_end */
733 1+2, /* plt_got_offset */
734 1, /* plt_reloc_offset */
735 7, /* plt_plt_offset */
736 1+6, /* plt_got_insn_size */
737 11, /* plt_plt_insn_end */
738 0, /* plt_lazy_offset */
739 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
740 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
743 #define elf_backend_arch_data &elf_x86_64_arch_bed
745 /* Is a undefined weak symbol which is resolved to 0. Reference to an
746 undefined weak symbol is resolved to 0 when building executable if
748 1. Has non-GOT/non-PLT relocations in text section. Or
749 2. Has no GOT/PLT relocation.
751 #define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, GOT_RELOC, EH) \
752 ((EH)->elf.root.type == bfd_link_hash_undefweak \
753 && bfd_link_executable (INFO) \
754 && (elf_x86_64_hash_table (INFO)->interp == NULL \
756 || (EH)->has_non_got_reloc \
757 || !(INFO)->dynamic_undefined_weak))
759 /* x86-64 ELF linker hash entry. */
761 struct elf_x86_64_link_hash_entry
763 struct elf_link_hash_entry elf
;
765 /* Track dynamic relocs copied for this symbol. */
766 struct elf_dyn_relocs
*dyn_relocs
;
768 #define GOT_UNKNOWN 0
772 #define GOT_TLS_GDESC 4
773 #define GOT_TLS_GD_BOTH_P(type) \
774 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
775 #define GOT_TLS_GD_P(type) \
776 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
777 #define GOT_TLS_GDESC_P(type) \
778 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
779 #define GOT_TLS_GD_ANY_P(type) \
780 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
781 unsigned char tls_type
;
783 /* TRUE if a weak symbol with a real definition needs a copy reloc.
784 When there is a weak symbol with a real definition, the processor
785 independent code will have arranged for us to see the real
786 definition first. We need to copy the needs_copy bit from the
787 real definition and check it when allowing copy reloc in PIE. */
788 unsigned int needs_copy
: 1;
790 /* TRUE if symbol has at least one BND relocation. */
791 unsigned int has_bnd_reloc
: 1;
793 /* TRUE if symbol has GOT or PLT relocations. */
794 unsigned int has_got_reloc
: 1;
796 /* TRUE if symbol has non-GOT/non-PLT relocations in text sections. */
797 unsigned int has_non_got_reloc
: 1;
799 /* Reference count of C/C++ function pointer relocations in read-write
800 section which can be resolved at run-time. */
801 bfd_signed_vma func_pointer_refcount
;
803 /* Information about the GOT PLT entry. Filled when there are both
804 GOT and PLT relocations against the same function. */
805 union gotplt_union plt_got
;
807 /* Information about the second PLT entry. Filled when has_bnd_reloc is
809 union gotplt_union plt_bnd
;
811 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
812 starting at the end of the jump table. */
816 #define elf_x86_64_hash_entry(ent) \
817 ((struct elf_x86_64_link_hash_entry *)(ent))
819 struct elf_x86_64_obj_tdata
821 struct elf_obj_tdata root
;
823 /* tls_type for each local got entry. */
824 char *local_got_tls_type
;
826 /* GOTPLT entries for TLS descriptors. */
827 bfd_vma
*local_tlsdesc_gotent
;
830 #define elf_x86_64_tdata(abfd) \
831 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
833 #define elf_x86_64_local_got_tls_type(abfd) \
834 (elf_x86_64_tdata (abfd)->local_got_tls_type)
836 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
837 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
839 #define is_x86_64_elf(bfd) \
840 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
841 && elf_tdata (bfd) != NULL \
842 && elf_object_id (bfd) == X86_64_ELF_DATA)
845 elf_x86_64_mkobject (bfd
*abfd
)
847 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_x86_64_obj_tdata
),
851 /* x86-64 ELF linker hash table. */
853 struct elf_x86_64_link_hash_table
855 struct elf_link_hash_table elf
;
857 /* Short-cuts to get to dynamic linker sections. */
861 asection
*plt_eh_frame
;
867 bfd_signed_vma refcount
;
871 /* The amount of space used by the jump slots in the GOT. */
872 bfd_vma sgotplt_jump_table_size
;
874 /* Small local sym cache. */
875 struct sym_cache sym_cache
;
877 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
878 bfd_vma (*r_sym
) (bfd_vma
);
879 unsigned int pointer_r_type
;
880 const char *dynamic_interpreter
;
881 int dynamic_interpreter_size
;
883 /* _TLS_MODULE_BASE_ symbol. */
884 struct bfd_link_hash_entry
*tls_module_base
;
886 /* Used by local STT_GNU_IFUNC symbols. */
887 htab_t loc_hash_table
;
888 void * loc_hash_memory
;
890 /* The offset into splt of the PLT entry for the TLS descriptor
891 resolver. Special values are 0, if not necessary (or not found
892 to be necessary yet), and -1 if needed but not determined
895 /* The offset into sgot of the GOT entry used by the PLT entry
899 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
900 bfd_vma next_jump_slot_index
;
901 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
902 bfd_vma next_irelative_index
;
904 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
905 to read-only sections. */
906 bfd_boolean readonly_dynrelocs_against_ifunc
;
909 /* Get the x86-64 ELF linker hash table from a link_info structure. */
911 #define elf_x86_64_hash_table(p) \
912 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
913 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
915 #define elf_x86_64_compute_jump_table_size(htab) \
916 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
918 /* Create an entry in an x86-64 ELF linker hash table. */
920 static struct bfd_hash_entry
*
921 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
922 struct bfd_hash_table
*table
,
925 /* Allocate the structure if it has not already been allocated by a
929 entry
= (struct bfd_hash_entry
*)
930 bfd_hash_allocate (table
,
931 sizeof (struct elf_x86_64_link_hash_entry
));
936 /* Call the allocation method of the superclass. */
937 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
940 struct elf_x86_64_link_hash_entry
*eh
;
942 eh
= (struct elf_x86_64_link_hash_entry
*) entry
;
943 eh
->dyn_relocs
= NULL
;
944 eh
->tls_type
= GOT_UNKNOWN
;
946 eh
->has_bnd_reloc
= 0;
947 eh
->has_got_reloc
= 0;
948 eh
->has_non_got_reloc
= 0;
949 eh
->func_pointer_refcount
= 0;
950 eh
->plt_bnd
.offset
= (bfd_vma
) -1;
951 eh
->plt_got
.offset
= (bfd_vma
) -1;
952 eh
->tlsdesc_got
= (bfd_vma
) -1;
958 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
959 for local symbol so that we can handle local STT_GNU_IFUNC symbols
960 as global symbol. We reuse indx and dynstr_index for local symbol
961 hash since they aren't used by global symbols in this backend. */
964 elf_x86_64_local_htab_hash (const void *ptr
)
966 struct elf_link_hash_entry
*h
967 = (struct elf_link_hash_entry
*) ptr
;
968 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
971 /* Compare local hash entries. */
974 elf_x86_64_local_htab_eq (const void *ptr1
, const void *ptr2
)
976 struct elf_link_hash_entry
*h1
977 = (struct elf_link_hash_entry
*) ptr1
;
978 struct elf_link_hash_entry
*h2
979 = (struct elf_link_hash_entry
*) ptr2
;
981 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
984 /* Find and/or create a hash entry for local symbol. */
986 static struct elf_link_hash_entry
*
987 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table
*htab
,
988 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
991 struct elf_x86_64_link_hash_entry e
, *ret
;
992 asection
*sec
= abfd
->sections
;
993 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
994 htab
->r_sym (rel
->r_info
));
997 e
.elf
.indx
= sec
->id
;
998 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
999 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
1000 create
? INSERT
: NO_INSERT
);
1007 ret
= (struct elf_x86_64_link_hash_entry
*) *slot
;
1011 ret
= (struct elf_x86_64_link_hash_entry
*)
1012 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
1013 sizeof (struct elf_x86_64_link_hash_entry
));
1016 memset (ret
, 0, sizeof (*ret
));
1017 ret
->elf
.indx
= sec
->id
;
1018 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
1019 ret
->elf
.dynindx
= -1;
1020 ret
->func_pointer_refcount
= 0;
1021 ret
->plt_got
.offset
= (bfd_vma
) -1;
1027 /* Destroy an X86-64 ELF linker hash table. */
1030 elf_x86_64_link_hash_table_free (bfd
*obfd
)
1032 struct elf_x86_64_link_hash_table
*htab
1033 = (struct elf_x86_64_link_hash_table
*) obfd
->link
.hash
;
1035 if (htab
->loc_hash_table
)
1036 htab_delete (htab
->loc_hash_table
);
1037 if (htab
->loc_hash_memory
)
1038 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
1039 _bfd_elf_link_hash_table_free (obfd
);
1042 /* Create an X86-64 ELF linker hash table. */
1044 static struct bfd_link_hash_table
*
1045 elf_x86_64_link_hash_table_create (bfd
*abfd
)
1047 struct elf_x86_64_link_hash_table
*ret
;
1048 bfd_size_type amt
= sizeof (struct elf_x86_64_link_hash_table
);
1050 ret
= (struct elf_x86_64_link_hash_table
*) bfd_zmalloc (amt
);
1054 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1055 elf_x86_64_link_hash_newfunc
,
1056 sizeof (struct elf_x86_64_link_hash_entry
),
1063 if (ABI_64_P (abfd
))
1065 ret
->r_info
= elf64_r_info
;
1066 ret
->r_sym
= elf64_r_sym
;
1067 ret
->pointer_r_type
= R_X86_64_64
;
1068 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
1069 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
1073 ret
->r_info
= elf32_r_info
;
1074 ret
->r_sym
= elf32_r_sym
;
1075 ret
->pointer_r_type
= R_X86_64_32
;
1076 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
1077 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
1080 ret
->loc_hash_table
= htab_try_create (1024,
1081 elf_x86_64_local_htab_hash
,
1082 elf_x86_64_local_htab_eq
,
1084 ret
->loc_hash_memory
= objalloc_create ();
1085 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1087 elf_x86_64_link_hash_table_free (abfd
);
1090 ret
->elf
.root
.hash_table_free
= elf_x86_64_link_hash_table_free
;
1092 return &ret
->elf
.root
;
1095 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1096 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1100 elf_x86_64_create_dynamic_sections (bfd
*dynobj
,
1101 struct bfd_link_info
*info
)
1103 struct elf_x86_64_link_hash_table
*htab
;
1105 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1108 htab
= elf_x86_64_hash_table (info
);
1112 /* Set the contents of the .interp section to the interpreter. */
1113 if (bfd_link_executable (info
) && !info
->nointerp
)
1115 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
1118 s
->size
= htab
->dynamic_interpreter_size
;
1119 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
1123 htab
->sdynbss
= bfd_get_linker_section (dynobj
, ".dynbss");
1127 if (bfd_link_executable (info
))
1129 /* Always allow copy relocs for building executables. */
1130 asection
*s
= bfd_get_linker_section (dynobj
, ".rela.bss");
1133 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
1134 s
= bfd_make_section_anyway_with_flags (dynobj
,
1136 (bed
->dynamic_sec_flags
1139 || ! bfd_set_section_alignment (dynobj
, s
,
1140 bed
->s
->log_file_align
))
1146 if (!info
->no_ld_generated_unwind_info
1147 && htab
->plt_eh_frame
== NULL
1148 && htab
->elf
.splt
!= NULL
)
1150 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1151 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1152 | SEC_LINKER_CREATED
);
1154 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
1155 if (htab
->plt_eh_frame
== NULL
1156 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 3))
1162 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1165 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
1166 struct elf_link_hash_entry
*dir
,
1167 struct elf_link_hash_entry
*ind
)
1169 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
1171 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
1172 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
1174 if (!edir
->has_bnd_reloc
)
1175 edir
->has_bnd_reloc
= eind
->has_bnd_reloc
;
1177 if (!edir
->has_got_reloc
)
1178 edir
->has_got_reloc
= eind
->has_got_reloc
;
1180 if (!edir
->has_non_got_reloc
)
1181 edir
->has_non_got_reloc
= eind
->has_non_got_reloc
;
1183 if (eind
->dyn_relocs
!= NULL
)
1185 if (edir
->dyn_relocs
!= NULL
)
1187 struct elf_dyn_relocs
**pp
;
1188 struct elf_dyn_relocs
*p
;
1190 /* Add reloc counts against the indirect sym to the direct sym
1191 list. Merge any entries against the same section. */
1192 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1194 struct elf_dyn_relocs
*q
;
1196 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1197 if (q
->sec
== p
->sec
)
1199 q
->pc_count
+= p
->pc_count
;
1200 q
->count
+= p
->count
;
1207 *pp
= edir
->dyn_relocs
;
1210 edir
->dyn_relocs
= eind
->dyn_relocs
;
1211 eind
->dyn_relocs
= NULL
;
1214 if (ind
->root
.type
== bfd_link_hash_indirect
1215 && dir
->got
.refcount
<= 0)
1217 edir
->tls_type
= eind
->tls_type
;
1218 eind
->tls_type
= GOT_UNKNOWN
;
1221 if (ELIMINATE_COPY_RELOCS
1222 && ind
->root
.type
!= bfd_link_hash_indirect
1223 && dir
->dynamic_adjusted
)
1225 /* If called to transfer flags for a weakdef during processing
1226 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1227 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1228 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1229 dir
->ref_regular
|= ind
->ref_regular
;
1230 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1231 dir
->needs_plt
|= ind
->needs_plt
;
1232 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1236 if (eind
->func_pointer_refcount
> 0)
1238 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1239 eind
->func_pointer_refcount
= 0;
1242 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1247 elf64_x86_64_elf_object_p (bfd
*abfd
)
1249 /* Set the right machine number for an x86-64 elf64 file. */
1250 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
1255 elf32_x86_64_elf_object_p (bfd
*abfd
)
1257 /* Set the right machine number for an x86-64 elf32 file. */
1258 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
1262 /* Return TRUE if the TLS access code sequence support transition
1266 elf_x86_64_check_tls_transition (bfd
*abfd
,
1267 struct bfd_link_info
*info
,
1270 Elf_Internal_Shdr
*symtab_hdr
,
1271 struct elf_link_hash_entry
**sym_hashes
,
1272 unsigned int r_type
,
1273 const Elf_Internal_Rela
*rel
,
1274 const Elf_Internal_Rela
*relend
)
1277 unsigned long r_symndx
;
1278 bfd_boolean largepic
= FALSE
;
1279 struct elf_link_hash_entry
*h
;
1281 struct elf_x86_64_link_hash_table
*htab
;
1283 htab
= elf_x86_64_hash_table (info
);
1284 offset
= rel
->r_offset
;
1287 case R_X86_64_TLSGD
:
1288 case R_X86_64_TLSLD
:
1289 if ((rel
+ 1) >= relend
)
1292 if (r_type
== R_X86_64_TLSGD
)
1294 /* Check transition from GD access model. For 64bit, only
1295 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1296 .word 0x6666; rex64; call __tls_get_addr
1297 can transit to different access model. For 32bit, only
1298 leaq foo@tlsgd(%rip), %rdi
1299 .word 0x6666; rex64; call __tls_get_addr
1300 can transit to different access model. For largepic
1302 leaq foo@tlsgd(%rip), %rdi
1303 movabsq $__tls_get_addr@pltoff, %rax
1307 static const unsigned char call
[] = { 0x66, 0x66, 0x48, 0xe8 };
1308 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1310 if ((offset
+ 12) > sec
->size
)
1313 if (memcmp (contents
+ offset
+ 4, call
, 4) != 0)
1315 if (!ABI_64_P (abfd
)
1316 || (offset
+ 19) > sec
->size
1318 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0
1319 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1320 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1325 else if (ABI_64_P (abfd
))
1328 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1334 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1340 /* Check transition from LD access model. Only
1341 leaq foo@tlsld(%rip), %rdi;
1343 can transit to different access model. For largepic
1345 leaq foo@tlsld(%rip), %rdi
1346 movabsq $__tls_get_addr@pltoff, %rax
1350 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1352 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1355 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0)
1358 if (0xe8 != *(contents
+ offset
+ 4))
1360 if (!ABI_64_P (abfd
)
1361 || (offset
+ 19) > sec
->size
1362 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1363 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1370 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1371 if (r_symndx
< symtab_hdr
->sh_info
)
1374 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1375 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1376 may be versioned. */
1378 && h
->root
.root
.string
!= NULL
1380 ? ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLTOFF64
1381 : (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1382 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
))
1383 && (strncmp (h
->root
.root
.string
,
1384 "__tls_get_addr", 14) == 0));
1386 case R_X86_64_GOTTPOFF
:
1387 /* Check transition from IE access model:
1388 mov foo@gottpoff(%rip), %reg
1389 add foo@gottpoff(%rip), %reg
1392 /* Check REX prefix first. */
1393 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1395 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1396 if (val
!= 0x48 && val
!= 0x4c)
1398 /* X32 may have 0x44 REX prefix or no REX prefix. */
1399 if (ABI_64_P (abfd
))
1405 /* X32 may not have any REX prefix. */
1406 if (ABI_64_P (abfd
))
1408 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1412 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1413 if (val
!= 0x8b && val
!= 0x03)
1416 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1417 return (val
& 0xc7) == 5;
1419 case R_X86_64_GOTPC32_TLSDESC
:
1420 /* Check transition from GDesc access model:
1421 leaq x@tlsdesc(%rip), %rax
1423 Make sure it's a leaq adding rip to a 32-bit offset
1424 into any register, although it's probably almost always
1427 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1430 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1431 if ((val
& 0xfb) != 0x48)
1434 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1437 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1438 return (val
& 0xc7) == 0x05;
1440 case R_X86_64_TLSDESC_CALL
:
1441 /* Check transition from GDesc access model:
1442 call *x@tlsdesc(%rax)
1444 if (offset
+ 2 <= sec
->size
)
1446 /* Make sure that it's a call *x@tlsdesc(%rax). */
1447 static const unsigned char call
[] = { 0xff, 0x10 };
1448 return memcmp (contents
+ offset
, call
, 2) == 0;
1458 /* Return TRUE if the TLS access transition is OK or no transition
1459 will be performed. Update R_TYPE if there is a transition. */
1462 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1463 asection
*sec
, bfd_byte
*contents
,
1464 Elf_Internal_Shdr
*symtab_hdr
,
1465 struct elf_link_hash_entry
**sym_hashes
,
1466 unsigned int *r_type
, int tls_type
,
1467 const Elf_Internal_Rela
*rel
,
1468 const Elf_Internal_Rela
*relend
,
1469 struct elf_link_hash_entry
*h
,
1470 unsigned long r_symndx
,
1471 bfd_boolean from_relocate_section
)
1473 unsigned int from_type
= *r_type
;
1474 unsigned int to_type
= from_type
;
1475 bfd_boolean check
= TRUE
;
1477 /* Skip TLS transition for functions. */
1479 && (h
->type
== STT_FUNC
1480 || h
->type
== STT_GNU_IFUNC
))
1485 case R_X86_64_TLSGD
:
1486 case R_X86_64_GOTPC32_TLSDESC
:
1487 case R_X86_64_TLSDESC_CALL
:
1488 case R_X86_64_GOTTPOFF
:
1489 if (bfd_link_executable (info
))
1492 to_type
= R_X86_64_TPOFF32
;
1494 to_type
= R_X86_64_GOTTPOFF
;
1497 /* When we are called from elf_x86_64_relocate_section, there may
1498 be additional transitions based on TLS_TYPE. */
1499 if (from_relocate_section
)
1501 unsigned int new_to_type
= to_type
;
1503 if (bfd_link_executable (info
)
1506 && tls_type
== GOT_TLS_IE
)
1507 new_to_type
= R_X86_64_TPOFF32
;
1509 if (to_type
== R_X86_64_TLSGD
1510 || to_type
== R_X86_64_GOTPC32_TLSDESC
1511 || to_type
== R_X86_64_TLSDESC_CALL
)
1513 if (tls_type
== GOT_TLS_IE
)
1514 new_to_type
= R_X86_64_GOTTPOFF
;
1517 /* We checked the transition before when we were called from
1518 elf_x86_64_check_relocs. We only want to check the new
1519 transition which hasn't been checked before. */
1520 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1521 to_type
= new_to_type
;
1526 case R_X86_64_TLSLD
:
1527 if (bfd_link_executable (info
))
1528 to_type
= R_X86_64_TPOFF32
;
1535 /* Return TRUE if there is no transition. */
1536 if (from_type
== to_type
)
1539 /* Check if the transition can be performed. */
1541 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1542 symtab_hdr
, sym_hashes
,
1543 from_type
, rel
, relend
))
1545 reloc_howto_type
*from
, *to
;
1548 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1549 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1552 name
= h
->root
.root
.string
;
1555 struct elf_x86_64_link_hash_table
*htab
;
1557 htab
= elf_x86_64_hash_table (info
);
1562 Elf_Internal_Sym
*isym
;
1564 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1566 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1570 (*_bfd_error_handler
)
1571 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1572 "in section `%A' failed"),
1573 abfd
, sec
, from
->name
, to
->name
, name
,
1574 (unsigned long) rel
->r_offset
);
1575 bfd_set_error (bfd_error_bad_value
);
1583 /* Rename some of the generic section flags to better document how they
1585 #define need_convert_load sec_flg0
1586 #define check_relocs_failed sec_flg1
1589 elf_x86_64_need_pic (bfd
*input_bfd
, asection
*sec
,
1590 struct elf_link_hash_entry
*h
,
1591 Elf_Internal_Shdr
*symtab_hdr
,
1592 Elf_Internal_Sym
*isym
,
1593 reloc_howto_type
*howto
)
1596 const char *und
= "";
1597 const char *pic
= "";
1602 name
= h
->root
.root
.string
;
1603 switch (ELF_ST_VISIBILITY (h
->other
))
1606 v
= _("hidden symbol ");
1609 v
= _("internal symbol ");
1612 v
= _("protected symbol ");
1616 pic
= _("; recompile with -fPIC");
1620 if (!h
->def_regular
&& !h
->def_dynamic
)
1621 und
= _("undefined ");
1625 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, isym
, NULL
);
1626 pic
= _("; recompile with -fPIC");
1629 (*_bfd_error_handler
) (_("%B: relocation %s against %s%s`%s' can "
1630 "not be used when making a shared object%s"),
1631 input_bfd
, howto
->name
, und
, v
, name
, pic
);
1632 bfd_set_error (bfd_error_bad_value
);
1633 sec
->check_relocs_failed
= 1;
1637 /* Look through the relocs for a section during the first phase, and
1638 calculate needed space in the global offset table, procedure
1639 linkage table, and dynamic reloc sections. */
1642 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1644 const Elf_Internal_Rela
*relocs
)
1646 struct elf_x86_64_link_hash_table
*htab
;
1647 Elf_Internal_Shdr
*symtab_hdr
;
1648 struct elf_link_hash_entry
**sym_hashes
;
1649 const Elf_Internal_Rela
*rel
;
1650 const Elf_Internal_Rela
*rel_end
;
1653 bfd_boolean use_plt_got
;
1655 if (bfd_link_relocatable (info
))
1658 BFD_ASSERT (is_x86_64_elf (abfd
));
1660 htab
= elf_x86_64_hash_table (info
);
1663 sec
->check_relocs_failed
= 1;
1667 /* Get the section contents. */
1668 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1669 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1670 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1672 sec
->check_relocs_failed
= 1;
1676 use_plt_got
= get_elf_x86_64_backend_data (abfd
) == &elf_x86_64_arch_bed
;
1678 symtab_hdr
= &elf_symtab_hdr (abfd
);
1679 sym_hashes
= elf_sym_hashes (abfd
);
1683 rel_end
= relocs
+ sec
->reloc_count
;
1684 for (rel
= relocs
; rel
< rel_end
; rel
++)
1686 unsigned int r_type
;
1687 unsigned long r_symndx
;
1688 struct elf_link_hash_entry
*h
;
1689 struct elf_x86_64_link_hash_entry
*eh
;
1690 Elf_Internal_Sym
*isym
;
1692 bfd_boolean size_reloc
;
1694 r_symndx
= htab
->r_sym (rel
->r_info
);
1695 r_type
= ELF32_R_TYPE (rel
->r_info
);
1697 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1699 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1704 if (r_symndx
< symtab_hdr
->sh_info
)
1706 /* A local symbol. */
1707 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1712 /* Check relocation against local STT_GNU_IFUNC symbol. */
1713 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1715 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
1720 /* Fake a STT_GNU_IFUNC symbol. */
1721 h
->type
= STT_GNU_IFUNC
;
1724 h
->forced_local
= 1;
1725 h
->root
.type
= bfd_link_hash_defined
;
1733 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1734 while (h
->root
.type
== bfd_link_hash_indirect
1735 || h
->root
.type
== bfd_link_hash_warning
)
1736 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1739 /* Check invalid x32 relocations. */
1740 if (!ABI_64_P (abfd
))
1746 case R_X86_64_DTPOFF64
:
1747 case R_X86_64_TPOFF64
:
1749 case R_X86_64_GOTOFF64
:
1750 case R_X86_64_GOT64
:
1751 case R_X86_64_GOTPCREL64
:
1752 case R_X86_64_GOTPC64
:
1753 case R_X86_64_GOTPLT64
:
1754 case R_X86_64_PLTOFF64
:
1757 name
= h
->root
.root
.string
;
1759 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1761 (*_bfd_error_handler
)
1762 (_("%B: relocation %s against symbol `%s' isn't "
1763 "supported in x32 mode"), abfd
,
1764 x86_64_elf_howto_table
[r_type
].name
, name
);
1765 bfd_set_error (bfd_error_bad_value
);
1778 case R_X86_64_PC32_BND
:
1779 case R_X86_64_PLT32_BND
:
1781 case R_X86_64_PLT32
:
1784 /* MPX PLT is supported only if elf_x86_64_arch_bed
1785 is used in 64-bit mode. */
1788 && (get_elf_x86_64_backend_data (abfd
)
1789 == &elf_x86_64_arch_bed
))
1791 elf_x86_64_hash_entry (h
)->has_bnd_reloc
= 1;
1793 /* Create the second PLT for Intel MPX support. */
1794 if (htab
->plt_bnd
== NULL
)
1796 unsigned int plt_bnd_align
;
1797 const struct elf_backend_data
*bed
;
1799 bed
= get_elf_backend_data (info
->output_bfd
);
1800 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry
) == 8
1801 && (sizeof (elf_x86_64_bnd_plt2_entry
)
1802 == sizeof (elf_x86_64_legacy_plt2_entry
)));
1805 if (htab
->elf
.dynobj
== NULL
)
1806 htab
->elf
.dynobj
= abfd
;
1808 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
1810 (bed
->dynamic_sec_flags
1815 if (htab
->plt_bnd
== NULL
1816 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
1825 case R_X86_64_GOTPCREL
:
1826 case R_X86_64_GOTPCRELX
:
1827 case R_X86_64_REX_GOTPCRELX
:
1828 case R_X86_64_GOTPCREL64
:
1829 if (htab
->elf
.dynobj
== NULL
)
1830 htab
->elf
.dynobj
= abfd
;
1831 /* Create the ifunc sections for static executables. */
1832 if (h
->type
== STT_GNU_IFUNC
1833 && !_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
,
1839 /* It is referenced by a non-shared object. */
1841 h
->root
.non_ir_ref
= 1;
1843 if (h
->type
== STT_GNU_IFUNC
)
1844 elf_tdata (info
->output_bfd
)->has_gnu_symbols
1845 |= elf_gnu_symbol_ifunc
;
1848 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, contents
,
1849 symtab_hdr
, sym_hashes
,
1850 &r_type
, GOT_UNKNOWN
,
1851 rel
, rel_end
, h
, r_symndx
, FALSE
))
1854 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
1857 case R_X86_64_TLSLD
:
1858 htab
->tls_ld_got
.refcount
+= 1;
1861 case R_X86_64_TPOFF32
:
1862 if (!bfd_link_executable (info
) && ABI_64_P (abfd
))
1863 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
1864 &x86_64_elf_howto_table
[r_type
]);
1866 eh
->has_got_reloc
= 1;
1869 case R_X86_64_GOTTPOFF
:
1870 if (!bfd_link_executable (info
))
1871 info
->flags
|= DF_STATIC_TLS
;
1874 case R_X86_64_GOT32
:
1875 case R_X86_64_GOTPCREL
:
1876 case R_X86_64_GOTPCRELX
:
1877 case R_X86_64_REX_GOTPCRELX
:
1878 case R_X86_64_TLSGD
:
1879 case R_X86_64_GOT64
:
1880 case R_X86_64_GOTPCREL64
:
1881 case R_X86_64_GOTPLT64
:
1882 case R_X86_64_GOTPC32_TLSDESC
:
1883 case R_X86_64_TLSDESC_CALL
:
1884 /* This symbol requires a global offset table entry. */
1886 int tls_type
, old_tls_type
;
1890 default: tls_type
= GOT_NORMAL
; break;
1891 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
1892 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
1893 case R_X86_64_GOTPC32_TLSDESC
:
1894 case R_X86_64_TLSDESC_CALL
:
1895 tls_type
= GOT_TLS_GDESC
; break;
1900 h
->got
.refcount
+= 1;
1901 old_tls_type
= eh
->tls_type
;
1905 bfd_signed_vma
*local_got_refcounts
;
1907 /* This is a global offset table entry for a local symbol. */
1908 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1909 if (local_got_refcounts
== NULL
)
1913 size
= symtab_hdr
->sh_info
;
1914 size
*= sizeof (bfd_signed_vma
)
1915 + sizeof (bfd_vma
) + sizeof (char);
1916 local_got_refcounts
= ((bfd_signed_vma
*)
1917 bfd_zalloc (abfd
, size
));
1918 if (local_got_refcounts
== NULL
)
1920 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1921 elf_x86_64_local_tlsdesc_gotent (abfd
)
1922 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1923 elf_x86_64_local_got_tls_type (abfd
)
1924 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1926 local_got_refcounts
[r_symndx
] += 1;
1928 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
1931 /* If a TLS symbol is accessed using IE at least once,
1932 there is no point to use dynamic model for it. */
1933 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1934 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1935 || tls_type
!= GOT_TLS_IE
))
1937 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
1938 tls_type
= old_tls_type
;
1939 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1940 && GOT_TLS_GD_ANY_P (tls_type
))
1941 tls_type
|= old_tls_type
;
1945 name
= h
->root
.root
.string
;
1947 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
1949 (*_bfd_error_handler
)
1950 (_("%B: '%s' accessed both as normal and thread local symbol"),
1952 bfd_set_error (bfd_error_bad_value
);
1957 if (old_tls_type
!= tls_type
)
1960 eh
->tls_type
= tls_type
;
1962 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1967 case R_X86_64_GOTOFF64
:
1968 case R_X86_64_GOTPC32
:
1969 case R_X86_64_GOTPC64
:
1972 eh
->has_got_reloc
= 1;
1973 if (htab
->elf
.sgot
== NULL
)
1975 if (htab
->elf
.dynobj
== NULL
)
1976 htab
->elf
.dynobj
= abfd
;
1977 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
1983 case R_X86_64_PLT32
:
1984 case R_X86_64_PLT32_BND
:
1985 /* This symbol requires a procedure linkage table entry. We
1986 actually build the entry in adjust_dynamic_symbol,
1987 because this might be a case of linking PIC code which is
1988 never referenced by a dynamic object, in which case we
1989 don't need to generate a procedure linkage table entry
1992 /* If this is a local symbol, we resolve it directly without
1993 creating a procedure linkage table entry. */
1997 eh
->has_got_reloc
= 1;
1999 h
->plt
.refcount
+= 1;
2002 case R_X86_64_PLTOFF64
:
2003 /* This tries to form the 'address' of a function relative
2004 to GOT. For global symbols we need a PLT entry. */
2008 h
->plt
.refcount
+= 1;
2012 case R_X86_64_SIZE32
:
2013 case R_X86_64_SIZE64
:
2018 if (!ABI_64_P (abfd
))
2023 /* Check relocation overflow as these relocs may lead to
2024 run-time relocation overflow. Don't error out for
2025 sections we don't care about, such as debug sections or
2026 when relocation overflow check is disabled. */
2027 if (!info
->no_reloc_overflow_check
2028 && (bfd_link_pic (info
)
2029 || (bfd_link_executable (info
)
2033 && (sec
->flags
& SEC_READONLY
) == 0))
2034 && (sec
->flags
& SEC_ALLOC
) != 0)
2035 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
2036 &x86_64_elf_howto_table
[r_type
]);
2042 case R_X86_64_PC32_BND
:
2046 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2047 eh
->has_non_got_reloc
= 1;
2048 /* STT_GNU_IFUNC symbol must go through PLT even if it is
2049 locally defined and undefined symbol may turn out to be
2050 a STT_GNU_IFUNC symbol later. */
2052 && (bfd_link_executable (info
)
2053 || ((h
->type
== STT_GNU_IFUNC
2054 || h
->root
.type
== bfd_link_hash_undefweak
2055 || h
->root
.type
== bfd_link_hash_undefined
)
2056 && SYMBOLIC_BIND (info
, h
))))
2058 /* If this reloc is in a read-only section, we might
2059 need a copy reloc. We can't check reliably at this
2060 stage whether the section is read-only, as input
2061 sections have not yet been mapped to output sections.
2062 Tentatively set the flag for now, and correct in
2063 adjust_dynamic_symbol. */
2066 /* We may need a .plt entry if the function this reloc
2067 refers to is in a shared lib. */
2068 h
->plt
.refcount
+= 1;
2069 if (r_type
== R_X86_64_PC32
)
2071 /* Since something like ".long foo - ." may be used
2072 as pointer, make sure that PLT is used if foo is
2073 a function defined in a shared library. */
2074 if ((sec
->flags
& SEC_CODE
) == 0)
2075 h
->pointer_equality_needed
= 1;
2077 else if (r_type
!= R_X86_64_PC32_BND
2078 && r_type
!= R_X86_64_PC64
)
2080 h
->pointer_equality_needed
= 1;
2081 /* At run-time, R_X86_64_64 can be resolved for both
2082 x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2083 can only be resolved for x32. */
2084 if ((sec
->flags
& SEC_READONLY
) == 0
2085 && (r_type
== R_X86_64_64
2086 || (!ABI_64_P (abfd
)
2087 && (r_type
== R_X86_64_32
2088 || r_type
== R_X86_64_32S
))))
2089 eh
->func_pointer_refcount
+= 1;
2095 /* If we are creating a shared library, and this is a reloc
2096 against a global symbol, or a non PC relative reloc
2097 against a local symbol, then we need to copy the reloc
2098 into the shared library. However, if we are linking with
2099 -Bsymbolic, we do not need to copy a reloc against a
2100 global symbol which is defined in an object we are
2101 including in the link (i.e., DEF_REGULAR is set). At
2102 this point we have not seen all the input files, so it is
2103 possible that DEF_REGULAR is not set now but will be set
2104 later (it is never cleared). In case of a weak definition,
2105 DEF_REGULAR may be cleared later by a strong definition in
2106 a shared library. We account for that possibility below by
2107 storing information in the relocs_copied field of the hash
2108 table entry. A similar situation occurs when creating
2109 shared libraries and symbol visibility changes render the
2112 If on the other hand, we are creating an executable, we
2113 may need to keep relocations for symbols satisfied by a
2114 dynamic library if we manage to avoid copy relocs for the
2116 if ((bfd_link_pic (info
)
2117 && (sec
->flags
& SEC_ALLOC
) != 0
2118 && (! IS_X86_64_PCREL_TYPE (r_type
)
2120 && (! (bfd_link_pie (info
)
2121 || SYMBOLIC_BIND (info
, h
))
2122 || h
->root
.type
== bfd_link_hash_defweak
2123 || !h
->def_regular
))))
2124 || (ELIMINATE_COPY_RELOCS
2125 && !bfd_link_pic (info
)
2126 && (sec
->flags
& SEC_ALLOC
) != 0
2128 && (h
->root
.type
== bfd_link_hash_defweak
2129 || !h
->def_regular
)))
2131 struct elf_dyn_relocs
*p
;
2132 struct elf_dyn_relocs
**head
;
2134 /* We must copy these reloc types into the output file.
2135 Create a reloc section in dynobj and make room for
2139 if (htab
->elf
.dynobj
== NULL
)
2140 htab
->elf
.dynobj
= abfd
;
2142 sreloc
= _bfd_elf_make_dynamic_reloc_section
2143 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
2144 abfd
, /*rela?*/ TRUE
);
2150 /* If this is a global symbol, we count the number of
2151 relocations we need for this symbol. */
2153 head
= &eh
->dyn_relocs
;
2156 /* Track dynamic relocs needed for local syms too.
2157 We really need local syms available to do this
2162 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2167 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2171 /* Beware of type punned pointers vs strict aliasing
2173 vpp
= &(elf_section_data (s
)->local_dynrel
);
2174 head
= (struct elf_dyn_relocs
**)vpp
;
2178 if (p
== NULL
|| p
->sec
!= sec
)
2180 bfd_size_type amt
= sizeof *p
;
2182 p
= ((struct elf_dyn_relocs
*)
2183 bfd_alloc (htab
->elf
.dynobj
, amt
));
2194 /* Count size relocation as PC-relative relocation. */
2195 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
2200 /* This relocation describes the C++ object vtable hierarchy.
2201 Reconstruct it for later use during GC. */
2202 case R_X86_64_GNU_VTINHERIT
:
2203 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2207 /* This relocation describes which C++ vtable entries are actually
2208 used. Record for later use during GC. */
2209 case R_X86_64_GNU_VTENTRY
:
2210 BFD_ASSERT (h
!= NULL
);
2212 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2222 && h
->plt
.refcount
> 0
2223 && (((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2224 || h
->got
.refcount
> 0)
2225 && htab
->plt_got
== NULL
)
2227 /* Create the GOT procedure linkage table. */
2228 unsigned int plt_got_align
;
2229 const struct elf_backend_data
*bed
;
2231 bed
= get_elf_backend_data (info
->output_bfd
);
2232 BFD_ASSERT (sizeof (elf_x86_64_legacy_plt2_entry
) == 8
2233 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2234 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2237 if (htab
->elf
.dynobj
== NULL
)
2238 htab
->elf
.dynobj
= abfd
;
2240 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2242 (bed
->dynamic_sec_flags
2247 if (htab
->plt_got
== NULL
2248 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2254 if ((r_type
== R_X86_64_GOTPCREL
2255 || r_type
== R_X86_64_GOTPCRELX
2256 || r_type
== R_X86_64_REX_GOTPCRELX
)
2257 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2258 sec
->need_convert_load
= 1;
2261 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2263 if (!info
->keep_memory
)
2267 /* Cache the section contents for elf_link_input_bfd. */
2268 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2275 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2277 sec
->check_relocs_failed
= 1;
2281 /* Return the section that should be marked against GC for a given
2285 elf_x86_64_gc_mark_hook (asection
*sec
,
2286 struct bfd_link_info
*info
,
2287 Elf_Internal_Rela
*rel
,
2288 struct elf_link_hash_entry
*h
,
2289 Elf_Internal_Sym
*sym
)
2292 switch (ELF32_R_TYPE (rel
->r_info
))
2294 case R_X86_64_GNU_VTINHERIT
:
2295 case R_X86_64_GNU_VTENTRY
:
2299 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2302 /* Remove undefined weak symbol from the dynamic symbol table if it
2303 is resolved to 0. */
2306 elf_x86_64_fixup_symbol (struct bfd_link_info
*info
,
2307 struct elf_link_hash_entry
*h
)
2309 if (h
->dynindx
!= -1
2310 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2311 elf_x86_64_hash_entry (h
)->has_got_reloc
,
2312 elf_x86_64_hash_entry (h
)))
2315 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2321 /* Adjust a symbol defined by a dynamic object and referenced by a
2322 regular object. The current definition is in some section of the
2323 dynamic object, but we're not including those sections. We have to
2324 change the definition to something the rest of the link can
2328 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2329 struct elf_link_hash_entry
*h
)
2331 struct elf_x86_64_link_hash_table
*htab
;
2333 struct elf_x86_64_link_hash_entry
*eh
;
2334 struct elf_dyn_relocs
*p
;
2336 /* STT_GNU_IFUNC symbol must go through PLT. */
2337 if (h
->type
== STT_GNU_IFUNC
)
2339 /* All local STT_GNU_IFUNC references must be treate as local
2340 calls via local PLT. */
2342 && SYMBOL_CALLS_LOCAL (info
, h
))
2344 bfd_size_type pc_count
= 0, count
= 0;
2345 struct elf_dyn_relocs
**pp
;
2347 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2348 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2350 pc_count
+= p
->pc_count
;
2351 p
->count
-= p
->pc_count
;
2360 if (pc_count
|| count
)
2364 if (h
->plt
.refcount
<= 0)
2365 h
->plt
.refcount
= 1;
2367 h
->plt
.refcount
+= 1;
2371 if (h
->plt
.refcount
<= 0)
2373 h
->plt
.offset
= (bfd_vma
) -1;
2379 /* If this is a function, put it in the procedure linkage table. We
2380 will fill in the contents of the procedure linkage table later,
2381 when we know the address of the .got section. */
2382 if (h
->type
== STT_FUNC
2385 if (h
->plt
.refcount
<= 0
2386 || SYMBOL_CALLS_LOCAL (info
, h
)
2387 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2388 && h
->root
.type
== bfd_link_hash_undefweak
))
2390 /* This case can occur if we saw a PLT32 reloc in an input
2391 file, but the symbol was never referred to by a dynamic
2392 object, or if all references were garbage collected. In
2393 such a case, we don't actually need to build a procedure
2394 linkage table, and we can just do a PC32 reloc instead. */
2395 h
->plt
.offset
= (bfd_vma
) -1;
2402 /* It's possible that we incorrectly decided a .plt reloc was
2403 needed for an R_X86_64_PC32 reloc to a non-function sym in
2404 check_relocs. We can't decide accurately between function and
2405 non-function syms in check-relocs; Objects loaded later in
2406 the link may change h->type. So fix it now. */
2407 h
->plt
.offset
= (bfd_vma
) -1;
2409 /* If this is a weak symbol, and there is a real definition, the
2410 processor independent code will have arranged for us to see the
2411 real definition first, and we can just use the same value. */
2412 if (h
->u
.weakdef
!= NULL
)
2414 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2415 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2416 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2417 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2418 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2420 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2421 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2422 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
2427 /* This is a reference to a symbol defined by a dynamic object which
2428 is not a function. */
2430 /* If we are creating a shared library, we must presume that the
2431 only references to the symbol are via the global offset table.
2432 For such cases we need not do anything here; the relocations will
2433 be handled correctly by relocate_section. */
2434 if (!bfd_link_executable (info
))
2437 /* If there are no references to this symbol that do not use the
2438 GOT, we don't need to generate a copy reloc. */
2439 if (!h
->non_got_ref
)
2442 /* If -z nocopyreloc was given, we won't generate them either. */
2443 if (info
->nocopyreloc
)
2449 if (ELIMINATE_COPY_RELOCS
)
2451 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2452 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2454 s
= p
->sec
->output_section
;
2455 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2459 /* If we didn't find any dynamic relocs in read-only sections, then
2460 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2468 /* We must allocate the symbol in our .dynbss section, which will
2469 become part of the .bss section of the executable. There will be
2470 an entry for this symbol in the .dynsym section. The dynamic
2471 object will contain position independent code, so all references
2472 from the dynamic object to this symbol will go through the global
2473 offset table. The dynamic linker will use the .dynsym entry to
2474 determine the address it must put in the global offset table, so
2475 both the dynamic object and the regular object will refer to the
2476 same memory location for the variable. */
2478 htab
= elf_x86_64_hash_table (info
);
2482 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2483 to copy the initial value out of the dynamic object and into the
2484 runtime process image. */
2485 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2487 const struct elf_backend_data
*bed
;
2488 bed
= get_elf_backend_data (info
->output_bfd
);
2489 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
2495 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2498 /* Allocate space in .plt, .got and associated reloc sections for
2502 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2504 struct bfd_link_info
*info
;
2505 struct elf_x86_64_link_hash_table
*htab
;
2506 struct elf_x86_64_link_hash_entry
*eh
;
2507 struct elf_dyn_relocs
*p
;
2508 const struct elf_backend_data
*bed
;
2509 unsigned int plt_entry_size
;
2510 bfd_boolean resolved_to_zero
;
2512 if (h
->root
.type
== bfd_link_hash_indirect
)
2515 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2517 info
= (struct bfd_link_info
*) inf
;
2518 htab
= elf_x86_64_hash_table (info
);
2521 bed
= get_elf_backend_data (info
->output_bfd
);
2522 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2524 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2528 /* We can't use the GOT PLT if pointer equality is needed since
2529 finish_dynamic_symbol won't clear symbol value and the dynamic
2530 linker won't update the GOT slot. We will get into an infinite
2531 loop at run-time. */
2532 if (htab
->plt_got
!= NULL
2533 && h
->type
!= STT_GNU_IFUNC
2534 && !h
->pointer_equality_needed
2535 && h
->plt
.refcount
> 0
2536 && h
->got
.refcount
> 0)
2538 /* Don't use the regular PLT if there are both GOT and GOTPLT
2540 h
->plt
.offset
= (bfd_vma
) -1;
2542 /* Use the GOT PLT. */
2543 eh
->plt_got
.refcount
= 1;
2546 /* Clear the reference count of function pointer relocations if
2547 symbol isn't a normal function. */
2548 if (h
->type
!= STT_FUNC
)
2549 eh
->func_pointer_refcount
= 0;
2551 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2552 here if it is defined and referenced in a non-shared object. */
2553 if (h
->type
== STT_GNU_IFUNC
2556 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
2558 &htab
->readonly_dynrelocs_against_ifunc
,
2563 asection
*s
= htab
->plt_bnd
;
2564 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
2566 /* Use the .plt.bnd section if it is created. */
2567 eh
->plt_bnd
.offset
= s
->size
;
2569 /* Make room for this entry in the .plt.bnd section. */
2570 s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2578 /* Don't create the PLT entry if there are only function pointer
2579 relocations which can be resolved at run-time. */
2580 else if (htab
->elf
.dynamic_sections_created
2581 && (h
->plt
.refcount
> eh
->func_pointer_refcount
2582 || eh
->plt_got
.refcount
> 0))
2584 bfd_boolean use_plt_got
;
2586 /* Clear the reference count of function pointer relocations
2588 eh
->func_pointer_refcount
= 0;
2590 if ((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2592 /* Don't use the regular PLT for DF_BIND_NOW. */
2593 h
->plt
.offset
= (bfd_vma
) -1;
2595 /* Use the GOT PLT. */
2596 h
->got
.refcount
= 1;
2597 eh
->plt_got
.refcount
= 1;
2600 use_plt_got
= eh
->plt_got
.refcount
> 0;
2602 /* Make sure this symbol is output as a dynamic symbol.
2603 Undefined weak syms won't yet be marked as dynamic. */
2604 if (h
->dynindx
== -1
2606 && !resolved_to_zero
)
2608 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2612 if (bfd_link_pic (info
)
2613 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2615 asection
*s
= htab
->elf
.splt
;
2616 asection
*bnd_s
= htab
->plt_bnd
;
2617 asection
*got_s
= htab
->plt_got
;
2619 /* If this is the first .plt entry, make room for the special
2620 first entry. The .plt section is used by prelink to undo
2621 prelinking for dynamic relocations. */
2623 s
->size
= plt_entry_size
;
2626 eh
->plt_got
.offset
= got_s
->size
;
2629 h
->plt
.offset
= s
->size
;
2631 eh
->plt_bnd
.offset
= bnd_s
->size
;
2634 /* If this symbol is not defined in a regular file, and we are
2635 not generating a shared library, then set the symbol to this
2636 location in the .plt. This is required to make function
2637 pointers compare as equal between the normal executable and
2638 the shared library. */
2639 if (! bfd_link_pic (info
)
2644 /* We need to make a call to the entry of the GOT PLT
2645 instead of regular PLT entry. */
2646 h
->root
.u
.def
.section
= got_s
;
2647 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
2653 /* We need to make a call to the entry of the second
2654 PLT instead of regular PLT entry. */
2655 h
->root
.u
.def
.section
= bnd_s
;
2656 h
->root
.u
.def
.value
= eh
->plt_bnd
.offset
;
2660 h
->root
.u
.def
.section
= s
;
2661 h
->root
.u
.def
.value
= h
->plt
.offset
;
2666 /* Make room for this entry. */
2668 got_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2671 s
->size
+= plt_entry_size
;
2673 bnd_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2675 /* We also need to make an entry in the .got.plt section,
2676 which will be placed in the .got section by the linker
2678 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
2680 /* There should be no PLT relocation against resolved
2681 undefined weak symbol in executable. */
2682 if (!resolved_to_zero
)
2684 /* We also need to make an entry in the .rela.plt
2686 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2687 htab
->elf
.srelplt
->reloc_count
++;
2693 eh
->plt_got
.offset
= (bfd_vma
) -1;
2694 h
->plt
.offset
= (bfd_vma
) -1;
2700 eh
->plt_got
.offset
= (bfd_vma
) -1;
2701 h
->plt
.offset
= (bfd_vma
) -1;
2705 eh
->tlsdesc_got
= (bfd_vma
) -1;
2707 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2708 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2709 if (h
->got
.refcount
> 0
2710 && bfd_link_executable (info
)
2712 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
2714 h
->got
.offset
= (bfd_vma
) -1;
2716 else if (h
->got
.refcount
> 0)
2720 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
2722 /* Make sure this symbol is output as a dynamic symbol.
2723 Undefined weak syms won't yet be marked as dynamic. */
2724 if (h
->dynindx
== -1
2726 && !resolved_to_zero
)
2728 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2732 if (GOT_TLS_GDESC_P (tls_type
))
2734 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2735 - elf_x86_64_compute_jump_table_size (htab
);
2736 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2737 h
->got
.offset
= (bfd_vma
) -2;
2739 if (! GOT_TLS_GDESC_P (tls_type
)
2740 || GOT_TLS_GD_P (tls_type
))
2743 h
->got
.offset
= s
->size
;
2744 s
->size
+= GOT_ENTRY_SIZE
;
2745 if (GOT_TLS_GD_P (tls_type
))
2746 s
->size
+= GOT_ENTRY_SIZE
;
2748 dyn
= htab
->elf
.dynamic_sections_created
;
2749 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2750 and two if global. R_X86_64_GOTTPOFF needs one dynamic
2751 relocation. No dynamic relocation against resolved undefined
2752 weak symbol in executable. */
2753 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2754 || tls_type
== GOT_TLS_IE
)
2755 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2756 else if (GOT_TLS_GD_P (tls_type
))
2757 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
2758 else if (! GOT_TLS_GDESC_P (tls_type
)
2759 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2760 && !resolved_to_zero
)
2761 || h
->root
.type
!= bfd_link_hash_undefweak
)
2762 && (bfd_link_pic (info
)
2763 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2764 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2765 if (GOT_TLS_GDESC_P (tls_type
))
2767 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2768 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2772 h
->got
.offset
= (bfd_vma
) -1;
2774 if (eh
->dyn_relocs
== NULL
)
2777 /* In the shared -Bsymbolic case, discard space allocated for
2778 dynamic pc-relative relocs against symbols which turn out to be
2779 defined in regular objects. For the normal shared case, discard
2780 space for pc-relative relocs that have become local due to symbol
2781 visibility changes. */
2783 if (bfd_link_pic (info
))
2785 /* Relocs that use pc_count are those that appear on a call
2786 insn, or certain REL relocs that can generated via assembly.
2787 We want calls to protected symbols to resolve directly to the
2788 function rather than going via the plt. If people want
2789 function pointer comparisons to work as expected then they
2790 should avoid writing weird assembly. */
2791 if (SYMBOL_CALLS_LOCAL (info
, h
))
2793 struct elf_dyn_relocs
**pp
;
2795 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2797 p
->count
-= p
->pc_count
;
2806 /* Also discard relocs on undefined weak syms with non-default
2807 visibility or in PIE. */
2808 if (eh
->dyn_relocs
!= NULL
)
2810 if (h
->root
.type
== bfd_link_hash_undefweak
)
2812 /* Undefined weak symbol is never bound locally in shared
2814 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2815 || resolved_to_zero
)
2816 eh
->dyn_relocs
= NULL
;
2817 else if (h
->dynindx
== -1
2818 && ! h
->forced_local
2819 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2822 /* For PIE, discard space for pc-relative relocs against
2823 symbols which turn out to need copy relocs. */
2824 else if (bfd_link_executable (info
)
2825 && (h
->needs_copy
|| eh
->needs_copy
)
2829 struct elf_dyn_relocs
**pp
;
2831 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2833 if (p
->pc_count
!= 0)
2841 else if (ELIMINATE_COPY_RELOCS
)
2843 /* For the non-shared case, discard space for relocs against
2844 symbols which turn out to need copy relocs or are not
2845 dynamic. Keep dynamic relocations for run-time function
2846 pointer initialization. */
2848 if ((!h
->non_got_ref
2849 || eh
->func_pointer_refcount
> 0
2850 || (h
->root
.type
== bfd_link_hash_undefweak
2851 && !resolved_to_zero
))
2854 || (htab
->elf
.dynamic_sections_created
2855 && (h
->root
.type
== bfd_link_hash_undefweak
2856 || h
->root
.type
== bfd_link_hash_undefined
))))
2858 /* Make sure this symbol is output as a dynamic symbol.
2859 Undefined weak syms won't yet be marked as dynamic. */
2860 if (h
->dynindx
== -1
2861 && ! h
->forced_local
2862 && ! resolved_to_zero
2863 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2866 /* If that succeeded, we know we'll be keeping all the
2868 if (h
->dynindx
!= -1)
2872 eh
->dyn_relocs
= NULL
;
2873 eh
->func_pointer_refcount
= 0;
2878 /* Finally, allocate space. */
2879 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2883 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2885 BFD_ASSERT (sreloc
!= NULL
);
2887 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2893 /* Allocate space in .plt, .got and associated reloc sections for
2894 local dynamic relocs. */
2897 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
2899 struct elf_link_hash_entry
*h
2900 = (struct elf_link_hash_entry
*) *slot
;
2902 if (h
->type
!= STT_GNU_IFUNC
2906 || h
->root
.type
!= bfd_link_hash_defined
)
2909 return elf_x86_64_allocate_dynrelocs (h
, inf
);
2912 /* Find any dynamic relocs that apply to read-only sections. */
2915 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
2918 struct elf_x86_64_link_hash_entry
*eh
;
2919 struct elf_dyn_relocs
*p
;
2921 /* Skip local IFUNC symbols. */
2922 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
2925 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2926 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2928 asection
*s
= p
->sec
->output_section
;
2930 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2932 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2934 info
->flags
|= DF_TEXTREL
;
2936 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
2937 || info
->error_textrel
)
2938 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
2939 p
->sec
->owner
, h
->root
.root
.string
,
2942 /* Not an error, just cut short the traversal. */
2949 /* With the local symbol, foo, we convert
2950 mov foo@GOTPCREL(%rip), %reg
2954 call/jmp *foo@GOTPCREL(%rip)
2956 nop call foo/jmp foo nop
2957 When PIC is false, convert
2958 test %reg, foo@GOTPCREL(%rip)
2962 binop foo@GOTPCREL(%rip), %reg
2965 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
2969 elf_x86_64_convert_load (bfd
*abfd
, asection
*sec
,
2970 struct bfd_link_info
*link_info
)
2972 Elf_Internal_Shdr
*symtab_hdr
;
2973 Elf_Internal_Rela
*internal_relocs
;
2974 Elf_Internal_Rela
*irel
, *irelend
;
2976 struct elf_x86_64_link_hash_table
*htab
;
2977 bfd_boolean changed_contents
;
2978 bfd_boolean changed_relocs
;
2979 bfd_signed_vma
*local_got_refcounts
;
2980 bfd_vma maxpagesize
;
2982 bfd_boolean require_reloc_pc32
;
2984 /* Don't even try to convert non-ELF outputs. */
2985 if (!is_elf_hash_table (link_info
->hash
))
2988 /* Nothing to do if there is no need or no output. */
2989 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
2990 || sec
->need_convert_load
== 0
2991 || bfd_is_abs_section (sec
->output_section
))
2994 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2996 /* Load the relocations for this section. */
2997 internal_relocs
= (_bfd_elf_link_read_relocs
2998 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
2999 link_info
->keep_memory
));
3000 if (internal_relocs
== NULL
)
3003 htab
= elf_x86_64_hash_table (link_info
);
3004 changed_contents
= FALSE
;
3005 changed_relocs
= FALSE
;
3006 local_got_refcounts
= elf_local_got_refcounts (abfd
);
3007 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
3009 /* Get the section contents. */
3010 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
3011 contents
= elf_section_data (sec
)->this_hdr
.contents
;
3014 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
3018 is_pic
= bfd_link_pic (link_info
);
3020 /* TRUE if we can convert only to R_X86_64_PC32. Enable it for
3023 = link_info
->disable_target_specific_optimizations
> 1;
3025 irelend
= internal_relocs
+ sec
->reloc_count
;
3026 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3028 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
3029 unsigned int r_symndx
= htab
->r_sym (irel
->r_info
);
3031 struct elf_link_hash_entry
*h
;
3035 bfd_signed_vma raddend
;
3036 unsigned int opcode
;
3039 bfd_boolean to_reloc_pc32
;
3041 relocx
= (r_type
== R_X86_64_GOTPCRELX
3042 || r_type
== R_X86_64_REX_GOTPCRELX
);
3043 if (!relocx
&& r_type
!= R_X86_64_GOTPCREL
)
3046 roff
= irel
->r_offset
;
3047 if (roff
< (r_type
== R_X86_64_REX_GOTPCRELX
? 3 : 2))
3050 raddend
= irel
->r_addend
;
3051 /* Addend for 32-bit PC-relative relocation must be -4. */
3055 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
3057 /* Convert mov to lea since it has been done for a while. */
3060 /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
3061 for call, jmp or one of adc, add, and, cmp, or, sbb, sub,
3062 test, xor instructions. */
3067 /* We convert only to R_X86_64_PC32:
3069 2. R_X86_64_GOTPCREL since we can't modify REX byte.
3070 3. require_reloc_pc32 is true.
3073 to_reloc_pc32
= (opcode
== 0xff
3075 || require_reloc_pc32
3078 /* Get the symbol referred to by the reloc. */
3079 if (r_symndx
< symtab_hdr
->sh_info
)
3081 Elf_Internal_Sym
*isym
;
3083 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
3086 symtype
= ELF_ST_TYPE (isym
->st_info
);
3088 /* STT_GNU_IFUNC must keep GOTPCREL relocations and skip
3089 relocation against undefined symbols. */
3090 if (symtype
== STT_GNU_IFUNC
|| isym
->st_shndx
== SHN_UNDEF
)
3093 if (isym
->st_shndx
== SHN_ABS
)
3094 tsec
= bfd_abs_section_ptr
;
3095 else if (isym
->st_shndx
== SHN_COMMON
)
3096 tsec
= bfd_com_section_ptr
;
3097 else if (isym
->st_shndx
== SHN_X86_64_LCOMMON
)
3098 tsec
= &_bfd_elf_large_com_section
;
3100 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
3103 toff
= isym
->st_value
;
3107 indx
= r_symndx
- symtab_hdr
->sh_info
;
3108 h
= elf_sym_hashes (abfd
)[indx
];
3109 BFD_ASSERT (h
!= NULL
);
3111 while (h
->root
.type
== bfd_link_hash_indirect
3112 || h
->root
.type
== bfd_link_hash_warning
)
3113 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3115 /* STT_GNU_IFUNC must keep GOTPCREL relocations. We also
3116 avoid optimizing GOTPCREL relocations againt _DYNAMIC
3117 since ld.so may use its link-time address. */
3118 if (h
->type
== STT_GNU_IFUNC
)
3121 /* Undefined weak symbol is only bound locally in executable
3122 and its reference is resolved as 0 without relocation
3123 overflow. We can only perform this optimization for
3124 GOTPCRELX relocations since we need to modify REX byte.
3125 It is OK convert mov with R_X86_64_GOTPCREL to
3127 if ((relocx
|| opcode
== 0x8b)
3128 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
,
3130 elf_x86_64_hash_entry (h
)))
3134 /* Skip for branch instructions since R_X86_64_PC32
3136 if (require_reloc_pc32
)
3141 /* For non-branch instructions, we can convert to
3142 R_X86_64_32/R_X86_64_32S since we know if there
3144 to_reloc_pc32
= FALSE
;
3147 /* Since we don't know the current PC when PIC is true,
3148 we can't convert to R_X86_64_PC32. */
3149 if (to_reloc_pc32
&& is_pic
)
3154 else if ((h
->def_regular
3155 || h
->root
.type
== bfd_link_hash_defined
3156 || h
->root
.type
== bfd_link_hash_defweak
)
3157 && h
!= htab
->elf
.hdynamic
3158 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
3160 /* bfd_link_hash_new or bfd_link_hash_undefined is
3161 set by an assignment in a linker script in
3162 bfd_elf_record_link_assignment. */
3164 && (h
->root
.type
== bfd_link_hash_new
3165 || h
->root
.type
== bfd_link_hash_undefined
))
3167 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */
3168 if (require_reloc_pc32
)
3172 tsec
= h
->root
.u
.def
.section
;
3173 toff
= h
->root
.u
.def
.value
;
3180 /* We can only estimate relocation overflow for R_X86_64_PC32. */
3184 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
3186 /* At this stage in linking, no SEC_MERGE symbol has been
3187 adjusted, so all references to such symbols need to be
3188 passed through _bfd_merged_section_offset. (Later, in
3189 relocate_section, all SEC_MERGE symbols *except* for
3190 section symbols have been adjusted.)
3192 gas may reduce relocations against symbols in SEC_MERGE
3193 sections to a relocation against the section symbol when
3194 the original addend was zero. When the reloc is against
3195 a section symbol we should include the addend in the
3196 offset passed to _bfd_merged_section_offset, since the
3197 location of interest is the original symbol. On the
3198 other hand, an access to "sym+addend" where "sym" is not
3199 a section symbol should not include the addend; Such an
3200 access is presumed to be an offset from "sym"; The
3201 location of interest is just "sym". */
3202 if (symtype
== STT_SECTION
)
3205 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
3206 elf_section_data (tsec
)->sec_info
,
3209 if (symtype
!= STT_SECTION
)
3215 /* Don't convert if R_X86_64_PC32 relocation overflows. */
3216 if (tsec
->output_section
== sec
->output_section
)
3218 if ((toff
- roff
+ 0x80000000) > 0xffffffff)
3223 bfd_signed_vma distance
;
3225 /* At this point, we don't know the load addresses of TSEC
3226 section nor SEC section. We estimate the distrance between
3227 SEC and TSEC. We store the estimated distances in the
3228 compressed_size field of the output section, which is only
3229 used to decompress the compressed input section. */
3230 if (sec
->output_section
->compressed_size
== 0)
3233 bfd_size_type size
= 0;
3234 for (asect
= link_info
->output_bfd
->sections
;
3236 asect
= asect
->next
)
3237 /* Skip debug sections since compressed_size is used to
3238 compress debug sections. */
3239 if ((asect
->flags
& SEC_DEBUGGING
) == 0)
3242 for (i
= asect
->map_head
.s
;
3246 size
= align_power (size
, i
->alignment_power
);
3249 asect
->compressed_size
= size
;
3253 /* Don't convert GOTPCREL relocations if TSEC isn't placed
3255 distance
= (tsec
->output_section
->compressed_size
3256 - sec
->output_section
->compressed_size
);
3260 /* Take PT_GNU_RELRO segment into account by adding
3262 if ((toff
+ distance
+ maxpagesize
- roff
+ 0x80000000)
3270 /* We have "call/jmp *foo@GOTPCREL(%rip)". */
3275 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
3277 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
3280 /* Convert to "jmp foo nop". */
3283 nop_offset
= irel
->r_offset
+ 3;
3284 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
3285 irel
->r_offset
-= 1;
3286 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
3290 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
3293 nop
= link_info
->call_nop_byte
;
3294 if (link_info
->call_nop_as_suffix
)
3296 nop_offset
= irel
->r_offset
+ 3;
3297 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
3298 irel
->r_offset
-= 1;
3299 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
3302 nop_offset
= irel
->r_offset
- 2;
3304 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
3305 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
3306 r_type
= R_X86_64_PC32
;
3311 unsigned int rex_mask
= REX_R
;
3313 if (r_type
== R_X86_64_REX_GOTPCRELX
)
3314 rex
= bfd_get_8 (abfd
, contents
+ roff
- 3);
3322 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
3323 "lea foo(%rip), %reg". */
3325 r_type
= R_X86_64_PC32
;
3329 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
3330 "mov $foo, %reg". */
3332 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
3333 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
3334 if ((rex
& REX_W
) != 0
3335 && ABI_64_P (link_info
->output_bfd
))
3337 /* Keep the REX_W bit in REX byte for LP64. */
3338 r_type
= R_X86_64_32S
;
3339 goto rewrite_modrm_rex
;
3343 /* If the REX_W bit in REX byte isn't needed,
3344 use R_X86_64_32 and clear the W bit to avoid
3345 sign-extend imm32 to imm64. */
3346 r_type
= R_X86_64_32
;
3347 /* Clear the W bit in REX byte. */
3349 goto rewrite_modrm_rex
;
3355 /* R_X86_64_PC32 isn't supported. */
3359 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
3362 /* Convert "test %reg, foo@GOTPCREL(%rip)" to
3363 "test $foo, %reg". */
3364 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
3369 /* Convert "binop foo@GOTPCREL(%rip), %reg" to
3370 "binop $foo, %reg". */
3371 modrm
= 0xc0 | (modrm
& 0x38) >> 3 | (opcode
& 0x3c);
3375 /* Use R_X86_64_32 with 32-bit operand to avoid relocation
3376 overflow when sign-extending imm32 to imm64. */
3377 r_type
= (rex
& REX_W
) != 0 ? R_X86_64_32S
: R_X86_64_32
;
3380 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
3384 /* Move the R bit to the B bit in REX byte. */
3385 rex
= (rex
& ~rex_mask
) | (rex
& REX_R
) >> 2;
3386 bfd_put_8 (abfd
, rex
, contents
+ roff
- 3);
3389 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */
3393 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
3396 irel
->r_info
= htab
->r_info (r_symndx
, r_type
);
3397 changed_contents
= TRUE
;
3398 changed_relocs
= TRUE
;
3402 if (h
->got
.refcount
> 0)
3403 h
->got
.refcount
-= 1;
3407 if (local_got_refcounts
!= NULL
3408 && local_got_refcounts
[r_symndx
] > 0)
3409 local_got_refcounts
[r_symndx
] -= 1;
3413 if (contents
!= NULL
3414 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3416 if (!changed_contents
&& !link_info
->keep_memory
)
3420 /* Cache the section contents for elf_link_input_bfd. */
3421 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3425 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3427 if (!changed_relocs
)
3428 free (internal_relocs
);
3430 elf_section_data (sec
)->relocs
= internal_relocs
;
3436 if (contents
!= NULL
3437 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3439 if (internal_relocs
!= NULL
3440 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3441 free (internal_relocs
);
3445 /* Set the sizes of the dynamic sections. */
3448 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
3449 struct bfd_link_info
*info
)
3451 struct elf_x86_64_link_hash_table
*htab
;
3456 const struct elf_backend_data
*bed
;
3458 htab
= elf_x86_64_hash_table (info
);
3461 bed
= get_elf_backend_data (output_bfd
);
3463 dynobj
= htab
->elf
.dynobj
;
3467 /* Set up .got offsets for local syms, and space for local dynamic
3469 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3471 bfd_signed_vma
*local_got
;
3472 bfd_signed_vma
*end_local_got
;
3473 char *local_tls_type
;
3474 bfd_vma
*local_tlsdesc_gotent
;
3475 bfd_size_type locsymcount
;
3476 Elf_Internal_Shdr
*symtab_hdr
;
3479 if (! is_x86_64_elf (ibfd
))
3482 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3484 struct elf_dyn_relocs
*p
;
3486 if (!elf_x86_64_convert_load (ibfd
, s
, info
))
3489 for (p
= (struct elf_dyn_relocs
*)
3490 (elf_section_data (s
)->local_dynrel
);
3494 if (!bfd_is_abs_section (p
->sec
)
3495 && bfd_is_abs_section (p
->sec
->output_section
))
3497 /* Input section has been discarded, either because
3498 it is a copy of a linkonce section or due to
3499 linker script /DISCARD/, so we'll be discarding
3502 else if (p
->count
!= 0)
3504 srel
= elf_section_data (p
->sec
)->sreloc
;
3505 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3506 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3507 && (info
->flags
& DF_TEXTREL
) == 0)
3509 info
->flags
|= DF_TEXTREL
;
3510 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3511 || info
->error_textrel
)
3512 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3513 p
->sec
->owner
, p
->sec
);
3519 local_got
= elf_local_got_refcounts (ibfd
);
3523 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3524 locsymcount
= symtab_hdr
->sh_info
;
3525 end_local_got
= local_got
+ locsymcount
;
3526 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
3527 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
3529 srel
= htab
->elf
.srelgot
;
3530 for (; local_got
< end_local_got
;
3531 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3533 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3536 if (GOT_TLS_GDESC_P (*local_tls_type
))
3538 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3539 - elf_x86_64_compute_jump_table_size (htab
);
3540 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3541 *local_got
= (bfd_vma
) -2;
3543 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3544 || GOT_TLS_GD_P (*local_tls_type
))
3546 *local_got
= s
->size
;
3547 s
->size
+= GOT_ENTRY_SIZE
;
3548 if (GOT_TLS_GD_P (*local_tls_type
))
3549 s
->size
+= GOT_ENTRY_SIZE
;
3551 if (bfd_link_pic (info
)
3552 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3553 || *local_tls_type
== GOT_TLS_IE
)
3555 if (GOT_TLS_GDESC_P (*local_tls_type
))
3557 htab
->elf
.srelplt
->size
3558 += bed
->s
->sizeof_rela
;
3559 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3561 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3562 || GOT_TLS_GD_P (*local_tls_type
))
3563 srel
->size
+= bed
->s
->sizeof_rela
;
3567 *local_got
= (bfd_vma
) -1;
3571 if (htab
->tls_ld_got
.refcount
> 0)
3573 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3575 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
3576 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
3577 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3580 htab
->tls_ld_got
.offset
= -1;
3582 /* Allocate global sym .plt and .got entries, and space for global
3583 sym dynamic relocs. */
3584 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
3587 /* Allocate .plt and .got entries, and space for local symbols. */
3588 htab_traverse (htab
->loc_hash_table
,
3589 elf_x86_64_allocate_local_dynrelocs
,
3592 /* For every jump slot reserved in the sgotplt, reloc_count is
3593 incremented. However, when we reserve space for TLS descriptors,
3594 it's not incremented, so in order to compute the space reserved
3595 for them, it suffices to multiply the reloc count by the jump
3598 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3599 so that R_X86_64_IRELATIVE entries come last. */
3600 if (htab
->elf
.srelplt
)
3602 htab
->sgotplt_jump_table_size
3603 = elf_x86_64_compute_jump_table_size (htab
);
3604 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3606 else if (htab
->elf
.irelplt
)
3607 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3609 if (htab
->tlsdesc_plt
)
3611 /* If we're not using lazy TLS relocations, don't generate the
3612 PLT and GOT entries they require. */
3613 if ((info
->flags
& DF_BIND_NOW
))
3614 htab
->tlsdesc_plt
= 0;
3617 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
3618 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
3619 /* Reserve room for the initial entry.
3620 FIXME: we could probably do away with it in this case. */
3621 if (htab
->elf
.splt
->size
== 0)
3622 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3623 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
3624 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3628 if (htab
->elf
.sgotplt
)
3630 /* Don't allocate .got.plt section if there are no GOT nor PLT
3631 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3632 if ((htab
->elf
.hgot
== NULL
3633 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3634 && (htab
->elf
.sgotplt
->size
3635 == get_elf_backend_data (output_bfd
)->got_header_size
)
3636 && (htab
->elf
.splt
== NULL
3637 || htab
->elf
.splt
->size
== 0)
3638 && (htab
->elf
.sgot
== NULL
3639 || htab
->elf
.sgot
->size
== 0)
3640 && (htab
->elf
.iplt
== NULL
3641 || htab
->elf
.iplt
->size
== 0)
3642 && (htab
->elf
.igotplt
== NULL
3643 || htab
->elf
.igotplt
->size
== 0))
3644 htab
->elf
.sgotplt
->size
= 0;
3647 if (htab
->plt_eh_frame
!= NULL
3648 && htab
->elf
.splt
!= NULL
3649 && htab
->elf
.splt
->size
!= 0
3650 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3651 && _bfd_elf_eh_frame_present (info
))
3653 const struct elf_x86_64_backend_data
*arch_data
3654 = get_elf_x86_64_arch_data (bed
);
3655 htab
->plt_eh_frame
->size
= arch_data
->eh_frame_plt_size
;
3658 /* We now have determined the sizes of the various dynamic sections.
3659 Allocate memory for them. */
3661 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3663 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3666 if (s
== htab
->elf
.splt
3667 || s
== htab
->elf
.sgot
3668 || s
== htab
->elf
.sgotplt
3669 || s
== htab
->elf
.iplt
3670 || s
== htab
->elf
.igotplt
3671 || s
== htab
->plt_bnd
3672 || s
== htab
->plt_got
3673 || s
== htab
->plt_eh_frame
3674 || s
== htab
->sdynbss
)
3676 /* Strip this section if we don't need it; see the
3679 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3681 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
3684 /* We use the reloc_count field as a counter if we need
3685 to copy relocs into the output file. */
3686 if (s
!= htab
->elf
.srelplt
)
3691 /* It's not one of our sections, so don't allocate space. */
3697 /* If we don't need this section, strip it from the
3698 output file. This is mostly to handle .rela.bss and
3699 .rela.plt. We must create both sections in
3700 create_dynamic_sections, because they must be created
3701 before the linker maps input sections to output
3702 sections. The linker does that before
3703 adjust_dynamic_symbol is called, and it is that
3704 function which decides whether anything needs to go
3705 into these sections. */
3707 s
->flags
|= SEC_EXCLUDE
;
3711 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3714 /* Allocate memory for the section contents. We use bfd_zalloc
3715 here in case unused entries are not reclaimed before the
3716 section's contents are written out. This should not happen,
3717 but this way if it does, we get a R_X86_64_NONE reloc instead
3719 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3720 if (s
->contents
== NULL
)
3724 if (htab
->plt_eh_frame
!= NULL
3725 && htab
->plt_eh_frame
->contents
!= NULL
)
3727 const struct elf_x86_64_backend_data
*arch_data
3728 = get_elf_x86_64_arch_data (bed
);
3730 memcpy (htab
->plt_eh_frame
->contents
,
3731 arch_data
->eh_frame_plt
, htab
->plt_eh_frame
->size
);
3732 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3733 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3736 if (htab
->elf
.dynamic_sections_created
)
3738 /* Add some entries to the .dynamic section. We fill in the
3739 values later, in elf_x86_64_finish_dynamic_sections, but we
3740 must add the entries now so that we get the correct size for
3741 the .dynamic section. The DT_DEBUG entry is filled in by the
3742 dynamic linker and used by the debugger. */
3743 #define add_dynamic_entry(TAG, VAL) \
3744 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3746 if (bfd_link_executable (info
))
3748 if (!add_dynamic_entry (DT_DEBUG
, 0))
3752 if (htab
->elf
.splt
->size
!= 0)
3754 /* DT_PLTGOT is used by prelink even if there is no PLT
3756 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3759 if (htab
->elf
.srelplt
->size
!= 0)
3761 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3762 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3763 || !add_dynamic_entry (DT_JMPREL
, 0))
3767 if (htab
->tlsdesc_plt
3768 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3769 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3775 if (!add_dynamic_entry (DT_RELA
, 0)
3776 || !add_dynamic_entry (DT_RELASZ
, 0)
3777 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3780 /* If any dynamic relocs apply to a read-only section,
3781 then we need a DT_TEXTREL entry. */
3782 if ((info
->flags
& DF_TEXTREL
) == 0)
3783 elf_link_hash_traverse (&htab
->elf
,
3784 elf_x86_64_readonly_dynrelocs
,
3787 if ((info
->flags
& DF_TEXTREL
) != 0)
3789 if (htab
->readonly_dynrelocs_against_ifunc
)
3791 info
->callbacks
->einfo
3792 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3793 bfd_set_error (bfd_error_bad_value
);
3797 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3802 #undef add_dynamic_entry
3808 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3809 struct bfd_link_info
*info
)
3811 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3815 struct elf_link_hash_entry
*tlsbase
;
3817 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3818 "_TLS_MODULE_BASE_",
3819 FALSE
, FALSE
, FALSE
);
3821 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3823 struct elf_x86_64_link_hash_table
*htab
;
3824 struct bfd_link_hash_entry
*bh
= NULL
;
3825 const struct elf_backend_data
*bed
3826 = get_elf_backend_data (output_bfd
);
3828 htab
= elf_x86_64_hash_table (info
);
3832 if (!(_bfd_generic_link_add_one_symbol
3833 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3834 tls_sec
, 0, NULL
, FALSE
,
3835 bed
->collect
, &bh
)))
3838 htab
->tls_module_base
= bh
;
3840 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3841 tlsbase
->def_regular
= 1;
3842 tlsbase
->other
= STV_HIDDEN
;
3843 tlsbase
->root
.linker_def
= 1;
3844 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3851 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3852 executables. Rather than setting it to the beginning of the TLS
3853 section, we have to set it to the end. This function may be called
3854 multiple times, it is idempotent. */
3857 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
3859 struct elf_x86_64_link_hash_table
*htab
;
3860 struct bfd_link_hash_entry
*base
;
3862 if (!bfd_link_executable (info
))
3865 htab
= elf_x86_64_hash_table (info
);
3869 base
= htab
->tls_module_base
;
3873 base
->u
.def
.value
= htab
->elf
.tls_size
;
3876 /* Return the base VMA address which should be subtracted from real addresses
3877 when resolving @dtpoff relocation.
3878 This is PT_TLS segment p_vaddr. */
3881 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
3883 /* If tls_sec is NULL, we should have signalled an error already. */
3884 if (elf_hash_table (info
)->tls_sec
== NULL
)
3886 return elf_hash_table (info
)->tls_sec
->vma
;
3889 /* Return the relocation value for @tpoff relocation
3890 if STT_TLS virtual address is ADDRESS. */
3893 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3895 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3896 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
3897 bfd_vma static_tls_size
;
3899 /* If tls_segment is NULL, we should have signalled an error already. */
3900 if (htab
->tls_sec
== NULL
)
3903 /* Consider special static TLS alignment requirements. */
3904 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
3905 return address
- static_tls_size
- htab
->tls_sec
->vma
;
3908 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
3912 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
3914 /* Opcode Instruction
3917 0x0f 0x8x conditional jump */
3919 && (contents
[offset
- 1] == 0xe8
3920 || contents
[offset
- 1] == 0xe9))
3922 && contents
[offset
- 2] == 0x0f
3923 && (contents
[offset
- 1] & 0xf0) == 0x80));
3926 /* Relocate an x86_64 ELF section. */
3929 elf_x86_64_relocate_section (bfd
*output_bfd
,
3930 struct bfd_link_info
*info
,
3932 asection
*input_section
,
3934 Elf_Internal_Rela
*relocs
,
3935 Elf_Internal_Sym
*local_syms
,
3936 asection
**local_sections
)
3938 struct elf_x86_64_link_hash_table
*htab
;
3939 Elf_Internal_Shdr
*symtab_hdr
;
3940 struct elf_link_hash_entry
**sym_hashes
;
3941 bfd_vma
*local_got_offsets
;
3942 bfd_vma
*local_tlsdesc_gotents
;
3943 Elf_Internal_Rela
*rel
;
3944 Elf_Internal_Rela
*wrel
;
3945 Elf_Internal_Rela
*relend
;
3946 const unsigned int plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
3948 BFD_ASSERT (is_x86_64_elf (input_bfd
));
3950 /* Skip if check_relocs failed. */
3951 if (input_section
->check_relocs_failed
)
3954 htab
= elf_x86_64_hash_table (info
);
3957 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3958 sym_hashes
= elf_sym_hashes (input_bfd
);
3959 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3960 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
3962 elf_x86_64_set_tls_module_base (info
);
3964 rel
= wrel
= relocs
;
3965 relend
= relocs
+ input_section
->reloc_count
;
3966 for (; rel
< relend
; wrel
++, rel
++)
3968 unsigned int r_type
;
3969 reloc_howto_type
*howto
;
3970 unsigned long r_symndx
;
3971 struct elf_link_hash_entry
*h
;
3972 struct elf_x86_64_link_hash_entry
*eh
;
3973 Elf_Internal_Sym
*sym
;
3975 bfd_vma off
, offplt
, plt_offset
;
3977 bfd_boolean unresolved_reloc
;
3978 bfd_reloc_status_type r
;
3980 asection
*base_got
, *resolved_plt
;
3982 bfd_boolean resolved_to_zero
;
3984 r_type
= ELF32_R_TYPE (rel
->r_info
);
3985 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
3986 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
3993 if (r_type
>= (int) R_X86_64_standard
)
3995 (*_bfd_error_handler
)
3996 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3997 input_bfd
, input_section
, r_type
);
3998 bfd_set_error (bfd_error_bad_value
);
4002 if (r_type
!= (int) R_X86_64_32
4003 || ABI_64_P (output_bfd
))
4004 howto
= x86_64_elf_howto_table
+ r_type
;
4006 howto
= (x86_64_elf_howto_table
4007 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
4008 r_symndx
= htab
->r_sym (rel
->r_info
);
4012 unresolved_reloc
= FALSE
;
4013 if (r_symndx
< symtab_hdr
->sh_info
)
4015 sym
= local_syms
+ r_symndx
;
4016 sec
= local_sections
[r_symndx
];
4018 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
4020 st_size
= sym
->st_size
;
4022 /* Relocate against local STT_GNU_IFUNC symbol. */
4023 if (!bfd_link_relocatable (info
)
4024 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
4026 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
4031 /* Set STT_GNU_IFUNC symbol value. */
4032 h
->root
.u
.def
.value
= sym
->st_value
;
4033 h
->root
.u
.def
.section
= sec
;
4038 bfd_boolean warned ATTRIBUTE_UNUSED
;
4039 bfd_boolean ignored ATTRIBUTE_UNUSED
;
4041 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
4042 r_symndx
, symtab_hdr
, sym_hashes
,
4044 unresolved_reloc
, warned
, ignored
);
4048 if (sec
!= NULL
&& discarded_section (sec
))
4050 _bfd_clear_contents (howto
, input_bfd
, input_section
,
4051 contents
+ rel
->r_offset
);
4052 wrel
->r_offset
= rel
->r_offset
;
4056 /* For ld -r, remove relocations in debug sections against
4057 sections defined in discarded sections. Not done for
4058 eh_frame editing code expects to be present. */
4059 if (bfd_link_relocatable (info
)
4060 && (input_section
->flags
& SEC_DEBUGGING
))
4066 if (bfd_link_relocatable (info
))
4073 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
4075 if (r_type
== R_X86_64_64
)
4077 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
4078 zero-extend it to 64bit if addend is zero. */
4079 r_type
= R_X86_64_32
;
4080 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4082 else if (r_type
== R_X86_64_SIZE64
)
4084 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
4085 zero-extend it to 64bit if addend is zero. */
4086 r_type
= R_X86_64_SIZE32
;
4087 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4091 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
4093 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
4094 it here if it is defined in a non-shared object. */
4096 && h
->type
== STT_GNU_IFUNC
4102 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4104 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4105 sections because such sections are not SEC_ALLOC and
4106 thus ld.so will not process them. */
4107 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
4111 else if (h
->plt
.offset
== (bfd_vma
) -1)
4114 /* STT_GNU_IFUNC symbol must go through PLT. */
4115 if (htab
->elf
.splt
!= NULL
)
4117 if (htab
->plt_bnd
!= NULL
)
4119 resolved_plt
= htab
->plt_bnd
;
4120 plt_offset
= eh
->plt_bnd
.offset
;
4124 resolved_plt
= htab
->elf
.splt
;
4125 plt_offset
= h
->plt
.offset
;
4130 resolved_plt
= htab
->elf
.iplt
;
4131 plt_offset
= h
->plt
.offset
;
4134 relocation
= (resolved_plt
->output_section
->vma
4135 + resolved_plt
->output_offset
+ plt_offset
);
4140 if (h
->root
.root
.string
)
4141 name
= h
->root
.root
.string
;
4143 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4145 (*_bfd_error_handler
)
4146 (_("%B: relocation %s against STT_GNU_IFUNC "
4147 "symbol `%s' isn't handled by %s"), input_bfd
,
4148 howto
->name
, name
, __FUNCTION__
);
4149 bfd_set_error (bfd_error_bad_value
);
4153 if (bfd_link_pic (info
))
4158 if (ABI_64_P (output_bfd
))
4162 if (rel
->r_addend
!= 0)
4164 if (h
->root
.root
.string
)
4165 name
= h
->root
.root
.string
;
4167 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4169 (*_bfd_error_handler
)
4170 (_("%B: relocation %s against STT_GNU_IFUNC "
4171 "symbol `%s' has non-zero addend: %d"),
4172 input_bfd
, howto
->name
, name
, rel
->r_addend
);
4173 bfd_set_error (bfd_error_bad_value
);
4177 /* Generate dynamic relcoation only when there is a
4178 non-GOT reference in a shared object. */
4179 if (bfd_link_pic (info
) && h
->non_got_ref
)
4181 Elf_Internal_Rela outrel
;
4184 /* Need a dynamic relocation to get the real function
4186 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
4190 if (outrel
.r_offset
== (bfd_vma
) -1
4191 || outrel
.r_offset
== (bfd_vma
) -2)
4194 outrel
.r_offset
+= (input_section
->output_section
->vma
4195 + input_section
->output_offset
);
4197 if (h
->dynindx
== -1
4199 || bfd_link_executable (info
))
4201 /* This symbol is resolved locally. */
4202 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4203 outrel
.r_addend
= (h
->root
.u
.def
.value
4204 + h
->root
.u
.def
.section
->output_section
->vma
4205 + h
->root
.u
.def
.section
->output_offset
);
4209 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4210 outrel
.r_addend
= 0;
4213 sreloc
= htab
->elf
.irelifunc
;
4214 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4216 /* If this reloc is against an external symbol, we
4217 do not want to fiddle with the addend. Otherwise,
4218 we need to include the symbol value so that it
4219 becomes an addend for the dynamic reloc. For an
4220 internal symbol, we have updated addend. */
4225 case R_X86_64_PC32_BND
:
4227 case R_X86_64_PLT32
:
4228 case R_X86_64_PLT32_BND
:
4231 case R_X86_64_GOTPCREL
:
4232 case R_X86_64_GOTPCRELX
:
4233 case R_X86_64_REX_GOTPCRELX
:
4234 case R_X86_64_GOTPCREL64
:
4235 base_got
= htab
->elf
.sgot
;
4236 off
= h
->got
.offset
;
4238 if (base_got
== NULL
)
4241 if (off
== (bfd_vma
) -1)
4243 /* We can't use h->got.offset here to save state, or
4244 even just remember the offset, as finish_dynamic_symbol
4245 would use that as offset into .got. */
4247 if (htab
->elf
.splt
!= NULL
)
4249 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4250 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4251 base_got
= htab
->elf
.sgotplt
;
4255 plt_index
= h
->plt
.offset
/ plt_entry_size
;
4256 off
= plt_index
* GOT_ENTRY_SIZE
;
4257 base_got
= htab
->elf
.igotplt
;
4260 if (h
->dynindx
== -1
4264 /* This references the local defitionion. We must
4265 initialize this entry in the global offset table.
4266 Since the offset must always be a multiple of 8,
4267 we use the least significant bit to record
4268 whether we have initialized it already.
4270 When doing a dynamic link, we create a .rela.got
4271 relocation entry to initialize the value. This
4272 is done in the finish_dynamic_symbol routine. */
4277 bfd_put_64 (output_bfd
, relocation
,
4278 base_got
->contents
+ off
);
4279 /* Note that this is harmless for the GOTPLT64
4280 case, as -1 | 1 still is -1. */
4286 relocation
= (base_got
->output_section
->vma
4287 + base_got
->output_offset
+ off
);
4293 resolved_to_zero
= (eh
!= NULL
4294 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
4298 /* When generating a shared object, the relocations handled here are
4299 copied into the output file to be resolved at run time. */
4302 case R_X86_64_GOT32
:
4303 case R_X86_64_GOT64
:
4304 /* Relocation is to the entry for this symbol in the global
4306 case R_X86_64_GOTPCREL
:
4307 case R_X86_64_GOTPCRELX
:
4308 case R_X86_64_REX_GOTPCRELX
:
4309 case R_X86_64_GOTPCREL64
:
4310 /* Use global offset table entry as symbol value. */
4311 case R_X86_64_GOTPLT64
:
4312 /* This is obsolete and treated the the same as GOT64. */
4313 base_got
= htab
->elf
.sgot
;
4315 if (htab
->elf
.sgot
== NULL
)
4322 off
= h
->got
.offset
;
4324 && h
->plt
.offset
!= (bfd_vma
)-1
4325 && off
== (bfd_vma
)-1)
4327 /* We can't use h->got.offset here to save
4328 state, or even just remember the offset, as
4329 finish_dynamic_symbol would use that as offset into
4331 bfd_vma plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4332 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4333 base_got
= htab
->elf
.sgotplt
;
4336 dyn
= htab
->elf
.dynamic_sections_created
;
4338 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
4339 || (bfd_link_pic (info
)
4340 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4341 || (ELF_ST_VISIBILITY (h
->other
)
4342 && h
->root
.type
== bfd_link_hash_undefweak
))
4344 /* This is actually a static link, or it is a -Bsymbolic
4345 link and the symbol is defined locally, or the symbol
4346 was forced to be local because of a version file. We
4347 must initialize this entry in the global offset table.
4348 Since the offset must always be a multiple of 8, we
4349 use the least significant bit to record whether we
4350 have initialized it already.
4352 When doing a dynamic link, we create a .rela.got
4353 relocation entry to initialize the value. This is
4354 done in the finish_dynamic_symbol routine. */
4359 bfd_put_64 (output_bfd
, relocation
,
4360 base_got
->contents
+ off
);
4361 /* Note that this is harmless for the GOTPLT64 case,
4362 as -1 | 1 still is -1. */
4367 unresolved_reloc
= FALSE
;
4371 if (local_got_offsets
== NULL
)
4374 off
= local_got_offsets
[r_symndx
];
4376 /* The offset must always be a multiple of 8. We use
4377 the least significant bit to record whether we have
4378 already generated the necessary reloc. */
4383 bfd_put_64 (output_bfd
, relocation
,
4384 base_got
->contents
+ off
);
4386 if (bfd_link_pic (info
))
4389 Elf_Internal_Rela outrel
;
4391 /* We need to generate a R_X86_64_RELATIVE reloc
4392 for the dynamic linker. */
4393 s
= htab
->elf
.srelgot
;
4397 outrel
.r_offset
= (base_got
->output_section
->vma
4398 + base_got
->output_offset
4400 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4401 outrel
.r_addend
= relocation
;
4402 elf_append_rela (output_bfd
, s
, &outrel
);
4405 local_got_offsets
[r_symndx
] |= 1;
4409 if (off
>= (bfd_vma
) -2)
4412 relocation
= base_got
->output_section
->vma
4413 + base_got
->output_offset
+ off
;
4414 if (r_type
!= R_X86_64_GOTPCREL
4415 && r_type
!= R_X86_64_GOTPCRELX
4416 && r_type
!= R_X86_64_REX_GOTPCRELX
4417 && r_type
!= R_X86_64_GOTPCREL64
)
4418 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4419 - htab
->elf
.sgotplt
->output_offset
;
4423 case R_X86_64_GOTOFF64
:
4424 /* Relocation is relative to the start of the global offset
4427 /* Check to make sure it isn't a protected function or data
4428 symbol for shared library since it may not be local when
4429 used as function address or with copy relocation. We also
4430 need to make sure that a symbol is referenced locally. */
4431 if (bfd_link_pic (info
) && h
)
4433 if (!h
->def_regular
)
4437 switch (ELF_ST_VISIBILITY (h
->other
))
4440 v
= _("hidden symbol");
4443 v
= _("internal symbol");
4446 v
= _("protected symbol");
4453 (*_bfd_error_handler
)
4454 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s `%s' can not be used when making a shared object"),
4455 input_bfd
, v
, h
->root
.root
.string
);
4456 bfd_set_error (bfd_error_bad_value
);
4459 else if (!bfd_link_executable (info
)
4460 && !SYMBOL_REFERENCES_LOCAL (info
, h
)
4461 && (h
->type
== STT_FUNC
4462 || h
->type
== STT_OBJECT
)
4463 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4465 (*_bfd_error_handler
)
4466 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s `%s' can not be used when making a shared object"),
4468 h
->type
== STT_FUNC
? "function" : "data",
4469 h
->root
.root
.string
);
4470 bfd_set_error (bfd_error_bad_value
);
4475 /* Note that sgot is not involved in this
4476 calculation. We always want the start of .got.plt. If we
4477 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4478 permitted by the ABI, we might have to change this
4480 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4481 + htab
->elf
.sgotplt
->output_offset
;
4484 case R_X86_64_GOTPC32
:
4485 case R_X86_64_GOTPC64
:
4486 /* Use global offset table as symbol value. */
4487 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4488 + htab
->elf
.sgotplt
->output_offset
;
4489 unresolved_reloc
= FALSE
;
4492 case R_X86_64_PLTOFF64
:
4493 /* Relocation is PLT entry relative to GOT. For local
4494 symbols it's the symbol itself relative to GOT. */
4496 /* See PLT32 handling. */
4497 && h
->plt
.offset
!= (bfd_vma
) -1
4498 && htab
->elf
.splt
!= NULL
)
4500 if (htab
->plt_bnd
!= NULL
)
4502 resolved_plt
= htab
->plt_bnd
;
4503 plt_offset
= eh
->plt_bnd
.offset
;
4507 resolved_plt
= htab
->elf
.splt
;
4508 plt_offset
= h
->plt
.offset
;
4511 relocation
= (resolved_plt
->output_section
->vma
4512 + resolved_plt
->output_offset
4514 unresolved_reloc
= FALSE
;
4517 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4518 + htab
->elf
.sgotplt
->output_offset
;
4521 case R_X86_64_PLT32
:
4522 case R_X86_64_PLT32_BND
:
4523 /* Relocation is to the entry for this symbol in the
4524 procedure linkage table. */
4526 /* Resolve a PLT32 reloc against a local symbol directly,
4527 without using the procedure linkage table. */
4531 if ((h
->plt
.offset
== (bfd_vma
) -1
4532 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4533 || htab
->elf
.splt
== NULL
)
4535 /* We didn't make a PLT entry for this symbol. This
4536 happens when statically linking PIC code, or when
4537 using -Bsymbolic. */
4541 if (h
->plt
.offset
!= (bfd_vma
) -1)
4543 if (htab
->plt_bnd
!= NULL
)
4545 resolved_plt
= htab
->plt_bnd
;
4546 plt_offset
= eh
->plt_bnd
.offset
;
4550 resolved_plt
= htab
->elf
.splt
;
4551 plt_offset
= h
->plt
.offset
;
4556 /* Use the GOT PLT. */
4557 resolved_plt
= htab
->plt_got
;
4558 plt_offset
= eh
->plt_got
.offset
;
4561 relocation
= (resolved_plt
->output_section
->vma
4562 + resolved_plt
->output_offset
4564 unresolved_reloc
= FALSE
;
4567 case R_X86_64_SIZE32
:
4568 case R_X86_64_SIZE64
:
4569 /* Set to symbol size. */
4570 relocation
= st_size
;
4576 case R_X86_64_PC32_BND
:
4577 /* Don't complain about -fPIC if the symbol is undefined when
4578 building executable unless it is unresolved weak symbol. */
4579 if ((input_section
->flags
& SEC_ALLOC
) != 0
4580 && (input_section
->flags
& SEC_READONLY
) != 0
4582 && ((bfd_link_executable (info
)
4583 && h
->root
.type
== bfd_link_hash_undefweak
4584 && !resolved_to_zero
)
4585 || (bfd_link_pic (info
)
4586 && !(bfd_link_pie (info
)
4587 && h
->root
.type
== bfd_link_hash_undefined
))))
4589 bfd_boolean fail
= FALSE
;
4591 = ((r_type
== R_X86_64_PC32
4592 || r_type
== R_X86_64_PC32_BND
)
4593 && is_32bit_relative_branch (contents
, rel
->r_offset
));
4595 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
4597 /* Symbol is referenced locally. Make sure it is
4598 defined locally or for a branch. */
4599 fail
= !h
->def_regular
&& !branch
;
4601 else if (!(bfd_link_pie (info
)
4602 && (h
->needs_copy
|| eh
->needs_copy
)))
4604 /* Symbol doesn't need copy reloc and isn't referenced
4605 locally. We only allow branch to symbol with
4606 non-default visibility. */
4608 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
4612 return elf_x86_64_need_pic (input_bfd
, input_section
,
4613 h
, NULL
, NULL
, howto
);
4622 /* FIXME: The ABI says the linker should make sure the value is
4623 the same when it's zeroextended to 64 bit. */
4626 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4629 /* Don't copy a pc-relative relocation into the output file
4630 if the symbol needs copy reloc or the symbol is undefined
4631 when building executable. Copy dynamic function pointer
4632 relocations. Don't generate dynamic relocations against
4633 resolved undefined weak symbols in PIE. */
4634 if ((bfd_link_pic (info
)
4635 && !(bfd_link_pie (info
)
4639 || h
->root
.type
== bfd_link_hash_undefined
)
4640 && IS_X86_64_PCREL_TYPE (r_type
))
4642 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4643 && !resolved_to_zero
)
4644 || h
->root
.type
!= bfd_link_hash_undefweak
))
4645 && ((! IS_X86_64_PCREL_TYPE (r_type
)
4646 && r_type
!= R_X86_64_SIZE32
4647 && r_type
!= R_X86_64_SIZE64
)
4648 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
4649 || (ELIMINATE_COPY_RELOCS
4650 && !bfd_link_pic (info
)
4654 || eh
->func_pointer_refcount
> 0
4655 || (h
->root
.type
== bfd_link_hash_undefweak
4656 && !resolved_to_zero
))
4657 && ((h
->def_dynamic
&& !h
->def_regular
)
4658 /* Undefined weak symbol is bound locally when
4660 || h
->root
.type
== bfd_link_hash_undefined
)))
4662 Elf_Internal_Rela outrel
;
4663 bfd_boolean skip
, relocate
;
4666 /* When generating a shared object, these relocations
4667 are copied into the output file to be resolved at run
4673 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4675 if (outrel
.r_offset
== (bfd_vma
) -1)
4677 else if (outrel
.r_offset
== (bfd_vma
) -2)
4678 skip
= TRUE
, relocate
= TRUE
;
4680 outrel
.r_offset
+= (input_section
->output_section
->vma
4681 + input_section
->output_offset
);
4684 memset (&outrel
, 0, sizeof outrel
);
4686 /* h->dynindx may be -1 if this symbol was marked to
4690 && (IS_X86_64_PCREL_TYPE (r_type
)
4691 || !(bfd_link_executable (info
)
4692 || SYMBOLIC_BIND (info
, h
))
4693 || ! h
->def_regular
))
4695 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4696 outrel
.r_addend
= rel
->r_addend
;
4700 /* This symbol is local, or marked to become local.
4701 When relocation overflow check is disabled, we
4702 convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */
4703 if (r_type
== htab
->pointer_r_type
4704 || (r_type
== R_X86_64_32
4705 && info
->no_reloc_overflow_check
))
4708 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4709 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4711 else if (r_type
== R_X86_64_64
4712 && !ABI_64_P (output_bfd
))
4715 outrel
.r_info
= htab
->r_info (0,
4716 R_X86_64_RELATIVE64
);
4717 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4718 /* Check addend overflow. */
4719 if ((outrel
.r_addend
& 0x80000000)
4720 != (rel
->r_addend
& 0x80000000))
4723 int addend
= rel
->r_addend
;
4724 if (h
&& h
->root
.root
.string
)
4725 name
= h
->root
.root
.string
;
4727 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4730 (*_bfd_error_handler
)
4731 (_("%B: addend -0x%x in relocation %s against "
4732 "symbol `%s' at 0x%lx in section `%A' is "
4734 input_bfd
, input_section
, addend
,
4736 (unsigned long) rel
->r_offset
);
4738 (*_bfd_error_handler
)
4739 (_("%B: addend 0x%x in relocation %s against "
4740 "symbol `%s' at 0x%lx in section `%A' is "
4742 input_bfd
, input_section
, addend
,
4744 (unsigned long) rel
->r_offset
);
4745 bfd_set_error (bfd_error_bad_value
);
4753 if (bfd_is_abs_section (sec
))
4755 else if (sec
== NULL
|| sec
->owner
== NULL
)
4757 bfd_set_error (bfd_error_bad_value
);
4764 /* We are turning this relocation into one
4765 against a section symbol. It would be
4766 proper to subtract the symbol's value,
4767 osec->vma, from the emitted reloc addend,
4768 but ld.so expects buggy relocs. */
4769 osec
= sec
->output_section
;
4770 sindx
= elf_section_data (osec
)->dynindx
;
4773 asection
*oi
= htab
->elf
.text_index_section
;
4774 sindx
= elf_section_data (oi
)->dynindx
;
4776 BFD_ASSERT (sindx
!= 0);
4779 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
4780 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4784 sreloc
= elf_section_data (input_section
)->sreloc
;
4786 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4788 r
= bfd_reloc_notsupported
;
4789 goto check_relocation_error
;
4792 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4794 /* If this reloc is against an external symbol, we do
4795 not want to fiddle with the addend. Otherwise, we
4796 need to include the symbol value so that it becomes
4797 an addend for the dynamic reloc. */
4804 case R_X86_64_TLSGD
:
4805 case R_X86_64_GOTPC32_TLSDESC
:
4806 case R_X86_64_TLSDESC_CALL
:
4807 case R_X86_64_GOTTPOFF
:
4808 tls_type
= GOT_UNKNOWN
;
4809 if (h
== NULL
&& local_got_offsets
)
4810 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
4812 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
4814 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4815 input_section
, contents
,
4816 symtab_hdr
, sym_hashes
,
4817 &r_type
, tls_type
, rel
,
4818 relend
, h
, r_symndx
, TRUE
))
4821 if (r_type
== R_X86_64_TPOFF32
)
4823 bfd_vma roff
= rel
->r_offset
;
4825 BFD_ASSERT (! unresolved_reloc
);
4827 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4829 /* GD->LE transition. For 64bit, change
4830 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4831 .word 0x6666; rex64; call __tls_get_addr
4834 leaq foo@tpoff(%rax), %rax
4836 leaq foo@tlsgd(%rip), %rdi
4837 .word 0x6666; rex64; call __tls_get_addr
4840 leaq foo@tpoff(%rax), %rax
4841 For largepic, change:
4842 leaq foo@tlsgd(%rip), %rdi
4843 movabsq $__tls_get_addr@pltoff, %rax
4848 leaq foo@tpoff(%rax), %rax
4849 nopw 0x0(%rax,%rax,1) */
4851 if (ABI_64_P (output_bfd
)
4852 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
4854 memcpy (contents
+ roff
- 3,
4855 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
4856 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4859 else if (ABI_64_P (output_bfd
))
4860 memcpy (contents
+ roff
- 4,
4861 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4864 memcpy (contents
+ roff
- 3,
4865 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4867 bfd_put_32 (output_bfd
,
4868 elf_x86_64_tpoff (info
, relocation
),
4869 contents
+ roff
+ 8 + largepic
);
4870 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4875 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
4877 /* GDesc -> LE transition.
4878 It's originally something like:
4879 leaq x@tlsdesc(%rip), %rax
4882 movl $x@tpoff, %rax. */
4884 unsigned int val
, type
;
4886 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4887 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4888 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
4889 contents
+ roff
- 3);
4890 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
4891 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4892 contents
+ roff
- 1);
4893 bfd_put_32 (output_bfd
,
4894 elf_x86_64_tpoff (info
, relocation
),
4898 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
4900 /* GDesc -> LE transition.
4905 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4906 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4909 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
4911 /* IE->LE transition:
4912 For 64bit, originally it can be one of:
4913 movq foo@gottpoff(%rip), %reg
4914 addq foo@gottpoff(%rip), %reg
4917 leaq foo(%reg), %reg
4919 For 32bit, originally it can be one of:
4920 movq foo@gottpoff(%rip), %reg
4921 addl foo@gottpoff(%rip), %reg
4924 leal foo(%reg), %reg
4927 unsigned int val
, type
, reg
;
4930 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4933 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
4934 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4940 bfd_put_8 (output_bfd
, 0x49,
4941 contents
+ roff
- 3);
4942 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4943 bfd_put_8 (output_bfd
, 0x41,
4944 contents
+ roff
- 3);
4945 bfd_put_8 (output_bfd
, 0xc7,
4946 contents
+ roff
- 2);
4947 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4948 contents
+ roff
- 1);
4952 /* addq/addl -> addq/addl - addressing with %rsp/%r12
4955 bfd_put_8 (output_bfd
, 0x49,
4956 contents
+ roff
- 3);
4957 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4958 bfd_put_8 (output_bfd
, 0x41,
4959 contents
+ roff
- 3);
4960 bfd_put_8 (output_bfd
, 0x81,
4961 contents
+ roff
- 2);
4962 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4963 contents
+ roff
- 1);
4967 /* addq/addl -> leaq/leal */
4969 bfd_put_8 (output_bfd
, 0x4d,
4970 contents
+ roff
- 3);
4971 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4972 bfd_put_8 (output_bfd
, 0x45,
4973 contents
+ roff
- 3);
4974 bfd_put_8 (output_bfd
, 0x8d,
4975 contents
+ roff
- 2);
4976 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
4977 contents
+ roff
- 1);
4979 bfd_put_32 (output_bfd
,
4980 elf_x86_64_tpoff (info
, relocation
),
4988 if (htab
->elf
.sgot
== NULL
)
4993 off
= h
->got
.offset
;
4994 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
4998 if (local_got_offsets
== NULL
)
5001 off
= local_got_offsets
[r_symndx
];
5002 offplt
= local_tlsdesc_gotents
[r_symndx
];
5009 Elf_Internal_Rela outrel
;
5013 if (htab
->elf
.srelgot
== NULL
)
5016 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
5018 if (GOT_TLS_GDESC_P (tls_type
))
5020 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
5021 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
5022 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
5023 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5024 + htab
->elf
.sgotplt
->output_offset
5026 + htab
->sgotplt_jump_table_size
);
5027 sreloc
= htab
->elf
.srelplt
;
5029 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5031 outrel
.r_addend
= 0;
5032 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5035 sreloc
= htab
->elf
.srelgot
;
5037 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5038 + htab
->elf
.sgot
->output_offset
+ off
);
5040 if (GOT_TLS_GD_P (tls_type
))
5041 dr_type
= R_X86_64_DTPMOD64
;
5042 else if (GOT_TLS_GDESC_P (tls_type
))
5045 dr_type
= R_X86_64_TPOFF64
;
5047 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
5048 outrel
.r_addend
= 0;
5049 if ((dr_type
== R_X86_64_TPOFF64
5050 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
5051 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5052 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
5054 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5056 if (GOT_TLS_GD_P (tls_type
))
5060 BFD_ASSERT (! unresolved_reloc
);
5061 bfd_put_64 (output_bfd
,
5062 relocation
- elf_x86_64_dtpoff_base (info
),
5063 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5067 bfd_put_64 (output_bfd
, 0,
5068 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5069 outrel
.r_info
= htab
->r_info (indx
,
5071 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
5072 elf_append_rela (output_bfd
, sreloc
,
5081 local_got_offsets
[r_symndx
] |= 1;
5084 if (off
>= (bfd_vma
) -2
5085 && ! GOT_TLS_GDESC_P (tls_type
))
5087 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
5089 if (r_type
== R_X86_64_GOTPC32_TLSDESC
5090 || r_type
== R_X86_64_TLSDESC_CALL
)
5091 relocation
= htab
->elf
.sgotplt
->output_section
->vma
5092 + htab
->elf
.sgotplt
->output_offset
5093 + offplt
+ htab
->sgotplt_jump_table_size
;
5095 relocation
= htab
->elf
.sgot
->output_section
->vma
5096 + htab
->elf
.sgot
->output_offset
+ off
;
5097 unresolved_reloc
= FALSE
;
5101 bfd_vma roff
= rel
->r_offset
;
5103 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5105 /* GD->IE transition. For 64bit, change
5106 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5107 .word 0x6666; rex64; call __tls_get_addr@plt
5110 addq foo@gottpoff(%rip), %rax
5112 leaq foo@tlsgd(%rip), %rdi
5113 .word 0x6666; rex64; call __tls_get_addr@plt
5116 addq foo@gottpoff(%rip), %rax
5117 For largepic, change:
5118 leaq foo@tlsgd(%rip), %rdi
5119 movabsq $__tls_get_addr@pltoff, %rax
5124 addq foo@gottpoff(%rax), %rax
5125 nopw 0x0(%rax,%rax,1) */
5127 if (ABI_64_P (output_bfd
)
5128 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
5130 memcpy (contents
+ roff
- 3,
5131 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
5132 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5135 else if (ABI_64_P (output_bfd
))
5136 memcpy (contents
+ roff
- 4,
5137 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5140 memcpy (contents
+ roff
- 3,
5141 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5144 relocation
= (htab
->elf
.sgot
->output_section
->vma
5145 + htab
->elf
.sgot
->output_offset
+ off
5148 - input_section
->output_section
->vma
5149 - input_section
->output_offset
5151 bfd_put_32 (output_bfd
, relocation
,
5152 contents
+ roff
+ 8 + largepic
);
5153 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5158 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5160 /* GDesc -> IE transition.
5161 It's originally something like:
5162 leaq x@tlsdesc(%rip), %rax
5165 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
5167 /* Now modify the instruction as appropriate. To
5168 turn a leaq into a movq in the form we use it, it
5169 suffices to change the second byte from 0x8d to
5171 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
5173 bfd_put_32 (output_bfd
,
5174 htab
->elf
.sgot
->output_section
->vma
5175 + htab
->elf
.sgot
->output_offset
+ off
5177 - input_section
->output_section
->vma
5178 - input_section
->output_offset
5183 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5185 /* GDesc -> IE transition.
5192 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5193 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5201 case R_X86_64_TLSLD
:
5202 if (! elf_x86_64_tls_transition (info
, input_bfd
,
5203 input_section
, contents
,
5204 symtab_hdr
, sym_hashes
,
5205 &r_type
, GOT_UNKNOWN
, rel
,
5206 relend
, h
, r_symndx
, TRUE
))
5209 if (r_type
!= R_X86_64_TLSLD
)
5211 /* LD->LE transition:
5212 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
5213 For 64bit, we change it into:
5214 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
5215 For 32bit, we change it into:
5216 nopl 0x0(%rax); movl %fs:0, %eax.
5217 For largepic, change:
5218 leaq foo@tlsgd(%rip), %rdi
5219 movabsq $__tls_get_addr@pltoff, %rax
5223 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
5226 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
5227 if (ABI_64_P (output_bfd
)
5228 && contents
[rel
->r_offset
+ 5] == (bfd_byte
) '\xb8')
5229 memcpy (contents
+ rel
->r_offset
- 3,
5230 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
5231 "\x64\x48\x8b\x04\x25\0\0\0", 22);
5232 else if (ABI_64_P (output_bfd
))
5233 memcpy (contents
+ rel
->r_offset
- 3,
5234 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
5236 memcpy (contents
+ rel
->r_offset
- 3,
5237 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
5238 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5244 if (htab
->elf
.sgot
== NULL
)
5247 off
= htab
->tls_ld_got
.offset
;
5252 Elf_Internal_Rela outrel
;
5254 if (htab
->elf
.srelgot
== NULL
)
5257 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5258 + htab
->elf
.sgot
->output_offset
+ off
);
5260 bfd_put_64 (output_bfd
, 0,
5261 htab
->elf
.sgot
->contents
+ off
);
5262 bfd_put_64 (output_bfd
, 0,
5263 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5264 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
5265 outrel
.r_addend
= 0;
5266 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
5268 htab
->tls_ld_got
.offset
|= 1;
5270 relocation
= htab
->elf
.sgot
->output_section
->vma
5271 + htab
->elf
.sgot
->output_offset
+ off
;
5272 unresolved_reloc
= FALSE
;
5275 case R_X86_64_DTPOFF32
:
5276 if (!bfd_link_executable (info
)
5277 || (input_section
->flags
& SEC_CODE
) == 0)
5278 relocation
-= elf_x86_64_dtpoff_base (info
);
5280 relocation
= elf_x86_64_tpoff (info
, relocation
);
5283 case R_X86_64_TPOFF32
:
5284 case R_X86_64_TPOFF64
:
5285 BFD_ASSERT (bfd_link_executable (info
));
5286 relocation
= elf_x86_64_tpoff (info
, relocation
);
5289 case R_X86_64_DTPOFF64
:
5290 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
5291 relocation
-= elf_x86_64_dtpoff_base (info
);
5298 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5299 because such sections are not SEC_ALLOC and thus ld.so will
5300 not process them. */
5301 if (unresolved_reloc
5302 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
5304 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5305 rel
->r_offset
) != (bfd_vma
) -1)
5307 (*_bfd_error_handler
)
5308 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5311 (long) rel
->r_offset
,
5313 h
->root
.root
.string
);
5318 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5319 contents
, rel
->r_offset
,
5320 relocation
, rel
->r_addend
);
5322 check_relocation_error
:
5323 if (r
!= bfd_reloc_ok
)
5328 name
= h
->root
.root
.string
;
5331 name
= bfd_elf_string_from_elf_section (input_bfd
,
5332 symtab_hdr
->sh_link
,
5337 name
= bfd_section_name (input_bfd
, sec
);
5340 if (r
== bfd_reloc_overflow
)
5342 if (! ((*info
->callbacks
->reloc_overflow
)
5343 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5344 (bfd_vma
) 0, input_bfd
, input_section
,
5350 (*_bfd_error_handler
)
5351 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5352 input_bfd
, input_section
,
5353 (long) rel
->r_offset
, name
, (int) r
);
5364 Elf_Internal_Shdr
*rel_hdr
;
5365 size_t deleted
= rel
- wrel
;
5367 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
5368 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5369 if (rel_hdr
->sh_size
== 0)
5371 /* It is too late to remove an empty reloc section. Leave
5373 ??? What is wrong with an empty section??? */
5374 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
5377 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5378 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5379 input_section
->reloc_count
-= deleted
;
5385 /* Finish up dynamic symbol handling. We set the contents of various
5386 dynamic sections here. */
5389 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
5390 struct bfd_link_info
*info
,
5391 struct elf_link_hash_entry
*h
,
5392 Elf_Internal_Sym
*sym
)
5394 struct elf_x86_64_link_hash_table
*htab
;
5395 const struct elf_x86_64_backend_data
*abed
;
5396 bfd_boolean use_plt_bnd
;
5397 struct elf_x86_64_link_hash_entry
*eh
;
5398 bfd_boolean local_undefweak
;
5400 htab
= elf_x86_64_hash_table (info
);
5404 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5405 section only if there is .plt section. */
5406 use_plt_bnd
= htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
;
5408 ? &elf_x86_64_bnd_arch_bed
5409 : get_elf_x86_64_backend_data (output_bfd
));
5411 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
5413 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5414 resolved undefined weak symbols in executable so that their
5415 references have value 0 at run-time. */
5416 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
5420 if (h
->plt
.offset
!= (bfd_vma
) -1)
5423 bfd_vma got_offset
, plt_offset
, plt_plt_offset
, plt_got_offset
;
5424 bfd_vma plt_plt_insn_end
, plt_got_insn_size
;
5425 Elf_Internal_Rela rela
;
5427 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
5428 const struct elf_backend_data
*bed
;
5429 bfd_vma plt_got_pcrel_offset
;
5431 /* When building a static executable, use .iplt, .igot.plt and
5432 .rela.iplt sections for STT_GNU_IFUNC symbols. */
5433 if (htab
->elf
.splt
!= NULL
)
5435 plt
= htab
->elf
.splt
;
5436 gotplt
= htab
->elf
.sgotplt
;
5437 relplt
= htab
->elf
.srelplt
;
5441 plt
= htab
->elf
.iplt
;
5442 gotplt
= htab
->elf
.igotplt
;
5443 relplt
= htab
->elf
.irelplt
;
5446 /* This symbol has an entry in the procedure linkage table. Set
5448 if ((h
->dynindx
== -1
5450 && !((h
->forced_local
|| bfd_link_executable (info
))
5452 && h
->type
== STT_GNU_IFUNC
))
5458 /* Get the index in the procedure linkage table which
5459 corresponds to this symbol. This is the index of this symbol
5460 in all the symbols for which we are making plt entries. The
5461 first entry in the procedure linkage table is reserved.
5463 Get the offset into the .got table of the entry that
5464 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
5465 bytes. The first three are reserved for the dynamic linker.
5467 For static executables, we don't reserve anything. */
5469 if (plt
== htab
->elf
.splt
)
5471 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
5472 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
5476 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
5477 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
5480 plt_plt_insn_end
= abed
->plt_plt_insn_end
;
5481 plt_plt_offset
= abed
->plt_plt_offset
;
5482 plt_got_insn_size
= abed
->plt_got_insn_size
;
5483 plt_got_offset
= abed
->plt_got_offset
;
5486 /* Use the second PLT with BND relocations. */
5487 const bfd_byte
*plt_entry
, *plt2_entry
;
5489 if (eh
->has_bnd_reloc
)
5491 plt_entry
= elf_x86_64_bnd_plt_entry
;
5492 plt2_entry
= elf_x86_64_bnd_plt2_entry
;
5496 plt_entry
= elf_x86_64_legacy_plt_entry
;
5497 plt2_entry
= elf_x86_64_legacy_plt2_entry
;
5499 /* Subtract 1 since there is no BND prefix. */
5500 plt_plt_insn_end
-= 1;
5501 plt_plt_offset
-= 1;
5502 plt_got_insn_size
-= 1;
5503 plt_got_offset
-= 1;
5506 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry
)
5507 == sizeof (elf_x86_64_legacy_plt_entry
));
5509 /* Fill in the entry in the procedure linkage table. */
5510 memcpy (plt
->contents
+ h
->plt
.offset
,
5511 plt_entry
, sizeof (elf_x86_64_legacy_plt_entry
));
5512 /* Fill in the entry in the second PLT. */
5513 memcpy (htab
->plt_bnd
->contents
+ eh
->plt_bnd
.offset
,
5514 plt2_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5516 resolved_plt
= htab
->plt_bnd
;
5517 plt_offset
= eh
->plt_bnd
.offset
;
5521 /* Fill in the entry in the procedure linkage table. */
5522 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
5523 abed
->plt_entry_size
);
5526 plt_offset
= h
->plt
.offset
;
5529 /* Insert the relocation positions of the plt section. */
5531 /* Put offset the PC-relative instruction referring to the GOT entry,
5532 subtracting the size of that instruction. */
5533 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
5534 + gotplt
->output_offset
5536 - resolved_plt
->output_section
->vma
5537 - resolved_plt
->output_offset
5539 - plt_got_insn_size
);
5541 /* Check PC-relative offset overflow in PLT entry. */
5542 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
5543 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5544 output_bfd
, h
->root
.root
.string
);
5546 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
5547 resolved_plt
->contents
+ plt_offset
+ plt_got_offset
);
5549 /* Fill in the entry in the global offset table, initially this
5550 points to the second part of the PLT entry. Leave the entry
5551 as zero for undefined weak symbol in PIE. No PLT relocation
5552 against undefined weak symbol in PIE. */
5553 if (!local_undefweak
)
5555 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5556 + plt
->output_offset
5558 + abed
->plt_lazy_offset
),
5559 gotplt
->contents
+ got_offset
);
5561 /* Fill in the entry in the .rela.plt section. */
5562 rela
.r_offset
= (gotplt
->output_section
->vma
5563 + gotplt
->output_offset
5565 if (h
->dynindx
== -1
5566 || ((bfd_link_executable (info
)
5567 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5569 && h
->type
== STT_GNU_IFUNC
))
5571 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5572 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
5573 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
5574 rela
.r_addend
= (h
->root
.u
.def
.value
5575 + h
->root
.u
.def
.section
->output_section
->vma
5576 + h
->root
.u
.def
.section
->output_offset
);
5577 /* R_X86_64_IRELATIVE comes last. */
5578 plt_index
= htab
->next_irelative_index
--;
5582 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
5584 plt_index
= htab
->next_jump_slot_index
++;
5587 /* Don't fill PLT entry for static executables. */
5588 if (plt
== htab
->elf
.splt
)
5590 bfd_vma plt0_offset
= h
->plt
.offset
+ plt_plt_insn_end
;
5592 /* Put relocation index. */
5593 bfd_put_32 (output_bfd
, plt_index
,
5594 (plt
->contents
+ h
->plt
.offset
5595 + abed
->plt_reloc_offset
));
5597 /* Put offset for jmp .PLT0 and check for overflow. We don't
5598 check relocation index for overflow since branch displacement
5599 will overflow first. */
5600 if (plt0_offset
> 0x80000000)
5601 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5602 output_bfd
, h
->root
.root
.string
);
5603 bfd_put_32 (output_bfd
, - plt0_offset
,
5604 plt
->contents
+ h
->plt
.offset
+ plt_plt_offset
);
5607 bed
= get_elf_backend_data (output_bfd
);
5608 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
5609 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
5612 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5614 bfd_vma got_offset
, plt_offset
, plt_got_offset
, plt_got_insn_size
;
5615 asection
*plt
, *got
;
5616 bfd_boolean got_after_plt
;
5617 int32_t got_pcrel_offset
;
5618 const bfd_byte
*got_plt_entry
;
5620 /* Set the entry in the GOT procedure linkage table. */
5621 plt
= htab
->plt_got
;
5622 got
= htab
->elf
.sgot
;
5623 got_offset
= h
->got
.offset
;
5625 if (got_offset
== (bfd_vma
) -1
5626 || h
->type
== STT_GNU_IFUNC
5631 /* Use the second PLT entry template for the GOT PLT since they
5632 are the identical. */
5633 plt_got_insn_size
= elf_x86_64_bnd_arch_bed
.plt_got_insn_size
;
5634 plt_got_offset
= elf_x86_64_bnd_arch_bed
.plt_got_offset
;
5635 if (eh
->has_bnd_reloc
)
5636 got_plt_entry
= elf_x86_64_bnd_plt2_entry
;
5639 got_plt_entry
= elf_x86_64_legacy_plt2_entry
;
5641 /* Subtract 1 since there is no BND prefix. */
5642 plt_got_insn_size
-= 1;
5643 plt_got_offset
-= 1;
5646 /* Fill in the entry in the GOT procedure linkage table. */
5647 plt_offset
= eh
->plt_got
.offset
;
5648 memcpy (plt
->contents
+ plt_offset
,
5649 got_plt_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5651 /* Put offset the PC-relative instruction referring to the GOT
5652 entry, subtracting the size of that instruction. */
5653 got_pcrel_offset
= (got
->output_section
->vma
5654 + got
->output_offset
5656 - plt
->output_section
->vma
5657 - plt
->output_offset
5659 - plt_got_insn_size
);
5661 /* Check PC-relative offset overflow in GOT PLT entry. */
5662 got_after_plt
= got
->output_section
->vma
> plt
->output_section
->vma
;
5663 if ((got_after_plt
&& got_pcrel_offset
< 0)
5664 || (!got_after_plt
&& got_pcrel_offset
> 0))
5665 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
5666 output_bfd
, h
->root
.root
.string
);
5668 bfd_put_32 (output_bfd
, got_pcrel_offset
,
5669 plt
->contents
+ plt_offset
+ plt_got_offset
);
5672 if (!local_undefweak
5674 && (h
->plt
.offset
!= (bfd_vma
) -1
5675 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5677 /* Mark the symbol as undefined, rather than as defined in
5678 the .plt section. Leave the value if there were any
5679 relocations where pointer equality matters (this is a clue
5680 for the dynamic linker, to make function pointer
5681 comparisons work between an application and shared
5682 library), otherwise set it to zero. If a function is only
5683 called from a binary, there is no need to slow down
5684 shared libraries because of that. */
5685 sym
->st_shndx
= SHN_UNDEF
;
5686 if (!h
->pointer_equality_needed
)
5690 /* Don't generate dynamic GOT relocation against undefined weak
5691 symbol in executable. */
5692 if (h
->got
.offset
!= (bfd_vma
) -1
5693 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
5694 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
5695 && !local_undefweak
)
5697 Elf_Internal_Rela rela
;
5699 /* This symbol has an entry in the global offset table. Set it
5701 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5704 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5705 + htab
->elf
.sgot
->output_offset
5706 + (h
->got
.offset
&~ (bfd_vma
) 1));
5708 /* If this is a static link, or it is a -Bsymbolic link and the
5709 symbol is defined locally or was forced to be local because
5710 of a version file, we just want to emit a RELATIVE reloc.
5711 The entry in the global offset table will already have been
5712 initialized in the relocate_section function. */
5714 && h
->type
== STT_GNU_IFUNC
)
5716 if (bfd_link_pic (info
))
5718 /* Generate R_X86_64_GLOB_DAT. */
5725 if (!h
->pointer_equality_needed
)
5728 /* For non-shared object, we can't use .got.plt, which
5729 contains the real function addres if we need pointer
5730 equality. We load the GOT entry with the PLT entry. */
5731 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5732 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5733 + plt
->output_offset
5735 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5739 else if (bfd_link_pic (info
)
5740 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5742 if (!h
->def_regular
)
5744 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5745 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
5746 rela
.r_addend
= (h
->root
.u
.def
.value
5747 + h
->root
.u
.def
.section
->output_section
->vma
5748 + h
->root
.u
.def
.section
->output_offset
);
5752 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5754 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5755 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5756 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
5760 elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &rela
);
5765 Elf_Internal_Rela rela
;
5767 /* This symbol needs a copy reloc. Set it up. */
5769 if (h
->dynindx
== -1
5770 || (h
->root
.type
!= bfd_link_hash_defined
5771 && h
->root
.type
!= bfd_link_hash_defweak
)
5772 || htab
->srelbss
== NULL
)
5775 rela
.r_offset
= (h
->root
.u
.def
.value
5776 + h
->root
.u
.def
.section
->output_section
->vma
5777 + h
->root
.u
.def
.section
->output_offset
);
5778 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
5780 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
5786 /* Finish up local dynamic symbol handling. We set the contents of
5787 various dynamic sections here. */
5790 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
5792 struct elf_link_hash_entry
*h
5793 = (struct elf_link_hash_entry
*) *slot
;
5794 struct bfd_link_info
*info
5795 = (struct bfd_link_info
*) inf
;
5797 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5801 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5802 here since undefined weak symbol may not be dynamic and may not be
5803 called for elf_x86_64_finish_dynamic_symbol. */
5806 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
5809 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
5810 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5812 if (h
->root
.type
!= bfd_link_hash_undefweak
5813 || h
->dynindx
!= -1)
5816 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5820 /* Used to decide how to sort relocs in an optimal manner for the
5821 dynamic linker, before writing them out. */
5823 static enum elf_reloc_type_class
5824 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info
,
5825 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5826 const Elf_Internal_Rela
*rela
)
5828 bfd
*abfd
= info
->output_bfd
;
5829 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5830 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
5832 if (htab
->elf
.dynsym
!= NULL
5833 && htab
->elf
.dynsym
->contents
!= NULL
)
5835 /* Check relocation against STT_GNU_IFUNC symbol if there are
5837 unsigned long r_symndx
= htab
->r_sym (rela
->r_info
);
5838 Elf_Internal_Sym sym
;
5839 if (!bed
->s
->swap_symbol_in (abfd
,
5840 (htab
->elf
.dynsym
->contents
5841 + r_symndx
* bed
->s
->sizeof_sym
),
5845 if (ELF_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
5846 return reloc_class_ifunc
;
5849 switch ((int) ELF32_R_TYPE (rela
->r_info
))
5851 case R_X86_64_RELATIVE
:
5852 case R_X86_64_RELATIVE64
:
5853 return reloc_class_relative
;
5854 case R_X86_64_JUMP_SLOT
:
5855 return reloc_class_plt
;
5857 return reloc_class_copy
;
5859 return reloc_class_normal
;
5863 /* Finish up the dynamic sections. */
5866 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
5867 struct bfd_link_info
*info
)
5869 struct elf_x86_64_link_hash_table
*htab
;
5872 const struct elf_x86_64_backend_data
*abed
;
5874 htab
= elf_x86_64_hash_table (info
);
5878 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5879 section only if there is .plt section. */
5880 abed
= (htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
5881 ? &elf_x86_64_bnd_arch_bed
5882 : get_elf_x86_64_backend_data (output_bfd
));
5884 dynobj
= htab
->elf
.dynobj
;
5885 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
5887 if (htab
->elf
.dynamic_sections_created
)
5889 bfd_byte
*dyncon
, *dynconend
;
5890 const struct elf_backend_data
*bed
;
5891 bfd_size_type sizeof_dyn
;
5893 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
5896 bed
= get_elf_backend_data (dynobj
);
5897 sizeof_dyn
= bed
->s
->sizeof_dyn
;
5898 dyncon
= sdyn
->contents
;
5899 dynconend
= sdyn
->contents
+ sdyn
->size
;
5900 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
5902 Elf_Internal_Dyn dyn
;
5905 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
5913 s
= htab
->elf
.sgotplt
;
5914 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5918 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
5922 s
= htab
->elf
.srelplt
->output_section
;
5923 dyn
.d_un
.d_val
= s
->size
;
5927 /* The procedure linkage table relocs (DT_JMPREL) should
5928 not be included in the overall relocs (DT_RELA).
5929 Therefore, we override the DT_RELASZ entry here to
5930 make it not include the JMPREL relocs. Since the
5931 linker script arranges for .rela.plt to follow all
5932 other relocation sections, we don't have to worry
5933 about changing the DT_RELA entry. */
5934 if (htab
->elf
.srelplt
!= NULL
)
5936 s
= htab
->elf
.srelplt
->output_section
;
5937 dyn
.d_un
.d_val
-= s
->size
;
5941 case DT_TLSDESC_PLT
:
5943 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5944 + htab
->tlsdesc_plt
;
5947 case DT_TLSDESC_GOT
:
5949 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5950 + htab
->tlsdesc_got
;
5954 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
5957 /* Fill in the special first entry in the procedure linkage table. */
5958 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
5960 /* Fill in the first entry in the procedure linkage table. */
5961 memcpy (htab
->elf
.splt
->contents
,
5962 abed
->plt0_entry
, abed
->plt_entry_size
);
5963 /* Add offset for pushq GOT+8(%rip), since the instruction
5964 uses 6 bytes subtract this value. */
5965 bfd_put_32 (output_bfd
,
5966 (htab
->elf
.sgotplt
->output_section
->vma
5967 + htab
->elf
.sgotplt
->output_offset
5969 - htab
->elf
.splt
->output_section
->vma
5970 - htab
->elf
.splt
->output_offset
5972 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
5973 /* Add offset for the PC-relative instruction accessing GOT+16,
5974 subtracting the offset to the end of that instruction. */
5975 bfd_put_32 (output_bfd
,
5976 (htab
->elf
.sgotplt
->output_section
->vma
5977 + htab
->elf
.sgotplt
->output_offset
5979 - htab
->elf
.splt
->output_section
->vma
5980 - htab
->elf
.splt
->output_offset
5981 - abed
->plt0_got2_insn_end
),
5982 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
5984 elf_section_data (htab
->elf
.splt
->output_section
)
5985 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
5987 if (htab
->tlsdesc_plt
)
5989 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5990 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
5992 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
5993 abed
->plt0_entry
, abed
->plt_entry_size
);
5995 /* Add offset for pushq GOT+8(%rip), since the
5996 instruction uses 6 bytes subtract this value. */
5997 bfd_put_32 (output_bfd
,
5998 (htab
->elf
.sgotplt
->output_section
->vma
5999 + htab
->elf
.sgotplt
->output_offset
6001 - htab
->elf
.splt
->output_section
->vma
6002 - htab
->elf
.splt
->output_offset
6005 htab
->elf
.splt
->contents
6006 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
6007 /* Add offset for the PC-relative instruction accessing GOT+TDG,
6008 where TGD stands for htab->tlsdesc_got, subtracting the offset
6009 to the end of that instruction. */
6010 bfd_put_32 (output_bfd
,
6011 (htab
->elf
.sgot
->output_section
->vma
6012 + htab
->elf
.sgot
->output_offset
6014 - htab
->elf
.splt
->output_section
->vma
6015 - htab
->elf
.splt
->output_offset
6017 - abed
->plt0_got2_insn_end
),
6018 htab
->elf
.splt
->contents
6019 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
6024 if (htab
->plt_bnd
!= NULL
)
6025 elf_section_data (htab
->plt_bnd
->output_section
)
6026 ->this_hdr
.sh_entsize
= sizeof (elf_x86_64_bnd_plt2_entry
);
6028 if (htab
->elf
.sgotplt
)
6030 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
6032 (*_bfd_error_handler
)
6033 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
6037 /* Fill in the first three entries in the global offset table. */
6038 if (htab
->elf
.sgotplt
->size
> 0)
6040 /* Set the first entry in the global offset table to the address of
6041 the dynamic section. */
6043 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
6045 bfd_put_64 (output_bfd
,
6046 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
6047 htab
->elf
.sgotplt
->contents
);
6048 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
6049 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
6050 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
6053 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
6057 /* Adjust .eh_frame for .plt section. */
6058 if (htab
->plt_eh_frame
!= NULL
6059 && htab
->plt_eh_frame
->contents
!= NULL
)
6061 if (htab
->elf
.splt
!= NULL
6062 && htab
->elf
.splt
->size
!= 0
6063 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
6064 && htab
->elf
.splt
->output_section
!= NULL
6065 && htab
->plt_eh_frame
->output_section
!= NULL
)
6067 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
6068 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
6069 + htab
->plt_eh_frame
->output_offset
6070 + PLT_FDE_START_OFFSET
;
6071 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6072 htab
->plt_eh_frame
->contents
6073 + PLT_FDE_START_OFFSET
);
6075 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
6077 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6079 htab
->plt_eh_frame
->contents
))
6084 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
6085 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
6088 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
6089 htab_traverse (htab
->loc_hash_table
,
6090 elf_x86_64_finish_local_dynamic_symbol
,
6093 /* Fill PLT entries for undefined weak symbols in PIE. */
6094 if (bfd_link_pie (info
))
6095 bfd_hash_traverse (&info
->hash
->table
,
6096 elf_x86_64_pie_finish_undefweak_symbol
,
6102 /* Return an array of PLT entry symbol values. */
6105 elf_x86_64_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
6108 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
6111 bfd_vma
*plt_sym_val
;
6113 bfd_byte
*plt_contents
;
6114 const struct elf_x86_64_backend_data
*bed
;
6115 Elf_Internal_Shdr
*hdr
;
6118 /* Get the .plt section contents. PLT passed down may point to the
6119 .plt.bnd section. Make sure that PLT always points to the .plt
6121 plt_bnd
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6126 plt
= bfd_get_section_by_name (abfd
, ".plt");
6129 bed
= &elf_x86_64_bnd_arch_bed
;
6132 bed
= get_elf_x86_64_backend_data (abfd
);
6134 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
6135 if (plt_contents
== NULL
)
6137 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
6138 plt_contents
, 0, plt
->size
))
6141 free (plt_contents
);
6145 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
6146 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
6149 hdr
= &elf_section_data (relplt
)->this_hdr
;
6150 count
= relplt
->size
/ hdr
->sh_entsize
;
6152 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
6153 if (plt_sym_val
== NULL
)
6156 for (i
= 0; i
< count
; i
++)
6157 plt_sym_val
[i
] = -1;
6159 plt_offset
= bed
->plt_entry_size
;
6160 p
= relplt
->relocation
;
6161 for (i
= 0; i
< count
; i
++, p
++)
6165 /* Skip unknown relocation. */
6166 if (p
->howto
== NULL
)
6169 if (p
->howto
->type
!= R_X86_64_JUMP_SLOT
6170 && p
->howto
->type
!= R_X86_64_IRELATIVE
)
6173 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
6174 + bed
->plt_reloc_offset
));
6175 if (reloc_index
< count
)
6179 /* This is the index in .plt section. */
6180 long plt_index
= plt_offset
/ bed
->plt_entry_size
;
6181 /* Store VMA + the offset in .plt.bnd section. */
6182 plt_sym_val
[reloc_index
] =
6184 + (plt_index
- 1) * sizeof (elf_x86_64_legacy_plt2_entry
));
6187 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
6189 plt_offset
+= bed
->plt_entry_size
;
6191 /* PR binutils/18437: Skip extra relocations in the .rela.plt
6193 if (plt_offset
>= plt
->size
)
6197 free (plt_contents
);
6202 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
6206 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
6213 /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
6214 as PLT if it exists. */
6215 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6217 plt
= bfd_get_section_by_name (abfd
, ".plt");
6218 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
6219 dynsymcount
, dynsyms
, ret
,
6221 elf_x86_64_get_plt_sym_val
);
6224 /* Handle an x86-64 specific section when reading an object file. This
6225 is called when elfcode.h finds a section with an unknown type. */
6228 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
6229 const char *name
, int shindex
)
6231 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
6234 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
6240 /* Hook called by the linker routine which adds symbols from an object
6241 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
6245 elf_x86_64_add_symbol_hook (bfd
*abfd
,
6246 struct bfd_link_info
*info
,
6247 Elf_Internal_Sym
*sym
,
6248 const char **namep ATTRIBUTE_UNUSED
,
6249 flagword
*flagsp ATTRIBUTE_UNUSED
,
6255 switch (sym
->st_shndx
)
6257 case SHN_X86_64_LCOMMON
:
6258 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
6261 lcomm
= bfd_make_section_with_flags (abfd
,
6265 | SEC_LINKER_CREATED
));
6268 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
6271 *valp
= sym
->st_size
;
6275 if (ELF_ST_BIND (sym
->st_info
) == STB_GNU_UNIQUE
6276 && (abfd
->flags
& DYNAMIC
) == 0
6277 && bfd_get_flavour (info
->output_bfd
) == bfd_target_elf_flavour
)
6278 elf_tdata (info
->output_bfd
)->has_gnu_symbols
6279 |= elf_gnu_symbol_unique
;
6285 /* Given a BFD section, try to locate the corresponding ELF section
6289 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
6290 asection
*sec
, int *index_return
)
6292 if (sec
== &_bfd_elf_large_com_section
)
6294 *index_return
= SHN_X86_64_LCOMMON
;
6300 /* Process a symbol. */
6303 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
6306 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
6308 switch (elfsym
->internal_elf_sym
.st_shndx
)
6310 case SHN_X86_64_LCOMMON
:
6311 asym
->section
= &_bfd_elf_large_com_section
;
6312 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
6313 /* Common symbol doesn't set BSF_GLOBAL. */
6314 asym
->flags
&= ~BSF_GLOBAL
;
6320 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
6322 return (sym
->st_shndx
== SHN_COMMON
6323 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
6327 elf_x86_64_common_section_index (asection
*sec
)
6329 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6332 return SHN_X86_64_LCOMMON
;
6336 elf_x86_64_common_section (asection
*sec
)
6338 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6339 return bfd_com_section_ptr
;
6341 return &_bfd_elf_large_com_section
;
6345 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
6346 const Elf_Internal_Sym
*sym
,
6351 const asection
*oldsec
)
6353 /* A normal common symbol and a large common symbol result in a
6354 normal common symbol. We turn the large common symbol into a
6357 && h
->root
.type
== bfd_link_hash_common
6359 && bfd_is_com_section (*psec
)
6362 if (sym
->st_shndx
== SHN_COMMON
6363 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
6365 h
->root
.u
.c
.p
->section
6366 = bfd_make_section_old_way (oldbfd
, "COMMON");
6367 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
6369 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
6370 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
6371 *psec
= bfd_com_section_ptr
;
6378 elf_x86_64_additional_program_headers (bfd
*abfd
,
6379 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6384 /* Check to see if we need a large readonly segment. */
6385 s
= bfd_get_section_by_name (abfd
, ".lrodata");
6386 if (s
&& (s
->flags
& SEC_LOAD
))
6389 /* Check to see if we need a large data segment. Since .lbss sections
6390 is placed right after the .bss section, there should be no need for
6391 a large data segment just because of .lbss. */
6392 s
= bfd_get_section_by_name (abfd
, ".ldata");
6393 if (s
&& (s
->flags
& SEC_LOAD
))
6399 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6402 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
6404 if (h
->plt
.offset
!= (bfd_vma
) -1
6406 && !h
->pointer_equality_needed
)
6409 return _bfd_elf_hash_symbol (h
);
6412 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
6415 elf_x86_64_relocs_compatible (const bfd_target
*input
,
6416 const bfd_target
*output
)
6418 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
6419 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
6420 && _bfd_elf_relocs_compatible (input
, output
));
6423 static const struct bfd_elf_special_section
6424 elf_x86_64_special_sections
[]=
6426 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6427 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6428 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
6429 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6430 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6431 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6432 { NULL
, 0, 0, 0, 0 }
6435 #define TARGET_LITTLE_SYM x86_64_elf64_vec
6436 #define TARGET_LITTLE_NAME "elf64-x86-64"
6437 #define ELF_ARCH bfd_arch_i386
6438 #define ELF_TARGET_ID X86_64_ELF_DATA
6439 #define ELF_MACHINE_CODE EM_X86_64
6440 #define ELF_MAXPAGESIZE 0x200000
6441 #define ELF_MINPAGESIZE 0x1000
6442 #define ELF_COMMONPAGESIZE 0x1000
6444 #define elf_backend_can_gc_sections 1
6445 #define elf_backend_can_refcount 1
6446 #define elf_backend_want_got_plt 1
6447 #define elf_backend_plt_readonly 1
6448 #define elf_backend_want_plt_sym 0
6449 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
6450 #define elf_backend_rela_normal 1
6451 #define elf_backend_plt_alignment 4
6452 #define elf_backend_extern_protected_data 1
6453 #define elf_backend_caches_rawsize 1
6455 #define elf_info_to_howto elf_x86_64_info_to_howto
6457 #define bfd_elf64_bfd_link_hash_table_create \
6458 elf_x86_64_link_hash_table_create
6459 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
6460 #define bfd_elf64_bfd_reloc_name_lookup \
6461 elf_x86_64_reloc_name_lookup
6463 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
6464 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
6465 #define elf_backend_check_relocs elf_x86_64_check_relocs
6466 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
6467 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
6468 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
6469 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
6470 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
6471 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
6472 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
6474 #define elf_backend_write_core_note elf_x86_64_write_core_note
6476 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
6477 #define elf_backend_relocate_section elf_x86_64_relocate_section
6478 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
6479 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
6480 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
6481 #define elf_backend_object_p elf64_x86_64_elf_object_p
6482 #define bfd_elf64_mkobject elf_x86_64_mkobject
6483 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
6485 #define elf_backend_section_from_shdr \
6486 elf_x86_64_section_from_shdr
6488 #define elf_backend_section_from_bfd_section \
6489 elf_x86_64_elf_section_from_bfd_section
6490 #define elf_backend_add_symbol_hook \
6491 elf_x86_64_add_symbol_hook
6492 #define elf_backend_symbol_processing \
6493 elf_x86_64_symbol_processing
6494 #define elf_backend_common_section_index \
6495 elf_x86_64_common_section_index
6496 #define elf_backend_common_section \
6497 elf_x86_64_common_section
6498 #define elf_backend_common_definition \
6499 elf_x86_64_common_definition
6500 #define elf_backend_merge_symbol \
6501 elf_x86_64_merge_symbol
6502 #define elf_backend_special_sections \
6503 elf_x86_64_special_sections
6504 #define elf_backend_additional_program_headers \
6505 elf_x86_64_additional_program_headers
6506 #define elf_backend_hash_symbol \
6507 elf_x86_64_hash_symbol
6508 #define elf_backend_omit_section_dynsym \
6509 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6510 #define elf_backend_fixup_symbol \
6511 elf_x86_64_fixup_symbol
6513 #include "elf64-target.h"
6515 /* CloudABI support. */
6517 #undef TARGET_LITTLE_SYM
6518 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
6519 #undef TARGET_LITTLE_NAME
6520 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
6523 #define ELF_OSABI ELFOSABI_CLOUDABI
6526 #define elf64_bed elf64_x86_64_cloudabi_bed
6528 #include "elf64-target.h"
6530 /* FreeBSD support. */
6532 #undef TARGET_LITTLE_SYM
6533 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
6534 #undef TARGET_LITTLE_NAME
6535 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
6538 #define ELF_OSABI ELFOSABI_FREEBSD
6541 #define elf64_bed elf64_x86_64_fbsd_bed
6543 #include "elf64-target.h"
6545 /* Solaris 2 support. */
6547 #undef TARGET_LITTLE_SYM
6548 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
6549 #undef TARGET_LITTLE_NAME
6550 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
6552 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6553 objects won't be recognized. */
6557 #define elf64_bed elf64_x86_64_sol2_bed
6559 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
6561 #undef elf_backend_static_tls_alignment
6562 #define elf_backend_static_tls_alignment 16
6564 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6566 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6568 #undef elf_backend_want_plt_sym
6569 #define elf_backend_want_plt_sym 1
6571 #undef elf_backend_strtab_flags
6572 #define elf_backend_strtab_flags SHF_STRINGS
6575 elf64_x86_64_copy_solaris_special_section_fields (const bfd
*ibfd ATTRIBUTE_UNUSED
,
6576 bfd
*obfd ATTRIBUTE_UNUSED
,
6577 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
6578 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
6580 /* PR 19938: FIXME: Need to add code for setting the sh_info
6581 and sh_link fields of Solaris specific section types. */
6585 #undef elf_backend_copy_special_section_fields
6586 #define elf_backend_copy_special_section_fields elf64_x86_64_copy_solaris_special_section_fields
6588 #include "elf64-target.h"
6590 /* Native Client support. */
6593 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
6595 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
6596 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
6600 #undef TARGET_LITTLE_SYM
6601 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
6602 #undef TARGET_LITTLE_NAME
6603 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
6605 #define elf64_bed elf64_x86_64_nacl_bed
6607 #undef ELF_MAXPAGESIZE
6608 #undef ELF_MINPAGESIZE
6609 #undef ELF_COMMONPAGESIZE
6610 #define ELF_MAXPAGESIZE 0x10000
6611 #define ELF_MINPAGESIZE 0x10000
6612 #define ELF_COMMONPAGESIZE 0x10000
6614 /* Restore defaults. */
6616 #undef elf_backend_static_tls_alignment
6617 #undef elf_backend_want_plt_sym
6618 #define elf_backend_want_plt_sym 0
6619 #undef elf_backend_strtab_flags
6620 #undef elf_backend_copy_special_section_fields
6622 /* NaCl uses substantially different PLT entries for the same effects. */
6624 #undef elf_backend_plt_alignment
6625 #define elf_backend_plt_alignment 5
6626 #define NACL_PLT_ENTRY_SIZE 64
6627 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6629 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
6631 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
6632 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
6633 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6634 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6635 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6637 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
6638 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
6640 /* 32 bytes of nop to pad out to the standard size. */
6641 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6642 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6643 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6644 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6645 0x66, /* excess data32 prefix */
6649 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6651 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
6652 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6653 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6654 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6656 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
6657 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6658 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6660 /* Lazy GOT entries point here (32-byte aligned). */
6661 0x68, /* pushq immediate */
6662 0, 0, 0, 0, /* replaced with index into relocation table. */
6663 0xe9, /* jmp relative */
6664 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
6666 /* 22 bytes of nop to pad out to the standard size. */
6667 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6668 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6669 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
6672 /* .eh_frame covering the .plt section. */
6674 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
6676 #if (PLT_CIE_LENGTH != 20 \
6677 || PLT_FDE_LENGTH != 36 \
6678 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6679 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6680 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
6682 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6683 0, 0, 0, 0, /* CIE ID */
6684 1, /* CIE version */
6685 'z', 'R', 0, /* Augmentation string */
6686 1, /* Code alignment factor */
6687 0x78, /* Data alignment factor */
6688 16, /* Return address column */
6689 1, /* Augmentation size */
6690 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6691 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
6692 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
6693 DW_CFA_nop
, DW_CFA_nop
,
6695 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6696 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
6697 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
6698 0, 0, 0, 0, /* .plt size goes here */
6699 0, /* Augmentation size */
6700 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
6701 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6702 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
6703 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6704 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6705 13, /* Block length */
6706 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
6707 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
6708 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6709 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
6710 DW_CFA_nop
, DW_CFA_nop
6713 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
6715 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
6716 elf_x86_64_nacl_plt_entry
, /* plt_entry */
6717 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6718 2, /* plt0_got1_offset */
6719 9, /* plt0_got2_offset */
6720 13, /* plt0_got2_insn_end */
6721 3, /* plt_got_offset */
6722 33, /* plt_reloc_offset */
6723 38, /* plt_plt_offset */
6724 7, /* plt_got_insn_size */
6725 42, /* plt_plt_insn_end */
6726 32, /* plt_lazy_offset */
6727 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
6728 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
6731 #undef elf_backend_arch_data
6732 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
6734 #undef elf_backend_object_p
6735 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
6736 #undef elf_backend_modify_segment_map
6737 #define elf_backend_modify_segment_map nacl_modify_segment_map
6738 #undef elf_backend_modify_program_headers
6739 #define elf_backend_modify_program_headers nacl_modify_program_headers
6740 #undef elf_backend_final_write_processing
6741 #define elf_backend_final_write_processing nacl_final_write_processing
6743 #include "elf64-target.h"
6745 /* Native Client x32 support. */
6748 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
6750 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
6751 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
6755 #undef TARGET_LITTLE_SYM
6756 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
6757 #undef TARGET_LITTLE_NAME
6758 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
6760 #define elf32_bed elf32_x86_64_nacl_bed
6762 #define bfd_elf32_bfd_link_hash_table_create \
6763 elf_x86_64_link_hash_table_create
6764 #define bfd_elf32_bfd_reloc_type_lookup \
6765 elf_x86_64_reloc_type_lookup
6766 #define bfd_elf32_bfd_reloc_name_lookup \
6767 elf_x86_64_reloc_name_lookup
6768 #define bfd_elf32_mkobject \
6770 #define bfd_elf32_get_synthetic_symtab \
6771 elf_x86_64_get_synthetic_symtab
6773 #undef elf_backend_object_p
6774 #define elf_backend_object_p \
6775 elf32_x86_64_nacl_elf_object_p
6777 #undef elf_backend_bfd_from_remote_memory
6778 #define elf_backend_bfd_from_remote_memory \
6779 _bfd_elf32_bfd_from_remote_memory
6781 #undef elf_backend_size_info
6782 #define elf_backend_size_info \
6783 _bfd_elf32_size_info
6785 #include "elf32-target.h"
6787 /* Restore defaults. */
6788 #undef elf_backend_object_p
6789 #define elf_backend_object_p elf64_x86_64_elf_object_p
6790 #undef elf_backend_bfd_from_remote_memory
6791 #undef elf_backend_size_info
6792 #undef elf_backend_modify_segment_map
6793 #undef elf_backend_modify_program_headers
6794 #undef elf_backend_final_write_processing
6796 /* Intel L1OM support. */
6799 elf64_l1om_elf_object_p (bfd
*abfd
)
6801 /* Set the right machine number for an L1OM elf64 file. */
6802 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
6806 #undef TARGET_LITTLE_SYM
6807 #define TARGET_LITTLE_SYM l1om_elf64_vec
6808 #undef TARGET_LITTLE_NAME
6809 #define TARGET_LITTLE_NAME "elf64-l1om"
6811 #define ELF_ARCH bfd_arch_l1om
6813 #undef ELF_MACHINE_CODE
6814 #define ELF_MACHINE_CODE EM_L1OM
6819 #define elf64_bed elf64_l1om_bed
6821 #undef elf_backend_object_p
6822 #define elf_backend_object_p elf64_l1om_elf_object_p
6824 /* Restore defaults. */
6825 #undef ELF_MAXPAGESIZE
6826 #undef ELF_MINPAGESIZE
6827 #undef ELF_COMMONPAGESIZE
6828 #define ELF_MAXPAGESIZE 0x200000
6829 #define ELF_MINPAGESIZE 0x1000
6830 #define ELF_COMMONPAGESIZE 0x1000
6831 #undef elf_backend_plt_alignment
6832 #define elf_backend_plt_alignment 4
6833 #undef elf_backend_arch_data
6834 #define elf_backend_arch_data &elf_x86_64_arch_bed
6836 #include "elf64-target.h"
6838 /* FreeBSD L1OM support. */
6840 #undef TARGET_LITTLE_SYM
6841 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
6842 #undef TARGET_LITTLE_NAME
6843 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
6846 #define ELF_OSABI ELFOSABI_FREEBSD
6849 #define elf64_bed elf64_l1om_fbsd_bed
6851 #include "elf64-target.h"
6853 /* Intel K1OM support. */
6856 elf64_k1om_elf_object_p (bfd
*abfd
)
6858 /* Set the right machine number for an K1OM elf64 file. */
6859 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
6863 #undef TARGET_LITTLE_SYM
6864 #define TARGET_LITTLE_SYM k1om_elf64_vec
6865 #undef TARGET_LITTLE_NAME
6866 #define TARGET_LITTLE_NAME "elf64-k1om"
6868 #define ELF_ARCH bfd_arch_k1om
6870 #undef ELF_MACHINE_CODE
6871 #define ELF_MACHINE_CODE EM_K1OM
6876 #define elf64_bed elf64_k1om_bed
6878 #undef elf_backend_object_p
6879 #define elf_backend_object_p elf64_k1om_elf_object_p
6881 #undef elf_backend_static_tls_alignment
6883 #undef elf_backend_want_plt_sym
6884 #define elf_backend_want_plt_sym 0
6886 #include "elf64-target.h"
6888 /* FreeBSD K1OM support. */
6890 #undef TARGET_LITTLE_SYM
6891 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
6892 #undef TARGET_LITTLE_NAME
6893 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
6896 #define ELF_OSABI ELFOSABI_FREEBSD
6899 #define elf64_bed elf64_k1om_fbsd_bed
6901 #include "elf64-target.h"
6903 /* 32bit x86-64 support. */
6905 #undef TARGET_LITTLE_SYM
6906 #define TARGET_LITTLE_SYM x86_64_elf32_vec
6907 #undef TARGET_LITTLE_NAME
6908 #define TARGET_LITTLE_NAME "elf32-x86-64"
6912 #define ELF_ARCH bfd_arch_i386
6914 #undef ELF_MACHINE_CODE
6915 #define ELF_MACHINE_CODE EM_X86_64
6919 #undef elf_backend_object_p
6920 #define elf_backend_object_p \
6921 elf32_x86_64_elf_object_p
6923 #undef elf_backend_bfd_from_remote_memory
6924 #define elf_backend_bfd_from_remote_memory \
6925 _bfd_elf32_bfd_from_remote_memory
6927 #undef elf_backend_size_info
6928 #define elf_backend_size_info \
6929 _bfd_elf32_size_info
6931 #include "elf32-target.h"