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, EH) \
752 ((EH)->elf.root.type == bfd_link_hash_undefweak \
753 && bfd_link_executable (INFO) \
754 && (elf_x86_64_hash_table (INFO)->interp == NULL \
755 || !(EH)->has_got_reloc \
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 htab
->sdynbss
= bfd_get_linker_section (dynobj
, ".dynbss");
1116 if (bfd_link_executable (info
))
1118 /* Always allow copy relocs for building executables. */
1119 asection
*s
= bfd_get_linker_section (dynobj
, ".rela.bss");
1122 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
1123 s
= bfd_make_section_anyway_with_flags (dynobj
,
1125 (bed
->dynamic_sec_flags
1128 || ! bfd_set_section_alignment (dynobj
, s
,
1129 bed
->s
->log_file_align
))
1135 if (!info
->no_ld_generated_unwind_info
1136 && htab
->plt_eh_frame
== NULL
1137 && htab
->elf
.splt
!= NULL
)
1139 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1140 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1141 | SEC_LINKER_CREATED
);
1143 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
1144 if (htab
->plt_eh_frame
== NULL
1145 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 3))
1151 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1154 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
1155 struct elf_link_hash_entry
*dir
,
1156 struct elf_link_hash_entry
*ind
)
1158 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
1160 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
1161 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
1163 if (!edir
->has_bnd_reloc
)
1164 edir
->has_bnd_reloc
= eind
->has_bnd_reloc
;
1166 if (!edir
->has_got_reloc
)
1167 edir
->has_got_reloc
= eind
->has_got_reloc
;
1169 if (!edir
->has_non_got_reloc
)
1170 edir
->has_non_got_reloc
= eind
->has_non_got_reloc
;
1172 if (eind
->dyn_relocs
!= NULL
)
1174 if (edir
->dyn_relocs
!= NULL
)
1176 struct elf_dyn_relocs
**pp
;
1177 struct elf_dyn_relocs
*p
;
1179 /* Add reloc counts against the indirect sym to the direct sym
1180 list. Merge any entries against the same section. */
1181 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1183 struct elf_dyn_relocs
*q
;
1185 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1186 if (q
->sec
== p
->sec
)
1188 q
->pc_count
+= p
->pc_count
;
1189 q
->count
+= p
->count
;
1196 *pp
= edir
->dyn_relocs
;
1199 edir
->dyn_relocs
= eind
->dyn_relocs
;
1200 eind
->dyn_relocs
= NULL
;
1203 if (ind
->root
.type
== bfd_link_hash_indirect
1204 && dir
->got
.refcount
<= 0)
1206 edir
->tls_type
= eind
->tls_type
;
1207 eind
->tls_type
= GOT_UNKNOWN
;
1210 if (ELIMINATE_COPY_RELOCS
1211 && ind
->root
.type
!= bfd_link_hash_indirect
1212 && dir
->dynamic_adjusted
)
1214 /* If called to transfer flags for a weakdef during processing
1215 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1216 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1217 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1218 dir
->ref_regular
|= ind
->ref_regular
;
1219 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1220 dir
->needs_plt
|= ind
->needs_plt
;
1221 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1225 if (eind
->func_pointer_refcount
> 0)
1227 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1228 eind
->func_pointer_refcount
= 0;
1231 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1236 elf64_x86_64_elf_object_p (bfd
*abfd
)
1238 /* Set the right machine number for an x86-64 elf64 file. */
1239 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
1244 elf32_x86_64_elf_object_p (bfd
*abfd
)
1246 /* Set the right machine number for an x86-64 elf32 file. */
1247 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
1251 /* Return TRUE if the TLS access code sequence support transition
1255 elf_x86_64_check_tls_transition (bfd
*abfd
,
1256 struct bfd_link_info
*info
,
1259 Elf_Internal_Shdr
*symtab_hdr
,
1260 struct elf_link_hash_entry
**sym_hashes
,
1261 unsigned int r_type
,
1262 const Elf_Internal_Rela
*rel
,
1263 const Elf_Internal_Rela
*relend
)
1266 unsigned long r_symndx
;
1267 bfd_boolean largepic
= FALSE
;
1268 struct elf_link_hash_entry
*h
;
1270 struct elf_x86_64_link_hash_table
*htab
;
1272 /* Get the section contents. */
1273 if (contents
== NULL
)
1275 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1276 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1279 /* FIXME: How to better handle error condition? */
1280 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1283 /* Cache the section contents for elf_link_input_bfd. */
1284 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1288 htab
= elf_x86_64_hash_table (info
);
1289 offset
= rel
->r_offset
;
1292 case R_X86_64_TLSGD
:
1293 case R_X86_64_TLSLD
:
1294 if ((rel
+ 1) >= relend
)
1297 if (r_type
== R_X86_64_TLSGD
)
1299 /* Check transition from GD access model. For 64bit, only
1300 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1301 .word 0x6666; rex64; call __tls_get_addr
1302 can transit to different access model. For 32bit, only
1303 leaq foo@tlsgd(%rip), %rdi
1304 .word 0x6666; rex64; call __tls_get_addr
1305 can transit to different access model. For largepic
1307 leaq foo@tlsgd(%rip), %rdi
1308 movabsq $__tls_get_addr@pltoff, %rax
1312 static const unsigned char call
[] = { 0x66, 0x66, 0x48, 0xe8 };
1313 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1315 if ((offset
+ 12) > sec
->size
)
1318 if (memcmp (contents
+ offset
+ 4, call
, 4) != 0)
1320 if (!ABI_64_P (abfd
)
1321 || (offset
+ 19) > sec
->size
1323 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0
1324 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1325 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1330 else if (ABI_64_P (abfd
))
1333 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1339 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1345 /* Check transition from LD access model. Only
1346 leaq foo@tlsld(%rip), %rdi;
1348 can transit to different access model. For largepic
1350 leaq foo@tlsld(%rip), %rdi
1351 movabsq $__tls_get_addr@pltoff, %rax
1355 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1357 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1360 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0)
1363 if (0xe8 != *(contents
+ offset
+ 4))
1365 if (!ABI_64_P (abfd
)
1366 || (offset
+ 19) > sec
->size
1367 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1368 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1375 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1376 if (r_symndx
< symtab_hdr
->sh_info
)
1379 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1380 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1381 may be versioned. */
1383 && h
->root
.root
.string
!= NULL
1385 ? ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLTOFF64
1386 : (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1387 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
))
1388 && (strncmp (h
->root
.root
.string
,
1389 "__tls_get_addr", 14) == 0));
1391 case R_X86_64_GOTTPOFF
:
1392 /* Check transition from IE access model:
1393 mov foo@gottpoff(%rip), %reg
1394 add foo@gottpoff(%rip), %reg
1397 /* Check REX prefix first. */
1398 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1400 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1401 if (val
!= 0x48 && val
!= 0x4c)
1403 /* X32 may have 0x44 REX prefix or no REX prefix. */
1404 if (ABI_64_P (abfd
))
1410 /* X32 may not have any REX prefix. */
1411 if (ABI_64_P (abfd
))
1413 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1417 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1418 if (val
!= 0x8b && val
!= 0x03)
1421 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1422 return (val
& 0xc7) == 5;
1424 case R_X86_64_GOTPC32_TLSDESC
:
1425 /* Check transition from GDesc access model:
1426 leaq x@tlsdesc(%rip), %rax
1428 Make sure it's a leaq adding rip to a 32-bit offset
1429 into any register, although it's probably almost always
1432 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1435 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1436 if ((val
& 0xfb) != 0x48)
1439 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1442 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1443 return (val
& 0xc7) == 0x05;
1445 case R_X86_64_TLSDESC_CALL
:
1446 /* Check transition from GDesc access model:
1447 call *x@tlsdesc(%rax)
1449 if (offset
+ 2 <= sec
->size
)
1451 /* Make sure that it's a call *x@tlsdesc(%rax). */
1452 static const unsigned char call
[] = { 0xff, 0x10 };
1453 return memcmp (contents
+ offset
, call
, 2) == 0;
1463 /* Return TRUE if the TLS access transition is OK or no transition
1464 will be performed. Update R_TYPE if there is a transition. */
1467 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1468 asection
*sec
, bfd_byte
*contents
,
1469 Elf_Internal_Shdr
*symtab_hdr
,
1470 struct elf_link_hash_entry
**sym_hashes
,
1471 unsigned int *r_type
, int tls_type
,
1472 const Elf_Internal_Rela
*rel
,
1473 const Elf_Internal_Rela
*relend
,
1474 struct elf_link_hash_entry
*h
,
1475 unsigned long r_symndx
)
1477 unsigned int from_type
= *r_type
;
1478 unsigned int to_type
= from_type
;
1479 bfd_boolean check
= TRUE
;
1481 /* Skip TLS transition for functions. */
1483 && (h
->type
== STT_FUNC
1484 || h
->type
== STT_GNU_IFUNC
))
1489 case R_X86_64_TLSGD
:
1490 case R_X86_64_GOTPC32_TLSDESC
:
1491 case R_X86_64_TLSDESC_CALL
:
1492 case R_X86_64_GOTTPOFF
:
1493 if (bfd_link_executable (info
))
1496 to_type
= R_X86_64_TPOFF32
;
1498 to_type
= R_X86_64_GOTTPOFF
;
1501 /* When we are called from elf_x86_64_relocate_section,
1502 CONTENTS isn't NULL and there may be additional transitions
1503 based on TLS_TYPE. */
1504 if (contents
!= NULL
)
1506 unsigned int new_to_type
= to_type
;
1508 if (bfd_link_executable (info
)
1511 && tls_type
== GOT_TLS_IE
)
1512 new_to_type
= R_X86_64_TPOFF32
;
1514 if (to_type
== R_X86_64_TLSGD
1515 || to_type
== R_X86_64_GOTPC32_TLSDESC
1516 || to_type
== R_X86_64_TLSDESC_CALL
)
1518 if (tls_type
== GOT_TLS_IE
)
1519 new_to_type
= R_X86_64_GOTTPOFF
;
1522 /* We checked the transition before when we were called from
1523 elf_x86_64_check_relocs. We only want to check the new
1524 transition which hasn't been checked before. */
1525 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1526 to_type
= new_to_type
;
1531 case R_X86_64_TLSLD
:
1532 if (bfd_link_executable (info
))
1533 to_type
= R_X86_64_TPOFF32
;
1540 /* Return TRUE if there is no transition. */
1541 if (from_type
== to_type
)
1544 /* Check if the transition can be performed. */
1546 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1547 symtab_hdr
, sym_hashes
,
1548 from_type
, rel
, relend
))
1550 reloc_howto_type
*from
, *to
;
1553 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1554 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1557 name
= h
->root
.root
.string
;
1560 struct elf_x86_64_link_hash_table
*htab
;
1562 htab
= elf_x86_64_hash_table (info
);
1567 Elf_Internal_Sym
*isym
;
1569 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1571 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1575 (*_bfd_error_handler
)
1576 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1577 "in section `%A' failed"),
1578 abfd
, sec
, from
->name
, to
->name
, name
,
1579 (unsigned long) rel
->r_offset
);
1580 bfd_set_error (bfd_error_bad_value
);
1588 /* Rename some of the generic section flags to better document how they
1590 #define need_convert_load sec_flg0
1591 #define check_relocs_failed sec_flg1
1594 elf_x86_64_need_pic (bfd
*input_bfd
, asection
*sec
,
1595 struct elf_link_hash_entry
*h
,
1596 Elf_Internal_Shdr
*symtab_hdr
,
1597 Elf_Internal_Sym
*isym
,
1598 reloc_howto_type
*howto
)
1601 const char *und
= "";
1602 const char *pic
= "";
1607 name
= h
->root
.root
.string
;
1608 switch (ELF_ST_VISIBILITY (h
->other
))
1611 v
= _("hidden symbol ");
1614 v
= _("internal symbol ");
1617 v
= _("protected symbol ");
1621 pic
= _("; recompile with -fPIC");
1625 if (!h
->def_regular
&& !h
->def_dynamic
)
1626 und
= _("undefined ");
1630 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, isym
, NULL
);
1631 pic
= _("; recompile with -fPIC");
1634 (*_bfd_error_handler
) (_("%B: relocation %s against %s%s`%s' can "
1635 "not be used when making a shared object%s"),
1636 input_bfd
, howto
->name
, und
, v
, name
, pic
);
1637 bfd_set_error (bfd_error_bad_value
);
1638 sec
->check_relocs_failed
= 1;
1642 /* Look through the relocs for a section during the first phase, and
1643 calculate needed space in the global offset table, procedure
1644 linkage table, and dynamic reloc sections. */
1647 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1649 const Elf_Internal_Rela
*relocs
)
1651 struct elf_x86_64_link_hash_table
*htab
;
1652 Elf_Internal_Shdr
*symtab_hdr
;
1653 struct elf_link_hash_entry
**sym_hashes
;
1654 const Elf_Internal_Rela
*rel
;
1655 const Elf_Internal_Rela
*rel_end
;
1657 bfd_boolean use_plt_got
;
1659 if (bfd_link_relocatable (info
))
1662 BFD_ASSERT (is_x86_64_elf (abfd
));
1664 htab
= elf_x86_64_hash_table (info
);
1667 sec
->check_relocs_failed
= 1;
1671 use_plt_got
= get_elf_x86_64_backend_data (abfd
) == &elf_x86_64_arch_bed
;
1673 symtab_hdr
= &elf_symtab_hdr (abfd
);
1674 sym_hashes
= elf_sym_hashes (abfd
);
1678 rel_end
= relocs
+ sec
->reloc_count
;
1679 for (rel
= relocs
; rel
< rel_end
; rel
++)
1681 unsigned int r_type
;
1682 unsigned long r_symndx
;
1683 struct elf_link_hash_entry
*h
;
1684 struct elf_x86_64_link_hash_entry
*eh
;
1685 Elf_Internal_Sym
*isym
;
1687 bfd_boolean size_reloc
;
1689 r_symndx
= htab
->r_sym (rel
->r_info
);
1690 r_type
= ELF32_R_TYPE (rel
->r_info
);
1692 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1694 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1699 if (r_symndx
< symtab_hdr
->sh_info
)
1701 /* A local symbol. */
1702 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1707 /* Check relocation against local STT_GNU_IFUNC symbol. */
1708 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1710 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
1715 /* Fake a STT_GNU_IFUNC symbol. */
1716 h
->type
= STT_GNU_IFUNC
;
1719 h
->forced_local
= 1;
1720 h
->root
.type
= bfd_link_hash_defined
;
1728 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1729 while (h
->root
.type
== bfd_link_hash_indirect
1730 || h
->root
.type
== bfd_link_hash_warning
)
1731 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1734 /* Check invalid x32 relocations. */
1735 if (!ABI_64_P (abfd
))
1741 case R_X86_64_DTPOFF64
:
1742 case R_X86_64_TPOFF64
:
1744 case R_X86_64_GOTOFF64
:
1745 case R_X86_64_GOT64
:
1746 case R_X86_64_GOTPCREL64
:
1747 case R_X86_64_GOTPC64
:
1748 case R_X86_64_GOTPLT64
:
1749 case R_X86_64_PLTOFF64
:
1752 name
= h
->root
.root
.string
;
1754 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1756 (*_bfd_error_handler
)
1757 (_("%B: relocation %s against symbol `%s' isn't "
1758 "supported in x32 mode"), abfd
,
1759 x86_64_elf_howto_table
[r_type
].name
, name
);
1760 bfd_set_error (bfd_error_bad_value
);
1773 case R_X86_64_PC32_BND
:
1774 case R_X86_64_PLT32_BND
:
1776 case R_X86_64_PLT32
:
1779 /* MPX PLT is supported only if elf_x86_64_arch_bed
1780 is used in 64-bit mode. */
1783 && (get_elf_x86_64_backend_data (abfd
)
1784 == &elf_x86_64_arch_bed
))
1786 elf_x86_64_hash_entry (h
)->has_bnd_reloc
= 1;
1788 /* Create the second PLT for Intel MPX support. */
1789 if (htab
->plt_bnd
== NULL
)
1791 unsigned int plt_bnd_align
;
1792 const struct elf_backend_data
*bed
;
1794 bed
= get_elf_backend_data (info
->output_bfd
);
1795 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry
) == 8
1796 && (sizeof (elf_x86_64_bnd_plt2_entry
)
1797 == sizeof (elf_x86_64_legacy_plt2_entry
)));
1800 if (htab
->elf
.dynobj
== NULL
)
1801 htab
->elf
.dynobj
= abfd
;
1803 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
1805 (bed
->dynamic_sec_flags
1810 if (htab
->plt_bnd
== NULL
1811 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
1820 case R_X86_64_GOTPCREL
:
1821 case R_X86_64_GOTPCRELX
:
1822 case R_X86_64_REX_GOTPCRELX
:
1823 case R_X86_64_GOTPCREL64
:
1824 if (htab
->elf
.dynobj
== NULL
)
1825 htab
->elf
.dynobj
= abfd
;
1826 /* Create the ifunc sections for static executables. */
1827 if (h
->type
== STT_GNU_IFUNC
1828 && !_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
,
1834 /* It is referenced by a non-shared object. */
1836 h
->root
.non_ir_ref
= 1;
1838 if (h
->type
== STT_GNU_IFUNC
)
1839 elf_tdata (info
->output_bfd
)->has_gnu_symbols
1840 |= elf_gnu_symbol_ifunc
;
1843 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
1844 symtab_hdr
, sym_hashes
,
1845 &r_type
, GOT_UNKNOWN
,
1846 rel
, rel_end
, h
, r_symndx
))
1849 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
1852 case R_X86_64_TLSLD
:
1853 htab
->tls_ld_got
.refcount
+= 1;
1856 case R_X86_64_TPOFF32
:
1857 if (!bfd_link_executable (info
) && ABI_64_P (abfd
))
1858 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
1859 &x86_64_elf_howto_table
[r_type
]);
1861 eh
->has_got_reloc
= 1;
1864 case R_X86_64_GOTTPOFF
:
1865 if (!bfd_link_executable (info
))
1866 info
->flags
|= DF_STATIC_TLS
;
1869 case R_X86_64_GOT32
:
1870 case R_X86_64_GOTPCREL
:
1871 case R_X86_64_GOTPCRELX
:
1872 case R_X86_64_REX_GOTPCRELX
:
1873 case R_X86_64_TLSGD
:
1874 case R_X86_64_GOT64
:
1875 case R_X86_64_GOTPCREL64
:
1876 case R_X86_64_GOTPLT64
:
1877 case R_X86_64_GOTPC32_TLSDESC
:
1878 case R_X86_64_TLSDESC_CALL
:
1879 /* This symbol requires a global offset table entry. */
1881 int tls_type
, old_tls_type
;
1885 default: tls_type
= GOT_NORMAL
; break;
1886 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
1887 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
1888 case R_X86_64_GOTPC32_TLSDESC
:
1889 case R_X86_64_TLSDESC_CALL
:
1890 tls_type
= GOT_TLS_GDESC
; break;
1895 h
->got
.refcount
+= 1;
1896 old_tls_type
= eh
->tls_type
;
1900 bfd_signed_vma
*local_got_refcounts
;
1902 /* This is a global offset table entry for a local symbol. */
1903 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1904 if (local_got_refcounts
== NULL
)
1908 size
= symtab_hdr
->sh_info
;
1909 size
*= sizeof (bfd_signed_vma
)
1910 + sizeof (bfd_vma
) + sizeof (char);
1911 local_got_refcounts
= ((bfd_signed_vma
*)
1912 bfd_zalloc (abfd
, size
));
1913 if (local_got_refcounts
== NULL
)
1915 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1916 elf_x86_64_local_tlsdesc_gotent (abfd
)
1917 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1918 elf_x86_64_local_got_tls_type (abfd
)
1919 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1921 local_got_refcounts
[r_symndx
] += 1;
1923 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
1926 /* If a TLS symbol is accessed using IE at least once,
1927 there is no point to use dynamic model for it. */
1928 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1929 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1930 || tls_type
!= GOT_TLS_IE
))
1932 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
1933 tls_type
= old_tls_type
;
1934 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1935 && GOT_TLS_GD_ANY_P (tls_type
))
1936 tls_type
|= old_tls_type
;
1940 name
= h
->root
.root
.string
;
1942 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
1944 (*_bfd_error_handler
)
1945 (_("%B: '%s' accessed both as normal and thread local symbol"),
1947 bfd_set_error (bfd_error_bad_value
);
1952 if (old_tls_type
!= tls_type
)
1955 eh
->tls_type
= tls_type
;
1957 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1962 case R_X86_64_GOTOFF64
:
1963 case R_X86_64_GOTPC32
:
1964 case R_X86_64_GOTPC64
:
1967 eh
->has_got_reloc
= 1;
1968 if (htab
->elf
.sgot
== NULL
)
1970 if (htab
->elf
.dynobj
== NULL
)
1971 htab
->elf
.dynobj
= abfd
;
1972 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
1978 case R_X86_64_PLT32
:
1979 case R_X86_64_PLT32_BND
:
1980 /* This symbol requires a procedure linkage table entry. We
1981 actually build the entry in adjust_dynamic_symbol,
1982 because this might be a case of linking PIC code which is
1983 never referenced by a dynamic object, in which case we
1984 don't need to generate a procedure linkage table entry
1987 /* If this is a local symbol, we resolve it directly without
1988 creating a procedure linkage table entry. */
1992 eh
->has_got_reloc
= 1;
1994 h
->plt
.refcount
+= 1;
1997 case R_X86_64_PLTOFF64
:
1998 /* This tries to form the 'address' of a function relative
1999 to GOT. For global symbols we need a PLT entry. */
2003 h
->plt
.refcount
+= 1;
2007 case R_X86_64_SIZE32
:
2008 case R_X86_64_SIZE64
:
2013 if (!ABI_64_P (abfd
))
2018 /* Check relocation overflow as these relocs may lead to
2019 run-time relocation overflow. Don't error out for
2020 sections we don't care about, such as debug sections or
2021 when relocation overflow check is disabled. */
2022 if (!info
->no_reloc_overflow_check
2023 && (bfd_link_pic (info
)
2024 || (bfd_link_executable (info
)
2028 && (sec
->flags
& SEC_READONLY
) == 0))
2029 && (sec
->flags
& SEC_ALLOC
) != 0)
2030 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
2031 &x86_64_elf_howto_table
[r_type
]);
2037 case R_X86_64_PC32_BND
:
2041 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2042 eh
->has_non_got_reloc
= 1;
2043 /* STT_GNU_IFUNC symbol must go through PLT even if it is
2044 locally defined and undefined symbol may turn out to be
2045 a STT_GNU_IFUNC symbol later. */
2047 && (bfd_link_executable (info
)
2048 || ((h
->type
== STT_GNU_IFUNC
2049 || h
->root
.type
== bfd_link_hash_undefweak
2050 || h
->root
.type
== bfd_link_hash_undefined
)
2051 && SYMBOLIC_BIND (info
, h
))))
2053 /* If this reloc is in a read-only section, we might
2054 need a copy reloc. We can't check reliably at this
2055 stage whether the section is read-only, as input
2056 sections have not yet been mapped to output sections.
2057 Tentatively set the flag for now, and correct in
2058 adjust_dynamic_symbol. */
2061 /* We may need a .plt entry if the function this reloc
2062 refers to is in a shared lib. */
2063 h
->plt
.refcount
+= 1;
2064 if (r_type
== R_X86_64_PC32
)
2066 /* Since something like ".long foo - ." may be used
2067 as pointer, make sure that PLT is used if foo is
2068 a function defined in a shared library. */
2069 if ((sec
->flags
& SEC_CODE
) == 0)
2070 h
->pointer_equality_needed
= 1;
2072 else if (r_type
!= R_X86_64_PC32_BND
2073 && r_type
!= R_X86_64_PC64
)
2075 h
->pointer_equality_needed
= 1;
2076 /* At run-time, R_X86_64_64 can be resolved for both
2077 x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2078 can only be resolved for x32. */
2079 if ((sec
->flags
& SEC_READONLY
) == 0
2080 && (r_type
== R_X86_64_64
2081 || (!ABI_64_P (abfd
)
2082 && (r_type
== R_X86_64_32
2083 || r_type
== R_X86_64_32S
))))
2084 eh
->func_pointer_refcount
+= 1;
2090 /* If we are creating a shared library, and this is a reloc
2091 against a global symbol, or a non PC relative reloc
2092 against a local symbol, then we need to copy the reloc
2093 into the shared library. However, if we are linking with
2094 -Bsymbolic, we do not need to copy a reloc against a
2095 global symbol which is defined in an object we are
2096 including in the link (i.e., DEF_REGULAR is set). At
2097 this point we have not seen all the input files, so it is
2098 possible that DEF_REGULAR is not set now but will be set
2099 later (it is never cleared). In case of a weak definition,
2100 DEF_REGULAR may be cleared later by a strong definition in
2101 a shared library. We account for that possibility below by
2102 storing information in the relocs_copied field of the hash
2103 table entry. A similar situation occurs when creating
2104 shared libraries and symbol visibility changes render the
2107 If on the other hand, we are creating an executable, we
2108 may need to keep relocations for symbols satisfied by a
2109 dynamic library if we manage to avoid copy relocs for the
2111 if ((bfd_link_pic (info
)
2112 && (sec
->flags
& SEC_ALLOC
) != 0
2113 && (! IS_X86_64_PCREL_TYPE (r_type
)
2115 && (! (bfd_link_pie (info
)
2116 || SYMBOLIC_BIND (info
, h
))
2117 || h
->root
.type
== bfd_link_hash_defweak
2118 || !h
->def_regular
))))
2119 || (ELIMINATE_COPY_RELOCS
2120 && !bfd_link_pic (info
)
2121 && (sec
->flags
& SEC_ALLOC
) != 0
2123 && (h
->root
.type
== bfd_link_hash_defweak
2124 || !h
->def_regular
)))
2126 struct elf_dyn_relocs
*p
;
2127 struct elf_dyn_relocs
**head
;
2129 /* We must copy these reloc types into the output file.
2130 Create a reloc section in dynobj and make room for
2134 if (htab
->elf
.dynobj
== NULL
)
2135 htab
->elf
.dynobj
= abfd
;
2137 sreloc
= _bfd_elf_make_dynamic_reloc_section
2138 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
2139 abfd
, /*rela?*/ TRUE
);
2145 /* If this is a global symbol, we count the number of
2146 relocations we need for this symbol. */
2148 head
= &eh
->dyn_relocs
;
2151 /* Track dynamic relocs needed for local syms too.
2152 We really need local syms available to do this
2157 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2162 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2166 /* Beware of type punned pointers vs strict aliasing
2168 vpp
= &(elf_section_data (s
)->local_dynrel
);
2169 head
= (struct elf_dyn_relocs
**)vpp
;
2173 if (p
== NULL
|| p
->sec
!= sec
)
2175 bfd_size_type amt
= sizeof *p
;
2177 p
= ((struct elf_dyn_relocs
*)
2178 bfd_alloc (htab
->elf
.dynobj
, amt
));
2189 /* Count size relocation as PC-relative relocation. */
2190 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
2195 /* This relocation describes the C++ object vtable hierarchy.
2196 Reconstruct it for later use during GC. */
2197 case R_X86_64_GNU_VTINHERIT
:
2198 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2202 /* This relocation describes which C++ vtable entries are actually
2203 used. Record for later use during GC. */
2204 case R_X86_64_GNU_VTENTRY
:
2205 BFD_ASSERT (h
!= NULL
);
2207 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2217 && h
->plt
.refcount
> 0
2218 && (((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2219 || h
->got
.refcount
> 0)
2220 && htab
->plt_got
== NULL
)
2222 /* Create the GOT procedure linkage table. */
2223 unsigned int plt_got_align
;
2224 const struct elf_backend_data
*bed
;
2226 bed
= get_elf_backend_data (info
->output_bfd
);
2227 BFD_ASSERT (sizeof (elf_x86_64_legacy_plt2_entry
) == 8
2228 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2229 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2232 if (htab
->elf
.dynobj
== NULL
)
2233 htab
->elf
.dynobj
= abfd
;
2235 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2237 (bed
->dynamic_sec_flags
2242 if (htab
->plt_got
== NULL
2243 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2249 if ((r_type
== R_X86_64_GOTPCREL
2250 || r_type
== R_X86_64_GOTPCRELX
2251 || r_type
== R_X86_64_REX_GOTPCRELX
)
2252 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2253 sec
->need_convert_load
= 1;
2259 sec
->check_relocs_failed
= 1;
2263 /* Return the section that should be marked against GC for a given
2267 elf_x86_64_gc_mark_hook (asection
*sec
,
2268 struct bfd_link_info
*info
,
2269 Elf_Internal_Rela
*rel
,
2270 struct elf_link_hash_entry
*h
,
2271 Elf_Internal_Sym
*sym
)
2274 switch (ELF32_R_TYPE (rel
->r_info
))
2276 case R_X86_64_GNU_VTINHERIT
:
2277 case R_X86_64_GNU_VTENTRY
:
2281 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2284 /* Remove undefined weak symbol from the dynamic symbol table if it
2285 is resolved to 0. */
2288 elf_x86_64_fixup_symbol (struct bfd_link_info
*info
,
2289 struct elf_link_hash_entry
*h
)
2291 if (h
->dynindx
!= -1
2292 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2293 elf_x86_64_hash_entry (h
)))
2296 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2302 /* Adjust a symbol defined by a dynamic object and referenced by a
2303 regular object. The current definition is in some section of the
2304 dynamic object, but we're not including those sections. We have to
2305 change the definition to something the rest of the link can
2309 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2310 struct elf_link_hash_entry
*h
)
2312 struct elf_x86_64_link_hash_table
*htab
;
2314 struct elf_x86_64_link_hash_entry
*eh
;
2315 struct elf_dyn_relocs
*p
;
2317 /* STT_GNU_IFUNC symbol must go through PLT. */
2318 if (h
->type
== STT_GNU_IFUNC
)
2320 /* All local STT_GNU_IFUNC references must be treate as local
2321 calls via local PLT. */
2323 && SYMBOL_CALLS_LOCAL (info
, h
))
2325 bfd_size_type pc_count
= 0, count
= 0;
2326 struct elf_dyn_relocs
**pp
;
2328 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2329 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2331 pc_count
+= p
->pc_count
;
2332 p
->count
-= p
->pc_count
;
2341 if (pc_count
|| count
)
2345 if (h
->plt
.refcount
<= 0)
2346 h
->plt
.refcount
= 1;
2348 h
->plt
.refcount
+= 1;
2352 if (h
->plt
.refcount
<= 0)
2354 h
->plt
.offset
= (bfd_vma
) -1;
2360 /* If this is a function, put it in the procedure linkage table. We
2361 will fill in the contents of the procedure linkage table later,
2362 when we know the address of the .got section. */
2363 if (h
->type
== STT_FUNC
2366 if (h
->plt
.refcount
<= 0
2367 || SYMBOL_CALLS_LOCAL (info
, h
)
2368 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2369 && h
->root
.type
== bfd_link_hash_undefweak
))
2371 /* This case can occur if we saw a PLT32 reloc in an input
2372 file, but the symbol was never referred to by a dynamic
2373 object, or if all references were garbage collected. In
2374 such a case, we don't actually need to build a procedure
2375 linkage table, and we can just do a PC32 reloc instead. */
2376 h
->plt
.offset
= (bfd_vma
) -1;
2383 /* It's possible that we incorrectly decided a .plt reloc was
2384 needed for an R_X86_64_PC32 reloc to a non-function sym in
2385 check_relocs. We can't decide accurately between function and
2386 non-function syms in check-relocs; Objects loaded later in
2387 the link may change h->type. So fix it now. */
2388 h
->plt
.offset
= (bfd_vma
) -1;
2390 /* If this is a weak symbol, and there is a real definition, the
2391 processor independent code will have arranged for us to see the
2392 real definition first, and we can just use the same value. */
2393 if (h
->u
.weakdef
!= NULL
)
2395 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2396 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2397 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2398 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2399 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2401 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2402 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2403 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
2408 /* This is a reference to a symbol defined by a dynamic object which
2409 is not a function. */
2411 /* If we are creating a shared library, we must presume that the
2412 only references to the symbol are via the global offset table.
2413 For such cases we need not do anything here; the relocations will
2414 be handled correctly by relocate_section. */
2415 if (!bfd_link_executable (info
))
2418 /* If there are no references to this symbol that do not use the
2419 GOT, we don't need to generate a copy reloc. */
2420 if (!h
->non_got_ref
)
2423 /* If -z nocopyreloc was given, we won't generate them either. */
2424 if (info
->nocopyreloc
)
2430 if (ELIMINATE_COPY_RELOCS
)
2432 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2433 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2435 s
= p
->sec
->output_section
;
2436 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2440 /* If we didn't find any dynamic relocs in read-only sections, then
2441 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2449 /* We must allocate the symbol in our .dynbss section, which will
2450 become part of the .bss section of the executable. There will be
2451 an entry for this symbol in the .dynsym section. The dynamic
2452 object will contain position independent code, so all references
2453 from the dynamic object to this symbol will go through the global
2454 offset table. The dynamic linker will use the .dynsym entry to
2455 determine the address it must put in the global offset table, so
2456 both the dynamic object and the regular object will refer to the
2457 same memory location for the variable. */
2459 htab
= elf_x86_64_hash_table (info
);
2463 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2464 to copy the initial value out of the dynamic object and into the
2465 runtime process image. */
2466 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2468 const struct elf_backend_data
*bed
;
2469 bed
= get_elf_backend_data (info
->output_bfd
);
2470 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
2476 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2479 /* Allocate space in .plt, .got and associated reloc sections for
2483 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2485 struct bfd_link_info
*info
;
2486 struct elf_x86_64_link_hash_table
*htab
;
2487 struct elf_x86_64_link_hash_entry
*eh
;
2488 struct elf_dyn_relocs
*p
;
2489 const struct elf_backend_data
*bed
;
2490 unsigned int plt_entry_size
;
2491 bfd_boolean resolved_to_zero
;
2493 if (h
->root
.type
== bfd_link_hash_indirect
)
2496 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2498 info
= (struct bfd_link_info
*) inf
;
2499 htab
= elf_x86_64_hash_table (info
);
2502 bed
= get_elf_backend_data (info
->output_bfd
);
2503 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2505 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, eh
);
2507 /* We can't use the GOT PLT if pointer equality is needed since
2508 finish_dynamic_symbol won't clear symbol value and the dynamic
2509 linker won't update the GOT slot. We will get into an infinite
2510 loop at run-time. */
2511 if (htab
->plt_got
!= NULL
2512 && h
->type
!= STT_GNU_IFUNC
2513 && !h
->pointer_equality_needed
2514 && h
->plt
.refcount
> 0
2515 && h
->got
.refcount
> 0)
2517 /* Don't use the regular PLT if there are both GOT and GOTPLT
2519 h
->plt
.offset
= (bfd_vma
) -1;
2521 /* Use the GOT PLT. */
2522 eh
->plt_got
.refcount
= 1;
2525 /* Clear the reference count of function pointer relocations if
2526 symbol isn't a normal function. */
2527 if (h
->type
!= STT_FUNC
)
2528 eh
->func_pointer_refcount
= 0;
2530 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2531 here if it is defined and referenced in a non-shared object. */
2532 if (h
->type
== STT_GNU_IFUNC
2535 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
2537 &htab
->readonly_dynrelocs_against_ifunc
,
2542 asection
*s
= htab
->plt_bnd
;
2543 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
2545 /* Use the .plt.bnd section if it is created. */
2546 eh
->plt_bnd
.offset
= s
->size
;
2548 /* Make room for this entry in the .plt.bnd section. */
2549 s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2557 /* Don't create the PLT entry if there are only function pointer
2558 relocations which can be resolved at run-time. */
2559 else if (htab
->elf
.dynamic_sections_created
2560 && (h
->plt
.refcount
> eh
->func_pointer_refcount
2561 || eh
->plt_got
.refcount
> 0))
2563 bfd_boolean use_plt_got
;
2565 /* Clear the reference count of function pointer relocations
2567 eh
->func_pointer_refcount
= 0;
2569 if ((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2571 /* Don't use the regular PLT for DF_BIND_NOW. */
2572 h
->plt
.offset
= (bfd_vma
) -1;
2574 /* Use the GOT PLT. */
2575 h
->got
.refcount
= 1;
2576 eh
->plt_got
.refcount
= 1;
2579 use_plt_got
= eh
->plt_got
.refcount
> 0;
2581 /* Make sure this symbol is output as a dynamic symbol.
2582 Undefined weak syms won't yet be marked as dynamic. */
2583 if (h
->dynindx
== -1
2585 && !resolved_to_zero
)
2587 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2591 if (bfd_link_pic (info
)
2592 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2594 asection
*s
= htab
->elf
.splt
;
2595 asection
*bnd_s
= htab
->plt_bnd
;
2596 asection
*got_s
= htab
->plt_got
;
2598 /* If this is the first .plt entry, make room for the special
2599 first entry. The .plt section is used by prelink to undo
2600 prelinking for dynamic relocations. */
2602 s
->size
= plt_entry_size
;
2605 eh
->plt_got
.offset
= got_s
->size
;
2608 h
->plt
.offset
= s
->size
;
2610 eh
->plt_bnd
.offset
= bnd_s
->size
;
2613 /* If this symbol is not defined in a regular file, and we are
2614 not generating a shared library, then set the symbol to this
2615 location in the .plt. This is required to make function
2616 pointers compare as equal between the normal executable and
2617 the shared library. */
2618 if (! bfd_link_pic (info
)
2623 /* We need to make a call to the entry of the GOT PLT
2624 instead of regular PLT entry. */
2625 h
->root
.u
.def
.section
= got_s
;
2626 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
2632 /* We need to make a call to the entry of the second
2633 PLT instead of regular PLT entry. */
2634 h
->root
.u
.def
.section
= bnd_s
;
2635 h
->root
.u
.def
.value
= eh
->plt_bnd
.offset
;
2639 h
->root
.u
.def
.section
= s
;
2640 h
->root
.u
.def
.value
= h
->plt
.offset
;
2645 /* Make room for this entry. */
2647 got_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2650 s
->size
+= plt_entry_size
;
2652 bnd_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2654 /* We also need to make an entry in the .got.plt section,
2655 which will be placed in the .got section by the linker
2657 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
2659 /* There should be no PLT relocation against resolved
2660 undefined weak symbol in executable. */
2661 if (!resolved_to_zero
)
2663 /* We also need to make an entry in the .rela.plt
2665 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2666 htab
->elf
.srelplt
->reloc_count
++;
2672 eh
->plt_got
.offset
= (bfd_vma
) -1;
2673 h
->plt
.offset
= (bfd_vma
) -1;
2679 eh
->plt_got
.offset
= (bfd_vma
) -1;
2680 h
->plt
.offset
= (bfd_vma
) -1;
2684 eh
->tlsdesc_got
= (bfd_vma
) -1;
2686 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2687 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2688 if (h
->got
.refcount
> 0
2689 && bfd_link_executable (info
)
2691 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
2693 h
->got
.offset
= (bfd_vma
) -1;
2695 else if (h
->got
.refcount
> 0)
2699 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
2701 /* Make sure this symbol is output as a dynamic symbol.
2702 Undefined weak syms won't yet be marked as dynamic. */
2703 if (h
->dynindx
== -1
2705 && !resolved_to_zero
)
2707 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2711 if (GOT_TLS_GDESC_P (tls_type
))
2713 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2714 - elf_x86_64_compute_jump_table_size (htab
);
2715 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2716 h
->got
.offset
= (bfd_vma
) -2;
2718 if (! GOT_TLS_GDESC_P (tls_type
)
2719 || GOT_TLS_GD_P (tls_type
))
2722 h
->got
.offset
= s
->size
;
2723 s
->size
+= GOT_ENTRY_SIZE
;
2724 if (GOT_TLS_GD_P (tls_type
))
2725 s
->size
+= GOT_ENTRY_SIZE
;
2727 dyn
= htab
->elf
.dynamic_sections_created
;
2728 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2729 and two if global. R_X86_64_GOTTPOFF needs one dynamic
2730 relocation. No dynamic relocation against resolved undefined
2731 weak symbol in executable. */
2732 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2733 || tls_type
== GOT_TLS_IE
)
2734 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2735 else if (GOT_TLS_GD_P (tls_type
))
2736 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
2737 else if (! GOT_TLS_GDESC_P (tls_type
)
2738 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2739 && !resolved_to_zero
)
2740 || h
->root
.type
!= bfd_link_hash_undefweak
)
2741 && (bfd_link_pic (info
)
2742 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2743 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2744 if (GOT_TLS_GDESC_P (tls_type
))
2746 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2747 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2751 h
->got
.offset
= (bfd_vma
) -1;
2753 if (eh
->dyn_relocs
== NULL
)
2756 /* In the shared -Bsymbolic case, discard space allocated for
2757 dynamic pc-relative relocs against symbols which turn out to be
2758 defined in regular objects. For the normal shared case, discard
2759 space for pc-relative relocs that have become local due to symbol
2760 visibility changes. */
2762 if (bfd_link_pic (info
))
2764 /* Relocs that use pc_count are those that appear on a call
2765 insn, or certain REL relocs that can generated via assembly.
2766 We want calls to protected symbols to resolve directly to the
2767 function rather than going via the plt. If people want
2768 function pointer comparisons to work as expected then they
2769 should avoid writing weird assembly. */
2770 if (SYMBOL_CALLS_LOCAL (info
, h
))
2772 struct elf_dyn_relocs
**pp
;
2774 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2776 p
->count
-= p
->pc_count
;
2785 /* Also discard relocs on undefined weak syms with non-default
2786 visibility or in PIE. */
2787 if (eh
->dyn_relocs
!= NULL
)
2789 if (h
->root
.type
== bfd_link_hash_undefweak
)
2791 /* Undefined weak symbol is never bound locally in shared
2793 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2794 || resolved_to_zero
)
2795 eh
->dyn_relocs
= NULL
;
2796 else if (h
->dynindx
== -1
2797 && ! h
->forced_local
2798 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2801 /* For PIE, discard space for pc-relative relocs against
2802 symbols which turn out to need copy relocs. */
2803 else if (bfd_link_executable (info
)
2804 && (h
->needs_copy
|| eh
->needs_copy
)
2808 struct elf_dyn_relocs
**pp
;
2810 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2812 if (p
->pc_count
!= 0)
2820 else if (ELIMINATE_COPY_RELOCS
)
2822 /* For the non-shared case, discard space for relocs against
2823 symbols which turn out to need copy relocs or are not
2824 dynamic. Keep dynamic relocations for run-time function
2825 pointer initialization. */
2827 if ((!h
->non_got_ref
2828 || eh
->func_pointer_refcount
> 0
2829 || (h
->root
.type
== bfd_link_hash_undefweak
2830 && !resolved_to_zero
))
2833 || (htab
->elf
.dynamic_sections_created
2834 && (h
->root
.type
== bfd_link_hash_undefweak
2835 || h
->root
.type
== bfd_link_hash_undefined
))))
2837 /* Make sure this symbol is output as a dynamic symbol.
2838 Undefined weak syms won't yet be marked as dynamic. */
2839 if (h
->dynindx
== -1
2840 && ! h
->forced_local
2841 && ! resolved_to_zero
2842 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2845 /* If that succeeded, we know we'll be keeping all the
2847 if (h
->dynindx
!= -1)
2851 eh
->dyn_relocs
= NULL
;
2852 eh
->func_pointer_refcount
= 0;
2857 /* Finally, allocate space. */
2858 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2862 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2864 BFD_ASSERT (sreloc
!= NULL
);
2866 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2872 /* Allocate space in .plt, .got and associated reloc sections for
2873 local dynamic relocs. */
2876 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
2878 struct elf_link_hash_entry
*h
2879 = (struct elf_link_hash_entry
*) *slot
;
2881 if (h
->type
!= STT_GNU_IFUNC
2885 || h
->root
.type
!= bfd_link_hash_defined
)
2888 return elf_x86_64_allocate_dynrelocs (h
, inf
);
2891 /* Find any dynamic relocs that apply to read-only sections. */
2894 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
2897 struct elf_x86_64_link_hash_entry
*eh
;
2898 struct elf_dyn_relocs
*p
;
2900 /* Skip local IFUNC symbols. */
2901 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
2904 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2905 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2907 asection
*s
= p
->sec
->output_section
;
2909 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2911 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2913 info
->flags
|= DF_TEXTREL
;
2915 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
2916 || info
->error_textrel
)
2917 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
2918 p
->sec
->owner
, h
->root
.root
.string
,
2921 /* Not an error, just cut short the traversal. */
2928 /* With the local symbol, foo, we convert
2929 mov foo@GOTPCREL(%rip), %reg
2933 call/jmp *foo@GOTPCREL(%rip)
2935 nop call foo/jmp foo nop
2936 When PIC is false, convert
2937 test %reg, foo@GOTPCREL(%rip)
2941 binop foo@GOTPCREL(%rip), %reg
2944 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
2948 elf_x86_64_convert_load (bfd
*abfd
, asection
*sec
,
2949 struct bfd_link_info
*link_info
)
2951 Elf_Internal_Shdr
*symtab_hdr
;
2952 Elf_Internal_Rela
*internal_relocs
;
2953 Elf_Internal_Rela
*irel
, *irelend
;
2955 struct elf_x86_64_link_hash_table
*htab
;
2956 bfd_boolean changed_contents
;
2957 bfd_boolean changed_relocs
;
2958 bfd_signed_vma
*local_got_refcounts
;
2959 bfd_vma maxpagesize
;
2961 bfd_boolean require_reloc_pc32
;
2963 /* Don't even try to convert non-ELF outputs. */
2964 if (!is_elf_hash_table (link_info
->hash
))
2967 /* Nothing to do if there is no need or no output. */
2968 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
2969 || sec
->need_convert_load
== 0
2970 || bfd_is_abs_section (sec
->output_section
))
2973 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2975 /* Load the relocations for this section. */
2976 internal_relocs
= (_bfd_elf_link_read_relocs
2977 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
2978 link_info
->keep_memory
));
2979 if (internal_relocs
== NULL
)
2982 htab
= elf_x86_64_hash_table (link_info
);
2983 changed_contents
= FALSE
;
2984 changed_relocs
= FALSE
;
2985 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2986 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2988 /* Get the section contents. */
2989 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2990 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2993 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2997 is_pic
= bfd_link_pic (link_info
);
2999 /* TRUE if we can convert only to R_X86_64_PC32. Enable it for
3002 = link_info
->disable_target_specific_optimizations
> 1;
3004 irelend
= internal_relocs
+ sec
->reloc_count
;
3005 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3007 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
3008 unsigned int r_symndx
= htab
->r_sym (irel
->r_info
);
3010 struct elf_link_hash_entry
*h
;
3014 bfd_signed_vma raddend
;
3015 unsigned int opcode
;
3018 bfd_boolean to_reloc_pc32
;
3020 relocx
= (r_type
== R_X86_64_GOTPCRELX
3021 || r_type
== R_X86_64_REX_GOTPCRELX
);
3022 if (!relocx
&& r_type
!= R_X86_64_GOTPCREL
)
3025 roff
= irel
->r_offset
;
3026 if (roff
< (r_type
== R_X86_64_REX_GOTPCRELX
? 3 : 2))
3029 raddend
= irel
->r_addend
;
3030 /* Addend for 32-bit PC-relative relocation must be -4. */
3034 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
3036 /* Convert mov to lea since it has been done for a while. */
3039 /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
3040 for call, jmp or one of adc, add, and, cmp, or, sbb, sub,
3041 test, xor instructions. */
3046 /* We convert only to R_X86_64_PC32:
3048 2. R_X86_64_GOTPCREL since we can't modify REX byte.
3049 3. require_reloc_pc32 is true.
3052 to_reloc_pc32
= (opcode
== 0xff
3054 || require_reloc_pc32
3057 /* Get the symbol referred to by the reloc. */
3058 if (r_symndx
< symtab_hdr
->sh_info
)
3060 Elf_Internal_Sym
*isym
;
3062 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
3065 symtype
= ELF_ST_TYPE (isym
->st_info
);
3067 /* STT_GNU_IFUNC must keep GOTPCREL relocations and skip
3068 relocation against undefined symbols. */
3069 if (symtype
== STT_GNU_IFUNC
|| isym
->st_shndx
== SHN_UNDEF
)
3072 if (isym
->st_shndx
== SHN_ABS
)
3073 tsec
= bfd_abs_section_ptr
;
3074 else if (isym
->st_shndx
== SHN_COMMON
)
3075 tsec
= bfd_com_section_ptr
;
3076 else if (isym
->st_shndx
== SHN_X86_64_LCOMMON
)
3077 tsec
= &_bfd_elf_large_com_section
;
3079 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
3082 toff
= isym
->st_value
;
3086 indx
= r_symndx
- symtab_hdr
->sh_info
;
3087 h
= elf_sym_hashes (abfd
)[indx
];
3088 BFD_ASSERT (h
!= NULL
);
3090 while (h
->root
.type
== bfd_link_hash_indirect
3091 || h
->root
.type
== bfd_link_hash_warning
)
3092 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3094 /* STT_GNU_IFUNC must keep GOTPCREL relocations. We also
3095 avoid optimizing GOTPCREL relocations againt _DYNAMIC
3096 since ld.so may use its link-time address. */
3097 if (h
->type
== STT_GNU_IFUNC
)
3100 /* Undefined weak symbol is only bound locally in executable
3101 and its reference is resolved as 0 without relocation
3102 overflow. We can only perform this optimization for
3103 GOTPCRELX relocations since we need to modify REX byte.
3104 It is OK convert mov with R_X86_64_GOTPCREL to
3106 if ((relocx
|| opcode
== 0x8b)
3107 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
,
3108 elf_x86_64_hash_entry (h
)))
3112 /* Skip for branch instructions since R_X86_64_PC32
3114 if (require_reloc_pc32
)
3119 /* For non-branch instructions, we can convert to
3120 R_X86_64_32/R_X86_64_32S since we know if there
3122 to_reloc_pc32
= FALSE
;
3125 /* Since we don't know the current PC when PIC is true,
3126 we can't convert to R_X86_64_PC32. */
3127 if (to_reloc_pc32
&& is_pic
)
3132 else if ((h
->def_regular
3133 || h
->root
.type
== bfd_link_hash_defined
3134 || h
->root
.type
== bfd_link_hash_defweak
)
3135 && h
!= htab
->elf
.hdynamic
3136 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
3138 /* bfd_link_hash_new or bfd_link_hash_undefined is
3139 set by an assignment in a linker script in
3140 bfd_elf_record_link_assignment. */
3142 && (h
->root
.type
== bfd_link_hash_new
3143 || h
->root
.type
== bfd_link_hash_undefined
))
3145 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */
3146 if (require_reloc_pc32
)
3150 tsec
= h
->root
.u
.def
.section
;
3151 toff
= h
->root
.u
.def
.value
;
3158 /* We can only estimate relocation overflow for R_X86_64_PC32. */
3162 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
3164 /* At this stage in linking, no SEC_MERGE symbol has been
3165 adjusted, so all references to such symbols need to be
3166 passed through _bfd_merged_section_offset. (Later, in
3167 relocate_section, all SEC_MERGE symbols *except* for
3168 section symbols have been adjusted.)
3170 gas may reduce relocations against symbols in SEC_MERGE
3171 sections to a relocation against the section symbol when
3172 the original addend was zero. When the reloc is against
3173 a section symbol we should include the addend in the
3174 offset passed to _bfd_merged_section_offset, since the
3175 location of interest is the original symbol. On the
3176 other hand, an access to "sym+addend" where "sym" is not
3177 a section symbol should not include the addend; Such an
3178 access is presumed to be an offset from "sym"; The
3179 location of interest is just "sym". */
3180 if (symtype
== STT_SECTION
)
3183 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
3184 elf_section_data (tsec
)->sec_info
,
3187 if (symtype
!= STT_SECTION
)
3193 /* Don't convert if R_X86_64_PC32 relocation overflows. */
3194 if (tsec
->output_section
== sec
->output_section
)
3196 if ((toff
- roff
+ 0x80000000) > 0xffffffff)
3201 bfd_signed_vma distance
;
3203 /* At this point, we don't know the load addresses of TSEC
3204 section nor SEC section. We estimate the distrance between
3205 SEC and TSEC. We store the estimated distances in the
3206 compressed_size field of the output section, which is only
3207 used to decompress the compressed input section. */
3208 if (sec
->output_section
->compressed_size
== 0)
3211 bfd_size_type size
= 0;
3212 for (asect
= link_info
->output_bfd
->sections
;
3214 asect
= asect
->next
)
3215 /* Skip debug sections since compressed_size is used to
3216 compress debug sections. */
3217 if ((asect
->flags
& SEC_DEBUGGING
) == 0)
3220 for (i
= asect
->map_head
.s
;
3224 size
= align_power (size
, i
->alignment_power
);
3227 asect
->compressed_size
= size
;
3231 /* Don't convert GOTPCREL relocations if TSEC isn't placed
3233 distance
= (tsec
->output_section
->compressed_size
3234 - sec
->output_section
->compressed_size
);
3238 /* Take PT_GNU_RELRO segment into account by adding
3240 if ((toff
+ distance
+ maxpagesize
- roff
+ 0x80000000)
3248 /* We have "call/jmp *foo@GOTPCREL(%rip)". */
3253 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
3255 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
3258 /* Convert to "jmp foo nop". */
3261 nop_offset
= irel
->r_offset
+ 3;
3262 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
3263 irel
->r_offset
-= 1;
3264 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
3268 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
3271 nop
= link_info
->call_nop_byte
;
3272 if (link_info
->call_nop_as_suffix
)
3274 nop_offset
= irel
->r_offset
+ 3;
3275 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
3276 irel
->r_offset
-= 1;
3277 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
3280 nop_offset
= irel
->r_offset
- 2;
3282 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
3283 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
3284 r_type
= R_X86_64_PC32
;
3289 unsigned int rex_mask
= REX_R
;
3291 if (r_type
== R_X86_64_REX_GOTPCRELX
)
3292 rex
= bfd_get_8 (abfd
, contents
+ roff
- 3);
3300 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
3301 "lea foo(%rip), %reg". */
3303 r_type
= R_X86_64_PC32
;
3307 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
3308 "mov $foo, %reg". */
3310 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
3311 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
3312 if ((rex
& REX_W
) != 0
3313 && ABI_64_P (link_info
->output_bfd
))
3315 /* Keep the REX_W bit in REX byte for LP64. */
3316 r_type
= R_X86_64_32S
;
3317 goto rewrite_modrm_rex
;
3321 /* If the REX_W bit in REX byte isn't needed,
3322 use R_X86_64_32 and clear the W bit to avoid
3323 sign-extend imm32 to imm64. */
3324 r_type
= R_X86_64_32
;
3325 /* Clear the W bit in REX byte. */
3327 goto rewrite_modrm_rex
;
3333 /* R_X86_64_PC32 isn't supported. */
3337 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
3340 /* Convert "test %reg, foo@GOTPCREL(%rip)" to
3341 "test $foo, %reg". */
3342 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
3347 /* Convert "binop foo@GOTPCREL(%rip), %reg" to
3348 "binop $foo, %reg". */
3349 modrm
= 0xc0 | (modrm
& 0x38) >> 3 | (opcode
& 0x3c);
3353 /* Use R_X86_64_32 with 32-bit operand to avoid relocation
3354 overflow when sign-extending imm32 to imm64. */
3355 r_type
= (rex
& REX_W
) != 0 ? R_X86_64_32S
: R_X86_64_32
;
3358 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
3362 /* Move the R bit to the B bit in REX byte. */
3363 rex
= (rex
& ~rex_mask
) | (rex
& REX_R
) >> 2;
3364 bfd_put_8 (abfd
, rex
, contents
+ roff
- 3);
3367 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */
3371 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
3374 irel
->r_info
= htab
->r_info (r_symndx
, r_type
);
3375 changed_contents
= TRUE
;
3376 changed_relocs
= TRUE
;
3380 if (h
->got
.refcount
> 0)
3381 h
->got
.refcount
-= 1;
3385 if (local_got_refcounts
!= NULL
3386 && local_got_refcounts
[r_symndx
] > 0)
3387 local_got_refcounts
[r_symndx
] -= 1;
3391 if (contents
!= NULL
3392 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3394 if (!changed_contents
&& !link_info
->keep_memory
)
3398 /* Cache the section contents for elf_link_input_bfd. */
3399 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3403 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3405 if (!changed_relocs
)
3406 free (internal_relocs
);
3408 elf_section_data (sec
)->relocs
= internal_relocs
;
3414 if (contents
!= NULL
3415 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3417 if (internal_relocs
!= NULL
3418 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3419 free (internal_relocs
);
3423 /* Set the sizes of the dynamic sections. */
3426 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
3427 struct bfd_link_info
*info
)
3429 struct elf_x86_64_link_hash_table
*htab
;
3434 const struct elf_backend_data
*bed
;
3436 htab
= elf_x86_64_hash_table (info
);
3439 bed
= get_elf_backend_data (output_bfd
);
3441 dynobj
= htab
->elf
.dynobj
;
3445 if (htab
->elf
.dynamic_sections_created
)
3447 /* Set the contents of the .interp section to the interpreter. */
3448 if (bfd_link_executable (info
) && !info
->nointerp
)
3450 s
= bfd_get_linker_section (dynobj
, ".interp");
3453 s
->size
= htab
->dynamic_interpreter_size
;
3454 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
3459 /* Set up .got offsets for local syms, and space for local dynamic
3461 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3463 bfd_signed_vma
*local_got
;
3464 bfd_signed_vma
*end_local_got
;
3465 char *local_tls_type
;
3466 bfd_vma
*local_tlsdesc_gotent
;
3467 bfd_size_type locsymcount
;
3468 Elf_Internal_Shdr
*symtab_hdr
;
3471 if (! is_x86_64_elf (ibfd
))
3474 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3476 struct elf_dyn_relocs
*p
;
3478 if (!elf_x86_64_convert_load (ibfd
, s
, info
))
3481 for (p
= (struct elf_dyn_relocs
*)
3482 (elf_section_data (s
)->local_dynrel
);
3486 if (!bfd_is_abs_section (p
->sec
)
3487 && bfd_is_abs_section (p
->sec
->output_section
))
3489 /* Input section has been discarded, either because
3490 it is a copy of a linkonce section or due to
3491 linker script /DISCARD/, so we'll be discarding
3494 else if (p
->count
!= 0)
3496 srel
= elf_section_data (p
->sec
)->sreloc
;
3497 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3498 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3499 && (info
->flags
& DF_TEXTREL
) == 0)
3501 info
->flags
|= DF_TEXTREL
;
3502 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3503 || info
->error_textrel
)
3504 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3505 p
->sec
->owner
, p
->sec
);
3511 local_got
= elf_local_got_refcounts (ibfd
);
3515 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3516 locsymcount
= symtab_hdr
->sh_info
;
3517 end_local_got
= local_got
+ locsymcount
;
3518 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
3519 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
3521 srel
= htab
->elf
.srelgot
;
3522 for (; local_got
< end_local_got
;
3523 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3525 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3528 if (GOT_TLS_GDESC_P (*local_tls_type
))
3530 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3531 - elf_x86_64_compute_jump_table_size (htab
);
3532 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3533 *local_got
= (bfd_vma
) -2;
3535 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3536 || GOT_TLS_GD_P (*local_tls_type
))
3538 *local_got
= s
->size
;
3539 s
->size
+= GOT_ENTRY_SIZE
;
3540 if (GOT_TLS_GD_P (*local_tls_type
))
3541 s
->size
+= GOT_ENTRY_SIZE
;
3543 if (bfd_link_pic (info
)
3544 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3545 || *local_tls_type
== GOT_TLS_IE
)
3547 if (GOT_TLS_GDESC_P (*local_tls_type
))
3549 htab
->elf
.srelplt
->size
3550 += bed
->s
->sizeof_rela
;
3551 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3553 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3554 || GOT_TLS_GD_P (*local_tls_type
))
3555 srel
->size
+= bed
->s
->sizeof_rela
;
3559 *local_got
= (bfd_vma
) -1;
3563 if (htab
->tls_ld_got
.refcount
> 0)
3565 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3567 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
3568 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
3569 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3572 htab
->tls_ld_got
.offset
= -1;
3574 /* Allocate global sym .plt and .got entries, and space for global
3575 sym dynamic relocs. */
3576 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
3579 /* Allocate .plt and .got entries, and space for local symbols. */
3580 htab_traverse (htab
->loc_hash_table
,
3581 elf_x86_64_allocate_local_dynrelocs
,
3584 /* For every jump slot reserved in the sgotplt, reloc_count is
3585 incremented. However, when we reserve space for TLS descriptors,
3586 it's not incremented, so in order to compute the space reserved
3587 for them, it suffices to multiply the reloc count by the jump
3590 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3591 so that R_X86_64_IRELATIVE entries come last. */
3592 if (htab
->elf
.srelplt
)
3594 htab
->sgotplt_jump_table_size
3595 = elf_x86_64_compute_jump_table_size (htab
);
3596 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3598 else if (htab
->elf
.irelplt
)
3599 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3601 if (htab
->tlsdesc_plt
)
3603 /* If we're not using lazy TLS relocations, don't generate the
3604 PLT and GOT entries they require. */
3605 if ((info
->flags
& DF_BIND_NOW
))
3606 htab
->tlsdesc_plt
= 0;
3609 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
3610 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
3611 /* Reserve room for the initial entry.
3612 FIXME: we could probably do away with it in this case. */
3613 if (htab
->elf
.splt
->size
== 0)
3614 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3615 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
3616 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3620 if (htab
->elf
.sgotplt
)
3622 /* Don't allocate .got.plt section if there are no GOT nor PLT
3623 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3624 if ((htab
->elf
.hgot
== NULL
3625 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3626 && (htab
->elf
.sgotplt
->size
3627 == get_elf_backend_data (output_bfd
)->got_header_size
)
3628 && (htab
->elf
.splt
== NULL
3629 || htab
->elf
.splt
->size
== 0)
3630 && (htab
->elf
.sgot
== NULL
3631 || htab
->elf
.sgot
->size
== 0)
3632 && (htab
->elf
.iplt
== NULL
3633 || htab
->elf
.iplt
->size
== 0)
3634 && (htab
->elf
.igotplt
== NULL
3635 || htab
->elf
.igotplt
->size
== 0))
3636 htab
->elf
.sgotplt
->size
= 0;
3639 if (htab
->plt_eh_frame
!= NULL
3640 && htab
->elf
.splt
!= NULL
3641 && htab
->elf
.splt
->size
!= 0
3642 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3643 && _bfd_elf_eh_frame_present (info
))
3645 const struct elf_x86_64_backend_data
*arch_data
3646 = get_elf_x86_64_arch_data (bed
);
3647 htab
->plt_eh_frame
->size
= arch_data
->eh_frame_plt_size
;
3650 /* We now have determined the sizes of the various dynamic sections.
3651 Allocate memory for them. */
3653 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3655 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3658 if (s
== htab
->elf
.splt
3659 || s
== htab
->elf
.sgot
3660 || s
== htab
->elf
.sgotplt
3661 || s
== htab
->elf
.iplt
3662 || s
== htab
->elf
.igotplt
3663 || s
== htab
->plt_bnd
3664 || s
== htab
->plt_got
3665 || s
== htab
->plt_eh_frame
3666 || s
== htab
->sdynbss
)
3668 /* Strip this section if we don't need it; see the
3671 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3673 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
3676 /* We use the reloc_count field as a counter if we need
3677 to copy relocs into the output file. */
3678 if (s
!= htab
->elf
.srelplt
)
3683 /* It's not one of our sections, so don't allocate space. */
3689 /* If we don't need this section, strip it from the
3690 output file. This is mostly to handle .rela.bss and
3691 .rela.plt. We must create both sections in
3692 create_dynamic_sections, because they must be created
3693 before the linker maps input sections to output
3694 sections. The linker does that before
3695 adjust_dynamic_symbol is called, and it is that
3696 function which decides whether anything needs to go
3697 into these sections. */
3699 s
->flags
|= SEC_EXCLUDE
;
3703 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3706 /* Allocate memory for the section contents. We use bfd_zalloc
3707 here in case unused entries are not reclaimed before the
3708 section's contents are written out. This should not happen,
3709 but this way if it does, we get a R_X86_64_NONE reloc instead
3711 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3712 if (s
->contents
== NULL
)
3716 if (htab
->plt_eh_frame
!= NULL
3717 && htab
->plt_eh_frame
->contents
!= NULL
)
3719 const struct elf_x86_64_backend_data
*arch_data
3720 = get_elf_x86_64_arch_data (bed
);
3722 memcpy (htab
->plt_eh_frame
->contents
,
3723 arch_data
->eh_frame_plt
, htab
->plt_eh_frame
->size
);
3724 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3725 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3728 if (htab
->elf
.dynamic_sections_created
)
3730 /* Add some entries to the .dynamic section. We fill in the
3731 values later, in elf_x86_64_finish_dynamic_sections, but we
3732 must add the entries now so that we get the correct size for
3733 the .dynamic section. The DT_DEBUG entry is filled in by the
3734 dynamic linker and used by the debugger. */
3735 #define add_dynamic_entry(TAG, VAL) \
3736 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3738 if (bfd_link_executable (info
))
3740 if (!add_dynamic_entry (DT_DEBUG
, 0))
3744 if (htab
->elf
.splt
->size
!= 0)
3746 /* DT_PLTGOT is used by prelink even if there is no PLT
3748 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3751 if (htab
->elf
.srelplt
->size
!= 0)
3753 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3754 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3755 || !add_dynamic_entry (DT_JMPREL
, 0))
3759 if (htab
->tlsdesc_plt
3760 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3761 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3767 if (!add_dynamic_entry (DT_RELA
, 0)
3768 || !add_dynamic_entry (DT_RELASZ
, 0)
3769 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3772 /* If any dynamic relocs apply to a read-only section,
3773 then we need a DT_TEXTREL entry. */
3774 if ((info
->flags
& DF_TEXTREL
) == 0)
3775 elf_link_hash_traverse (&htab
->elf
,
3776 elf_x86_64_readonly_dynrelocs
,
3779 if ((info
->flags
& DF_TEXTREL
) != 0)
3781 if (htab
->readonly_dynrelocs_against_ifunc
)
3783 info
->callbacks
->einfo
3784 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3785 bfd_set_error (bfd_error_bad_value
);
3789 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3794 #undef add_dynamic_entry
3800 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3801 struct bfd_link_info
*info
)
3803 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3807 struct elf_link_hash_entry
*tlsbase
;
3809 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3810 "_TLS_MODULE_BASE_",
3811 FALSE
, FALSE
, FALSE
);
3813 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3815 struct elf_x86_64_link_hash_table
*htab
;
3816 struct bfd_link_hash_entry
*bh
= NULL
;
3817 const struct elf_backend_data
*bed
3818 = get_elf_backend_data (output_bfd
);
3820 htab
= elf_x86_64_hash_table (info
);
3824 if (!(_bfd_generic_link_add_one_symbol
3825 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3826 tls_sec
, 0, NULL
, FALSE
,
3827 bed
->collect
, &bh
)))
3830 htab
->tls_module_base
= bh
;
3832 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3833 tlsbase
->def_regular
= 1;
3834 tlsbase
->other
= STV_HIDDEN
;
3835 tlsbase
->root
.linker_def
= 1;
3836 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3843 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3844 executables. Rather than setting it to the beginning of the TLS
3845 section, we have to set it to the end. This function may be called
3846 multiple times, it is idempotent. */
3849 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
3851 struct elf_x86_64_link_hash_table
*htab
;
3852 struct bfd_link_hash_entry
*base
;
3854 if (!bfd_link_executable (info
))
3857 htab
= elf_x86_64_hash_table (info
);
3861 base
= htab
->tls_module_base
;
3865 base
->u
.def
.value
= htab
->elf
.tls_size
;
3868 /* Return the base VMA address which should be subtracted from real addresses
3869 when resolving @dtpoff relocation.
3870 This is PT_TLS segment p_vaddr. */
3873 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
3875 /* If tls_sec is NULL, we should have signalled an error already. */
3876 if (elf_hash_table (info
)->tls_sec
== NULL
)
3878 return elf_hash_table (info
)->tls_sec
->vma
;
3881 /* Return the relocation value for @tpoff relocation
3882 if STT_TLS virtual address is ADDRESS. */
3885 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3887 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3888 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
3889 bfd_vma static_tls_size
;
3891 /* If tls_segment is NULL, we should have signalled an error already. */
3892 if (htab
->tls_sec
== NULL
)
3895 /* Consider special static TLS alignment requirements. */
3896 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
3897 return address
- static_tls_size
- htab
->tls_sec
->vma
;
3900 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
3904 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
3906 /* Opcode Instruction
3909 0x0f 0x8x conditional jump */
3911 && (contents
[offset
- 1] == 0xe8
3912 || contents
[offset
- 1] == 0xe9))
3914 && contents
[offset
- 2] == 0x0f
3915 && (contents
[offset
- 1] & 0xf0) == 0x80));
3918 /* Relocate an x86_64 ELF section. */
3921 elf_x86_64_relocate_section (bfd
*output_bfd
,
3922 struct bfd_link_info
*info
,
3924 asection
*input_section
,
3926 Elf_Internal_Rela
*relocs
,
3927 Elf_Internal_Sym
*local_syms
,
3928 asection
**local_sections
)
3930 struct elf_x86_64_link_hash_table
*htab
;
3931 Elf_Internal_Shdr
*symtab_hdr
;
3932 struct elf_link_hash_entry
**sym_hashes
;
3933 bfd_vma
*local_got_offsets
;
3934 bfd_vma
*local_tlsdesc_gotents
;
3935 Elf_Internal_Rela
*rel
;
3936 Elf_Internal_Rela
*wrel
;
3937 Elf_Internal_Rela
*relend
;
3938 const unsigned int plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
3940 BFD_ASSERT (is_x86_64_elf (input_bfd
));
3942 /* Skip if check_relocs failed. */
3943 if (input_section
->check_relocs_failed
)
3946 htab
= elf_x86_64_hash_table (info
);
3949 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3950 sym_hashes
= elf_sym_hashes (input_bfd
);
3951 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3952 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
3954 elf_x86_64_set_tls_module_base (info
);
3956 rel
= wrel
= relocs
;
3957 relend
= relocs
+ input_section
->reloc_count
;
3958 for (; rel
< relend
; wrel
++, rel
++)
3960 unsigned int r_type
;
3961 reloc_howto_type
*howto
;
3962 unsigned long r_symndx
;
3963 struct elf_link_hash_entry
*h
;
3964 struct elf_x86_64_link_hash_entry
*eh
;
3965 Elf_Internal_Sym
*sym
;
3967 bfd_vma off
, offplt
, plt_offset
;
3969 bfd_boolean unresolved_reloc
;
3970 bfd_reloc_status_type r
;
3972 asection
*base_got
, *resolved_plt
;
3974 bfd_boolean resolved_to_zero
;
3976 r_type
= ELF32_R_TYPE (rel
->r_info
);
3977 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
3978 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
3985 if (r_type
>= (int) R_X86_64_standard
)
3987 (*_bfd_error_handler
)
3988 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3989 input_bfd
, input_section
, r_type
);
3990 bfd_set_error (bfd_error_bad_value
);
3994 if (r_type
!= (int) R_X86_64_32
3995 || ABI_64_P (output_bfd
))
3996 howto
= x86_64_elf_howto_table
+ r_type
;
3998 howto
= (x86_64_elf_howto_table
3999 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
4000 r_symndx
= htab
->r_sym (rel
->r_info
);
4004 unresolved_reloc
= FALSE
;
4005 if (r_symndx
< symtab_hdr
->sh_info
)
4007 sym
= local_syms
+ r_symndx
;
4008 sec
= local_sections
[r_symndx
];
4010 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
4012 st_size
= sym
->st_size
;
4014 /* Relocate against local STT_GNU_IFUNC symbol. */
4015 if (!bfd_link_relocatable (info
)
4016 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
4018 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
4023 /* Set STT_GNU_IFUNC symbol value. */
4024 h
->root
.u
.def
.value
= sym
->st_value
;
4025 h
->root
.u
.def
.section
= sec
;
4030 bfd_boolean warned ATTRIBUTE_UNUSED
;
4031 bfd_boolean ignored ATTRIBUTE_UNUSED
;
4033 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
4034 r_symndx
, symtab_hdr
, sym_hashes
,
4036 unresolved_reloc
, warned
, ignored
);
4040 if (sec
!= NULL
&& discarded_section (sec
))
4042 _bfd_clear_contents (howto
, input_bfd
, input_section
,
4043 contents
+ rel
->r_offset
);
4044 wrel
->r_offset
= rel
->r_offset
;
4048 /* For ld -r, remove relocations in debug sections against
4049 sections defined in discarded sections. Not done for
4050 eh_frame editing code expects to be present. */
4051 if (bfd_link_relocatable (info
)
4052 && (input_section
->flags
& SEC_DEBUGGING
))
4058 if (bfd_link_relocatable (info
))
4065 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
4067 if (r_type
== R_X86_64_64
)
4069 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
4070 zero-extend it to 64bit if addend is zero. */
4071 r_type
= R_X86_64_32
;
4072 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4074 else if (r_type
== R_X86_64_SIZE64
)
4076 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
4077 zero-extend it to 64bit if addend is zero. */
4078 r_type
= R_X86_64_SIZE32
;
4079 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4083 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
4085 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
4086 it here if it is defined in a non-shared object. */
4088 && h
->type
== STT_GNU_IFUNC
4094 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4096 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4097 sections because such sections are not SEC_ALLOC and
4098 thus ld.so will not process them. */
4099 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
4103 else if (h
->plt
.offset
== (bfd_vma
) -1)
4106 /* STT_GNU_IFUNC symbol must go through PLT. */
4107 if (htab
->elf
.splt
!= NULL
)
4109 if (htab
->plt_bnd
!= NULL
)
4111 resolved_plt
= htab
->plt_bnd
;
4112 plt_offset
= eh
->plt_bnd
.offset
;
4116 resolved_plt
= htab
->elf
.splt
;
4117 plt_offset
= h
->plt
.offset
;
4122 resolved_plt
= htab
->elf
.iplt
;
4123 plt_offset
= h
->plt
.offset
;
4126 relocation
= (resolved_plt
->output_section
->vma
4127 + resolved_plt
->output_offset
+ plt_offset
);
4132 if (h
->root
.root
.string
)
4133 name
= h
->root
.root
.string
;
4135 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4137 (*_bfd_error_handler
)
4138 (_("%B: relocation %s against STT_GNU_IFUNC "
4139 "symbol `%s' isn't handled by %s"), input_bfd
,
4140 howto
->name
, name
, __FUNCTION__
);
4141 bfd_set_error (bfd_error_bad_value
);
4145 if (bfd_link_pic (info
))
4150 if (ABI_64_P (output_bfd
))
4154 if (rel
->r_addend
!= 0)
4156 if (h
->root
.root
.string
)
4157 name
= h
->root
.root
.string
;
4159 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4161 (*_bfd_error_handler
)
4162 (_("%B: relocation %s against STT_GNU_IFUNC "
4163 "symbol `%s' has non-zero addend: %d"),
4164 input_bfd
, howto
->name
, name
, rel
->r_addend
);
4165 bfd_set_error (bfd_error_bad_value
);
4169 /* Generate dynamic relcoation only when there is a
4170 non-GOT reference in a shared object. */
4171 if (bfd_link_pic (info
) && h
->non_got_ref
)
4173 Elf_Internal_Rela outrel
;
4176 /* Need a dynamic relocation to get the real function
4178 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
4182 if (outrel
.r_offset
== (bfd_vma
) -1
4183 || outrel
.r_offset
== (bfd_vma
) -2)
4186 outrel
.r_offset
+= (input_section
->output_section
->vma
4187 + input_section
->output_offset
);
4189 if (h
->dynindx
== -1
4191 || bfd_link_executable (info
))
4193 /* This symbol is resolved locally. */
4194 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4195 outrel
.r_addend
= (h
->root
.u
.def
.value
4196 + h
->root
.u
.def
.section
->output_section
->vma
4197 + h
->root
.u
.def
.section
->output_offset
);
4201 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4202 outrel
.r_addend
= 0;
4205 sreloc
= htab
->elf
.irelifunc
;
4206 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4208 /* If this reloc is against an external symbol, we
4209 do not want to fiddle with the addend. Otherwise,
4210 we need to include the symbol value so that it
4211 becomes an addend for the dynamic reloc. For an
4212 internal symbol, we have updated addend. */
4217 case R_X86_64_PC32_BND
:
4219 case R_X86_64_PLT32
:
4220 case R_X86_64_PLT32_BND
:
4223 case R_X86_64_GOTPCREL
:
4224 case R_X86_64_GOTPCRELX
:
4225 case R_X86_64_REX_GOTPCRELX
:
4226 case R_X86_64_GOTPCREL64
:
4227 base_got
= htab
->elf
.sgot
;
4228 off
= h
->got
.offset
;
4230 if (base_got
== NULL
)
4233 if (off
== (bfd_vma
) -1)
4235 /* We can't use h->got.offset here to save state, or
4236 even just remember the offset, as finish_dynamic_symbol
4237 would use that as offset into .got. */
4239 if (htab
->elf
.splt
!= NULL
)
4241 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4242 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4243 base_got
= htab
->elf
.sgotplt
;
4247 plt_index
= h
->plt
.offset
/ plt_entry_size
;
4248 off
= plt_index
* GOT_ENTRY_SIZE
;
4249 base_got
= htab
->elf
.igotplt
;
4252 if (h
->dynindx
== -1
4256 /* This references the local defitionion. We must
4257 initialize this entry in the global offset table.
4258 Since the offset must always be a multiple of 8,
4259 we use the least significant bit to record
4260 whether we have initialized it already.
4262 When doing a dynamic link, we create a .rela.got
4263 relocation entry to initialize the value. This
4264 is done in the finish_dynamic_symbol routine. */
4269 bfd_put_64 (output_bfd
, relocation
,
4270 base_got
->contents
+ off
);
4271 /* Note that this is harmless for the GOTPLT64
4272 case, as -1 | 1 still is -1. */
4278 relocation
= (base_got
->output_section
->vma
4279 + base_got
->output_offset
+ off
);
4285 resolved_to_zero
= (eh
!= NULL
4286 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, eh
));
4288 /* When generating a shared object, the relocations handled here are
4289 copied into the output file to be resolved at run time. */
4292 case R_X86_64_GOT32
:
4293 case R_X86_64_GOT64
:
4294 /* Relocation is to the entry for this symbol in the global
4296 case R_X86_64_GOTPCREL
:
4297 case R_X86_64_GOTPCRELX
:
4298 case R_X86_64_REX_GOTPCRELX
:
4299 case R_X86_64_GOTPCREL64
:
4300 /* Use global offset table entry as symbol value. */
4301 case R_X86_64_GOTPLT64
:
4302 /* This is obsolete and treated the the same as GOT64. */
4303 base_got
= htab
->elf
.sgot
;
4305 if (htab
->elf
.sgot
== NULL
)
4312 off
= h
->got
.offset
;
4314 && h
->plt
.offset
!= (bfd_vma
)-1
4315 && off
== (bfd_vma
)-1)
4317 /* We can't use h->got.offset here to save
4318 state, or even just remember the offset, as
4319 finish_dynamic_symbol would use that as offset into
4321 bfd_vma plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4322 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4323 base_got
= htab
->elf
.sgotplt
;
4326 dyn
= htab
->elf
.dynamic_sections_created
;
4328 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
4329 || (bfd_link_pic (info
)
4330 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4331 || (ELF_ST_VISIBILITY (h
->other
)
4332 && h
->root
.type
== bfd_link_hash_undefweak
))
4334 /* This is actually a static link, or it is a -Bsymbolic
4335 link and the symbol is defined locally, or the symbol
4336 was forced to be local because of a version file. We
4337 must initialize this entry in the global offset table.
4338 Since the offset must always be a multiple of 8, we
4339 use the least significant bit to record whether we
4340 have initialized it already.
4342 When doing a dynamic link, we create a .rela.got
4343 relocation entry to initialize the value. This is
4344 done in the finish_dynamic_symbol routine. */
4349 bfd_put_64 (output_bfd
, relocation
,
4350 base_got
->contents
+ off
);
4351 /* Note that this is harmless for the GOTPLT64 case,
4352 as -1 | 1 still is -1. */
4357 unresolved_reloc
= FALSE
;
4361 if (local_got_offsets
== NULL
)
4364 off
= local_got_offsets
[r_symndx
];
4366 /* The offset must always be a multiple of 8. We use
4367 the least significant bit to record whether we have
4368 already generated the necessary reloc. */
4373 bfd_put_64 (output_bfd
, relocation
,
4374 base_got
->contents
+ off
);
4376 if (bfd_link_pic (info
))
4379 Elf_Internal_Rela outrel
;
4381 /* We need to generate a R_X86_64_RELATIVE reloc
4382 for the dynamic linker. */
4383 s
= htab
->elf
.srelgot
;
4387 outrel
.r_offset
= (base_got
->output_section
->vma
4388 + base_got
->output_offset
4390 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4391 outrel
.r_addend
= relocation
;
4392 elf_append_rela (output_bfd
, s
, &outrel
);
4395 local_got_offsets
[r_symndx
] |= 1;
4399 if (off
>= (bfd_vma
) -2)
4402 relocation
= base_got
->output_section
->vma
4403 + base_got
->output_offset
+ off
;
4404 if (r_type
!= R_X86_64_GOTPCREL
4405 && r_type
!= R_X86_64_GOTPCRELX
4406 && r_type
!= R_X86_64_REX_GOTPCRELX
4407 && r_type
!= R_X86_64_GOTPCREL64
)
4408 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4409 - htab
->elf
.sgotplt
->output_offset
;
4413 case R_X86_64_GOTOFF64
:
4414 /* Relocation is relative to the start of the global offset
4417 /* Check to make sure it isn't a protected function or data
4418 symbol for shared library since it may not be local when
4419 used as function address or with copy relocation. We also
4420 need to make sure that a symbol is referenced locally. */
4421 if (bfd_link_pic (info
) && h
)
4423 if (!h
->def_regular
)
4427 switch (ELF_ST_VISIBILITY (h
->other
))
4430 v
= _("hidden symbol");
4433 v
= _("internal symbol");
4436 v
= _("protected symbol");
4443 (*_bfd_error_handler
)
4444 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s `%s' can not be used when making a shared object"),
4445 input_bfd
, v
, h
->root
.root
.string
);
4446 bfd_set_error (bfd_error_bad_value
);
4449 else if (!bfd_link_executable (info
)
4450 && !SYMBOL_REFERENCES_LOCAL (info
, h
)
4451 && (h
->type
== STT_FUNC
4452 || h
->type
== STT_OBJECT
)
4453 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4455 (*_bfd_error_handler
)
4456 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s `%s' can not be used when making a shared object"),
4458 h
->type
== STT_FUNC
? "function" : "data",
4459 h
->root
.root
.string
);
4460 bfd_set_error (bfd_error_bad_value
);
4465 /* Note that sgot is not involved in this
4466 calculation. We always want the start of .got.plt. If we
4467 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4468 permitted by the ABI, we might have to change this
4470 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4471 + htab
->elf
.sgotplt
->output_offset
;
4474 case R_X86_64_GOTPC32
:
4475 case R_X86_64_GOTPC64
:
4476 /* Use global offset table as symbol value. */
4477 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4478 + htab
->elf
.sgotplt
->output_offset
;
4479 unresolved_reloc
= FALSE
;
4482 case R_X86_64_PLTOFF64
:
4483 /* Relocation is PLT entry relative to GOT. For local
4484 symbols it's the symbol itself relative to GOT. */
4486 /* See PLT32 handling. */
4487 && h
->plt
.offset
!= (bfd_vma
) -1
4488 && htab
->elf
.splt
!= NULL
)
4490 if (htab
->plt_bnd
!= NULL
)
4492 resolved_plt
= htab
->plt_bnd
;
4493 plt_offset
= eh
->plt_bnd
.offset
;
4497 resolved_plt
= htab
->elf
.splt
;
4498 plt_offset
= h
->plt
.offset
;
4501 relocation
= (resolved_plt
->output_section
->vma
4502 + resolved_plt
->output_offset
4504 unresolved_reloc
= FALSE
;
4507 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4508 + htab
->elf
.sgotplt
->output_offset
;
4511 case R_X86_64_PLT32
:
4512 case R_X86_64_PLT32_BND
:
4513 /* Relocation is to the entry for this symbol in the
4514 procedure linkage table. */
4516 /* Resolve a PLT32 reloc against a local symbol directly,
4517 without using the procedure linkage table. */
4521 if ((h
->plt
.offset
== (bfd_vma
) -1
4522 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4523 || htab
->elf
.splt
== NULL
)
4525 /* We didn't make a PLT entry for this symbol. This
4526 happens when statically linking PIC code, or when
4527 using -Bsymbolic. */
4531 if (h
->plt
.offset
!= (bfd_vma
) -1)
4533 if (htab
->plt_bnd
!= NULL
)
4535 resolved_plt
= htab
->plt_bnd
;
4536 plt_offset
= eh
->plt_bnd
.offset
;
4540 resolved_plt
= htab
->elf
.splt
;
4541 plt_offset
= h
->plt
.offset
;
4546 /* Use the GOT PLT. */
4547 resolved_plt
= htab
->plt_got
;
4548 plt_offset
= eh
->plt_got
.offset
;
4551 relocation
= (resolved_plt
->output_section
->vma
4552 + resolved_plt
->output_offset
4554 unresolved_reloc
= FALSE
;
4557 case R_X86_64_SIZE32
:
4558 case R_X86_64_SIZE64
:
4559 /* Set to symbol size. */
4560 relocation
= st_size
;
4566 case R_X86_64_PC32_BND
:
4567 /* Don't complain about -fPIC if the symbol is undefined when
4568 building executable unless it is unresolved weak symbol. */
4569 if ((input_section
->flags
& SEC_ALLOC
) != 0
4570 && (input_section
->flags
& SEC_READONLY
) != 0
4572 && ((bfd_link_executable (info
)
4573 && h
->root
.type
== bfd_link_hash_undefweak
4574 && !resolved_to_zero
)
4575 || (bfd_link_pic (info
)
4576 && !(bfd_link_pie (info
)
4577 && h
->root
.type
== bfd_link_hash_undefined
))))
4579 bfd_boolean fail
= FALSE
;
4581 = ((r_type
== R_X86_64_PC32
4582 || r_type
== R_X86_64_PC32_BND
)
4583 && is_32bit_relative_branch (contents
, rel
->r_offset
));
4585 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
4587 /* Symbol is referenced locally. Make sure it is
4588 defined locally or for a branch. */
4589 fail
= !h
->def_regular
&& !branch
;
4591 else if (!(bfd_link_pie (info
)
4592 && (h
->needs_copy
|| eh
->needs_copy
)))
4594 /* Symbol doesn't need copy reloc and isn't referenced
4595 locally. We only allow branch to symbol with
4596 non-default visibility. */
4598 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
4602 return elf_x86_64_need_pic (input_bfd
, input_section
,
4603 h
, NULL
, NULL
, howto
);
4612 /* FIXME: The ABI says the linker should make sure the value is
4613 the same when it's zeroextended to 64 bit. */
4616 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4619 /* Don't copy a pc-relative relocation into the output file
4620 if the symbol needs copy reloc or the symbol is undefined
4621 when building executable. Copy dynamic function pointer
4622 relocations. Don't generate dynamic relocations against
4623 resolved undefined weak symbols in PIE. */
4624 if ((bfd_link_pic (info
)
4625 && !(bfd_link_pie (info
)
4629 || h
->root
.type
== bfd_link_hash_undefined
)
4630 && IS_X86_64_PCREL_TYPE (r_type
))
4632 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4633 && !resolved_to_zero
)
4634 || h
->root
.type
!= bfd_link_hash_undefweak
))
4635 && ((! IS_X86_64_PCREL_TYPE (r_type
)
4636 && r_type
!= R_X86_64_SIZE32
4637 && r_type
!= R_X86_64_SIZE64
)
4638 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
4639 || (ELIMINATE_COPY_RELOCS
4640 && !bfd_link_pic (info
)
4644 || eh
->func_pointer_refcount
> 0
4645 || (h
->root
.type
== bfd_link_hash_undefweak
4646 && !resolved_to_zero
))
4647 && ((h
->def_dynamic
&& !h
->def_regular
)
4648 /* Undefined weak symbol is bound locally when
4650 || h
->root
.type
== bfd_link_hash_undefined
)))
4652 Elf_Internal_Rela outrel
;
4653 bfd_boolean skip
, relocate
;
4656 /* When generating a shared object, these relocations
4657 are copied into the output file to be resolved at run
4663 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4665 if (outrel
.r_offset
== (bfd_vma
) -1)
4667 else if (outrel
.r_offset
== (bfd_vma
) -2)
4668 skip
= TRUE
, relocate
= TRUE
;
4670 outrel
.r_offset
+= (input_section
->output_section
->vma
4671 + input_section
->output_offset
);
4674 memset (&outrel
, 0, sizeof outrel
);
4676 /* h->dynindx may be -1 if this symbol was marked to
4680 && (IS_X86_64_PCREL_TYPE (r_type
)
4681 || !(bfd_link_executable (info
)
4682 || SYMBOLIC_BIND (info
, h
))
4683 || ! h
->def_regular
))
4685 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4686 outrel
.r_addend
= rel
->r_addend
;
4690 /* This symbol is local, or marked to become local.
4691 When relocation overflow check is disabled, we
4692 convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */
4693 if (r_type
== htab
->pointer_r_type
4694 || (r_type
== R_X86_64_32
4695 && info
->no_reloc_overflow_check
))
4698 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4699 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4701 else if (r_type
== R_X86_64_64
4702 && !ABI_64_P (output_bfd
))
4705 outrel
.r_info
= htab
->r_info (0,
4706 R_X86_64_RELATIVE64
);
4707 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4708 /* Check addend overflow. */
4709 if ((outrel
.r_addend
& 0x80000000)
4710 != (rel
->r_addend
& 0x80000000))
4713 int addend
= rel
->r_addend
;
4714 if (h
&& h
->root
.root
.string
)
4715 name
= h
->root
.root
.string
;
4717 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4720 (*_bfd_error_handler
)
4721 (_("%B: addend -0x%x in relocation %s against "
4722 "symbol `%s' at 0x%lx in section `%A' is "
4724 input_bfd
, input_section
, addend
,
4726 (unsigned long) rel
->r_offset
);
4728 (*_bfd_error_handler
)
4729 (_("%B: addend 0x%x in relocation %s against "
4730 "symbol `%s' at 0x%lx in section `%A' is "
4732 input_bfd
, input_section
, addend
,
4734 (unsigned long) rel
->r_offset
);
4735 bfd_set_error (bfd_error_bad_value
);
4743 if (bfd_is_abs_section (sec
))
4745 else if (sec
== NULL
|| sec
->owner
== NULL
)
4747 bfd_set_error (bfd_error_bad_value
);
4754 /* We are turning this relocation into one
4755 against a section symbol. It would be
4756 proper to subtract the symbol's value,
4757 osec->vma, from the emitted reloc addend,
4758 but ld.so expects buggy relocs. */
4759 osec
= sec
->output_section
;
4760 sindx
= elf_section_data (osec
)->dynindx
;
4763 asection
*oi
= htab
->elf
.text_index_section
;
4764 sindx
= elf_section_data (oi
)->dynindx
;
4766 BFD_ASSERT (sindx
!= 0);
4769 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
4770 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4774 sreloc
= elf_section_data (input_section
)->sreloc
;
4776 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4778 r
= bfd_reloc_notsupported
;
4779 goto check_relocation_error
;
4782 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4784 /* If this reloc is against an external symbol, we do
4785 not want to fiddle with the addend. Otherwise, we
4786 need to include the symbol value so that it becomes
4787 an addend for the dynamic reloc. */
4794 case R_X86_64_TLSGD
:
4795 case R_X86_64_GOTPC32_TLSDESC
:
4796 case R_X86_64_TLSDESC_CALL
:
4797 case R_X86_64_GOTTPOFF
:
4798 tls_type
= GOT_UNKNOWN
;
4799 if (h
== NULL
&& local_got_offsets
)
4800 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
4802 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
4804 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4805 input_section
, contents
,
4806 symtab_hdr
, sym_hashes
,
4807 &r_type
, tls_type
, rel
,
4808 relend
, h
, r_symndx
))
4811 if (r_type
== R_X86_64_TPOFF32
)
4813 bfd_vma roff
= rel
->r_offset
;
4815 BFD_ASSERT (! unresolved_reloc
);
4817 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4819 /* GD->LE transition. For 64bit, change
4820 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4821 .word 0x6666; rex64; call __tls_get_addr
4824 leaq foo@tpoff(%rax), %rax
4826 leaq foo@tlsgd(%rip), %rdi
4827 .word 0x6666; rex64; call __tls_get_addr
4830 leaq foo@tpoff(%rax), %rax
4831 For largepic, change:
4832 leaq foo@tlsgd(%rip), %rdi
4833 movabsq $__tls_get_addr@pltoff, %rax
4838 leaq foo@tpoff(%rax), %rax
4839 nopw 0x0(%rax,%rax,1) */
4841 if (ABI_64_P (output_bfd
)
4842 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
4844 memcpy (contents
+ roff
- 3,
4845 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
4846 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4849 else if (ABI_64_P (output_bfd
))
4850 memcpy (contents
+ roff
- 4,
4851 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4854 memcpy (contents
+ roff
- 3,
4855 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4857 bfd_put_32 (output_bfd
,
4858 elf_x86_64_tpoff (info
, relocation
),
4859 contents
+ roff
+ 8 + largepic
);
4860 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4865 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
4867 /* GDesc -> LE transition.
4868 It's originally something like:
4869 leaq x@tlsdesc(%rip), %rax
4872 movl $x@tpoff, %rax. */
4874 unsigned int val
, type
;
4876 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4877 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4878 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
4879 contents
+ roff
- 3);
4880 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
4881 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4882 contents
+ roff
- 1);
4883 bfd_put_32 (output_bfd
,
4884 elf_x86_64_tpoff (info
, relocation
),
4888 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
4890 /* GDesc -> LE transition.
4895 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4896 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4899 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
4901 /* IE->LE transition:
4902 For 64bit, originally it can be one of:
4903 movq foo@gottpoff(%rip), %reg
4904 addq foo@gottpoff(%rip), %reg
4907 leaq foo(%reg), %reg
4909 For 32bit, originally it can be one of:
4910 movq foo@gottpoff(%rip), %reg
4911 addl foo@gottpoff(%rip), %reg
4914 leal foo(%reg), %reg
4917 unsigned int val
, type
, reg
;
4920 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4923 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
4924 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4930 bfd_put_8 (output_bfd
, 0x49,
4931 contents
+ roff
- 3);
4932 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4933 bfd_put_8 (output_bfd
, 0x41,
4934 contents
+ roff
- 3);
4935 bfd_put_8 (output_bfd
, 0xc7,
4936 contents
+ roff
- 2);
4937 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4938 contents
+ roff
- 1);
4942 /* addq/addl -> addq/addl - addressing with %rsp/%r12
4945 bfd_put_8 (output_bfd
, 0x49,
4946 contents
+ roff
- 3);
4947 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4948 bfd_put_8 (output_bfd
, 0x41,
4949 contents
+ roff
- 3);
4950 bfd_put_8 (output_bfd
, 0x81,
4951 contents
+ roff
- 2);
4952 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4953 contents
+ roff
- 1);
4957 /* addq/addl -> leaq/leal */
4959 bfd_put_8 (output_bfd
, 0x4d,
4960 contents
+ roff
- 3);
4961 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4962 bfd_put_8 (output_bfd
, 0x45,
4963 contents
+ roff
- 3);
4964 bfd_put_8 (output_bfd
, 0x8d,
4965 contents
+ roff
- 2);
4966 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
4967 contents
+ roff
- 1);
4969 bfd_put_32 (output_bfd
,
4970 elf_x86_64_tpoff (info
, relocation
),
4978 if (htab
->elf
.sgot
== NULL
)
4983 off
= h
->got
.offset
;
4984 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
4988 if (local_got_offsets
== NULL
)
4991 off
= local_got_offsets
[r_symndx
];
4992 offplt
= local_tlsdesc_gotents
[r_symndx
];
4999 Elf_Internal_Rela outrel
;
5003 if (htab
->elf
.srelgot
== NULL
)
5006 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
5008 if (GOT_TLS_GDESC_P (tls_type
))
5010 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
5011 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
5012 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
5013 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5014 + htab
->elf
.sgotplt
->output_offset
5016 + htab
->sgotplt_jump_table_size
);
5017 sreloc
= htab
->elf
.srelplt
;
5019 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5021 outrel
.r_addend
= 0;
5022 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5025 sreloc
= htab
->elf
.srelgot
;
5027 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5028 + htab
->elf
.sgot
->output_offset
+ off
);
5030 if (GOT_TLS_GD_P (tls_type
))
5031 dr_type
= R_X86_64_DTPMOD64
;
5032 else if (GOT_TLS_GDESC_P (tls_type
))
5035 dr_type
= R_X86_64_TPOFF64
;
5037 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
5038 outrel
.r_addend
= 0;
5039 if ((dr_type
== R_X86_64_TPOFF64
5040 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
5041 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5042 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
5044 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5046 if (GOT_TLS_GD_P (tls_type
))
5050 BFD_ASSERT (! unresolved_reloc
);
5051 bfd_put_64 (output_bfd
,
5052 relocation
- elf_x86_64_dtpoff_base (info
),
5053 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5057 bfd_put_64 (output_bfd
, 0,
5058 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5059 outrel
.r_info
= htab
->r_info (indx
,
5061 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
5062 elf_append_rela (output_bfd
, sreloc
,
5071 local_got_offsets
[r_symndx
] |= 1;
5074 if (off
>= (bfd_vma
) -2
5075 && ! GOT_TLS_GDESC_P (tls_type
))
5077 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
5079 if (r_type
== R_X86_64_GOTPC32_TLSDESC
5080 || r_type
== R_X86_64_TLSDESC_CALL
)
5081 relocation
= htab
->elf
.sgotplt
->output_section
->vma
5082 + htab
->elf
.sgotplt
->output_offset
5083 + offplt
+ htab
->sgotplt_jump_table_size
;
5085 relocation
= htab
->elf
.sgot
->output_section
->vma
5086 + htab
->elf
.sgot
->output_offset
+ off
;
5087 unresolved_reloc
= FALSE
;
5091 bfd_vma roff
= rel
->r_offset
;
5093 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5095 /* GD->IE transition. For 64bit, change
5096 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5097 .word 0x6666; rex64; call __tls_get_addr@plt
5100 addq foo@gottpoff(%rip), %rax
5102 leaq foo@tlsgd(%rip), %rdi
5103 .word 0x6666; rex64; call __tls_get_addr@plt
5106 addq foo@gottpoff(%rip), %rax
5107 For largepic, change:
5108 leaq foo@tlsgd(%rip), %rdi
5109 movabsq $__tls_get_addr@pltoff, %rax
5114 addq foo@gottpoff(%rax), %rax
5115 nopw 0x0(%rax,%rax,1) */
5117 if (ABI_64_P (output_bfd
)
5118 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
5120 memcpy (contents
+ roff
- 3,
5121 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
5122 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5125 else if (ABI_64_P (output_bfd
))
5126 memcpy (contents
+ roff
- 4,
5127 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5130 memcpy (contents
+ roff
- 3,
5131 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5134 relocation
= (htab
->elf
.sgot
->output_section
->vma
5135 + htab
->elf
.sgot
->output_offset
+ off
5138 - input_section
->output_section
->vma
5139 - input_section
->output_offset
5141 bfd_put_32 (output_bfd
, relocation
,
5142 contents
+ roff
+ 8 + largepic
);
5143 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5148 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5150 /* GDesc -> IE transition.
5151 It's originally something like:
5152 leaq x@tlsdesc(%rip), %rax
5155 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
5157 /* Now modify the instruction as appropriate. To
5158 turn a leaq into a movq in the form we use it, it
5159 suffices to change the second byte from 0x8d to
5161 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
5163 bfd_put_32 (output_bfd
,
5164 htab
->elf
.sgot
->output_section
->vma
5165 + htab
->elf
.sgot
->output_offset
+ off
5167 - input_section
->output_section
->vma
5168 - input_section
->output_offset
5173 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5175 /* GDesc -> IE transition.
5182 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5183 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5191 case R_X86_64_TLSLD
:
5192 if (! elf_x86_64_tls_transition (info
, input_bfd
,
5193 input_section
, contents
,
5194 symtab_hdr
, sym_hashes
,
5195 &r_type
, GOT_UNKNOWN
,
5196 rel
, relend
, h
, r_symndx
))
5199 if (r_type
!= R_X86_64_TLSLD
)
5201 /* LD->LE transition:
5202 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
5203 For 64bit, we change it into:
5204 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
5205 For 32bit, we change it into:
5206 nopl 0x0(%rax); movl %fs:0, %eax.
5207 For largepic, change:
5208 leaq foo@tlsgd(%rip), %rdi
5209 movabsq $__tls_get_addr@pltoff, %rax
5213 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
5216 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
5217 if (ABI_64_P (output_bfd
)
5218 && contents
[rel
->r_offset
+ 5] == (bfd_byte
) '\xb8')
5219 memcpy (contents
+ rel
->r_offset
- 3,
5220 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
5221 "\x64\x48\x8b\x04\x25\0\0\0", 22);
5222 else if (ABI_64_P (output_bfd
))
5223 memcpy (contents
+ rel
->r_offset
- 3,
5224 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
5226 memcpy (contents
+ rel
->r_offset
- 3,
5227 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
5228 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5234 if (htab
->elf
.sgot
== NULL
)
5237 off
= htab
->tls_ld_got
.offset
;
5242 Elf_Internal_Rela outrel
;
5244 if (htab
->elf
.srelgot
== NULL
)
5247 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5248 + htab
->elf
.sgot
->output_offset
+ off
);
5250 bfd_put_64 (output_bfd
, 0,
5251 htab
->elf
.sgot
->contents
+ off
);
5252 bfd_put_64 (output_bfd
, 0,
5253 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5254 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
5255 outrel
.r_addend
= 0;
5256 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
5258 htab
->tls_ld_got
.offset
|= 1;
5260 relocation
= htab
->elf
.sgot
->output_section
->vma
5261 + htab
->elf
.sgot
->output_offset
+ off
;
5262 unresolved_reloc
= FALSE
;
5265 case R_X86_64_DTPOFF32
:
5266 if (!bfd_link_executable (info
)
5267 || (input_section
->flags
& SEC_CODE
) == 0)
5268 relocation
-= elf_x86_64_dtpoff_base (info
);
5270 relocation
= elf_x86_64_tpoff (info
, relocation
);
5273 case R_X86_64_TPOFF32
:
5274 case R_X86_64_TPOFF64
:
5275 BFD_ASSERT (bfd_link_executable (info
));
5276 relocation
= elf_x86_64_tpoff (info
, relocation
);
5279 case R_X86_64_DTPOFF64
:
5280 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
5281 relocation
-= elf_x86_64_dtpoff_base (info
);
5288 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5289 because such sections are not SEC_ALLOC and thus ld.so will
5290 not process them. */
5291 if (unresolved_reloc
5292 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
5294 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5295 rel
->r_offset
) != (bfd_vma
) -1)
5297 (*_bfd_error_handler
)
5298 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5301 (long) rel
->r_offset
,
5303 h
->root
.root
.string
);
5308 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5309 contents
, rel
->r_offset
,
5310 relocation
, rel
->r_addend
);
5312 check_relocation_error
:
5313 if (r
!= bfd_reloc_ok
)
5318 name
= h
->root
.root
.string
;
5321 name
= bfd_elf_string_from_elf_section (input_bfd
,
5322 symtab_hdr
->sh_link
,
5327 name
= bfd_section_name (input_bfd
, sec
);
5330 if (r
== bfd_reloc_overflow
)
5332 if (! ((*info
->callbacks
->reloc_overflow
)
5333 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5334 (bfd_vma
) 0, input_bfd
, input_section
,
5340 (*_bfd_error_handler
)
5341 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5342 input_bfd
, input_section
,
5343 (long) rel
->r_offset
, name
, (int) r
);
5354 Elf_Internal_Shdr
*rel_hdr
;
5355 size_t deleted
= rel
- wrel
;
5357 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
5358 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5359 if (rel_hdr
->sh_size
== 0)
5361 /* It is too late to remove an empty reloc section. Leave
5363 ??? What is wrong with an empty section??? */
5364 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
5367 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5368 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5369 input_section
->reloc_count
-= deleted
;
5375 /* Finish up dynamic symbol handling. We set the contents of various
5376 dynamic sections here. */
5379 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
5380 struct bfd_link_info
*info
,
5381 struct elf_link_hash_entry
*h
,
5382 Elf_Internal_Sym
*sym
)
5384 struct elf_x86_64_link_hash_table
*htab
;
5385 const struct elf_x86_64_backend_data
*abed
;
5386 bfd_boolean use_plt_bnd
;
5387 struct elf_x86_64_link_hash_entry
*eh
;
5388 bfd_boolean local_undefweak
;
5390 htab
= elf_x86_64_hash_table (info
);
5394 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5395 section only if there is .plt section. */
5396 use_plt_bnd
= htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
;
5398 ? &elf_x86_64_bnd_arch_bed
5399 : get_elf_x86_64_backend_data (output_bfd
));
5401 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
5403 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5404 resolved undefined weak symbols in executable so that their
5405 references have value 0 at run-time. */
5406 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, eh
);
5408 if (h
->plt
.offset
!= (bfd_vma
) -1)
5411 bfd_vma got_offset
, plt_offset
, plt_plt_offset
, plt_got_offset
;
5412 bfd_vma plt_plt_insn_end
, plt_got_insn_size
;
5413 Elf_Internal_Rela rela
;
5415 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
5416 const struct elf_backend_data
*bed
;
5417 bfd_vma plt_got_pcrel_offset
;
5419 /* When building a static executable, use .iplt, .igot.plt and
5420 .rela.iplt sections for STT_GNU_IFUNC symbols. */
5421 if (htab
->elf
.splt
!= NULL
)
5423 plt
= htab
->elf
.splt
;
5424 gotplt
= htab
->elf
.sgotplt
;
5425 relplt
= htab
->elf
.srelplt
;
5429 plt
= htab
->elf
.iplt
;
5430 gotplt
= htab
->elf
.igotplt
;
5431 relplt
= htab
->elf
.irelplt
;
5434 /* This symbol has an entry in the procedure linkage table. Set
5436 if ((h
->dynindx
== -1
5438 && !((h
->forced_local
|| bfd_link_executable (info
))
5440 && h
->type
== STT_GNU_IFUNC
))
5446 /* Get the index in the procedure linkage table which
5447 corresponds to this symbol. This is the index of this symbol
5448 in all the symbols for which we are making plt entries. The
5449 first entry in the procedure linkage table is reserved.
5451 Get the offset into the .got table of the entry that
5452 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
5453 bytes. The first three are reserved for the dynamic linker.
5455 For static executables, we don't reserve anything. */
5457 if (plt
== htab
->elf
.splt
)
5459 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
5460 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
5464 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
5465 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
5468 plt_plt_insn_end
= abed
->plt_plt_insn_end
;
5469 plt_plt_offset
= abed
->plt_plt_offset
;
5470 plt_got_insn_size
= abed
->plt_got_insn_size
;
5471 plt_got_offset
= abed
->plt_got_offset
;
5474 /* Use the second PLT with BND relocations. */
5475 const bfd_byte
*plt_entry
, *plt2_entry
;
5477 if (eh
->has_bnd_reloc
)
5479 plt_entry
= elf_x86_64_bnd_plt_entry
;
5480 plt2_entry
= elf_x86_64_bnd_plt2_entry
;
5484 plt_entry
= elf_x86_64_legacy_plt_entry
;
5485 plt2_entry
= elf_x86_64_legacy_plt2_entry
;
5487 /* Subtract 1 since there is no BND prefix. */
5488 plt_plt_insn_end
-= 1;
5489 plt_plt_offset
-= 1;
5490 plt_got_insn_size
-= 1;
5491 plt_got_offset
-= 1;
5494 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry
)
5495 == sizeof (elf_x86_64_legacy_plt_entry
));
5497 /* Fill in the entry in the procedure linkage table. */
5498 memcpy (plt
->contents
+ h
->plt
.offset
,
5499 plt_entry
, sizeof (elf_x86_64_legacy_plt_entry
));
5500 /* Fill in the entry in the second PLT. */
5501 memcpy (htab
->plt_bnd
->contents
+ eh
->plt_bnd
.offset
,
5502 plt2_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5504 resolved_plt
= htab
->plt_bnd
;
5505 plt_offset
= eh
->plt_bnd
.offset
;
5509 /* Fill in the entry in the procedure linkage table. */
5510 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
5511 abed
->plt_entry_size
);
5514 plt_offset
= h
->plt
.offset
;
5517 /* Insert the relocation positions of the plt section. */
5519 /* Put offset the PC-relative instruction referring to the GOT entry,
5520 subtracting the size of that instruction. */
5521 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
5522 + gotplt
->output_offset
5524 - resolved_plt
->output_section
->vma
5525 - resolved_plt
->output_offset
5527 - plt_got_insn_size
);
5529 /* Check PC-relative offset overflow in PLT entry. */
5530 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
5531 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5532 output_bfd
, h
->root
.root
.string
);
5534 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
5535 resolved_plt
->contents
+ plt_offset
+ plt_got_offset
);
5537 /* Fill in the entry in the global offset table, initially this
5538 points to the second part of the PLT entry. Leave the entry
5539 as zero for undefined weak symbol in PIE. No PLT relocation
5540 against undefined weak symbol in PIE. */
5541 if (!local_undefweak
)
5543 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5544 + plt
->output_offset
5546 + abed
->plt_lazy_offset
),
5547 gotplt
->contents
+ got_offset
);
5549 /* Fill in the entry in the .rela.plt section. */
5550 rela
.r_offset
= (gotplt
->output_section
->vma
5551 + gotplt
->output_offset
5553 if (h
->dynindx
== -1
5554 || ((bfd_link_executable (info
)
5555 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5557 && h
->type
== STT_GNU_IFUNC
))
5559 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5560 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
5561 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
5562 rela
.r_addend
= (h
->root
.u
.def
.value
5563 + h
->root
.u
.def
.section
->output_section
->vma
5564 + h
->root
.u
.def
.section
->output_offset
);
5565 /* R_X86_64_IRELATIVE comes last. */
5566 plt_index
= htab
->next_irelative_index
--;
5570 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
5572 plt_index
= htab
->next_jump_slot_index
++;
5575 /* Don't fill PLT entry for static executables. */
5576 if (plt
== htab
->elf
.splt
)
5578 bfd_vma plt0_offset
= h
->plt
.offset
+ plt_plt_insn_end
;
5580 /* Put relocation index. */
5581 bfd_put_32 (output_bfd
, plt_index
,
5582 (plt
->contents
+ h
->plt
.offset
5583 + abed
->plt_reloc_offset
));
5585 /* Put offset for jmp .PLT0 and check for overflow. We don't
5586 check relocation index for overflow since branch displacement
5587 will overflow first. */
5588 if (plt0_offset
> 0x80000000)
5589 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5590 output_bfd
, h
->root
.root
.string
);
5591 bfd_put_32 (output_bfd
, - plt0_offset
,
5592 plt
->contents
+ h
->plt
.offset
+ plt_plt_offset
);
5595 bed
= get_elf_backend_data (output_bfd
);
5596 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
5597 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
5600 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5602 bfd_vma got_offset
, plt_offset
, plt_got_offset
, plt_got_insn_size
;
5603 asection
*plt
, *got
;
5604 bfd_boolean got_after_plt
;
5605 int32_t got_pcrel_offset
;
5606 const bfd_byte
*got_plt_entry
;
5608 /* Set the entry in the GOT procedure linkage table. */
5609 plt
= htab
->plt_got
;
5610 got
= htab
->elf
.sgot
;
5611 got_offset
= h
->got
.offset
;
5613 if (got_offset
== (bfd_vma
) -1
5614 || h
->type
== STT_GNU_IFUNC
5619 /* Use the second PLT entry template for the GOT PLT since they
5620 are the identical. */
5621 plt_got_insn_size
= elf_x86_64_bnd_arch_bed
.plt_got_insn_size
;
5622 plt_got_offset
= elf_x86_64_bnd_arch_bed
.plt_got_offset
;
5623 if (eh
->has_bnd_reloc
)
5624 got_plt_entry
= elf_x86_64_bnd_plt2_entry
;
5627 got_plt_entry
= elf_x86_64_legacy_plt2_entry
;
5629 /* Subtract 1 since there is no BND prefix. */
5630 plt_got_insn_size
-= 1;
5631 plt_got_offset
-= 1;
5634 /* Fill in the entry in the GOT procedure linkage table. */
5635 plt_offset
= eh
->plt_got
.offset
;
5636 memcpy (plt
->contents
+ plt_offset
,
5637 got_plt_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5639 /* Put offset the PC-relative instruction referring to the GOT
5640 entry, subtracting the size of that instruction. */
5641 got_pcrel_offset
= (got
->output_section
->vma
5642 + got
->output_offset
5644 - plt
->output_section
->vma
5645 - plt
->output_offset
5647 - plt_got_insn_size
);
5649 /* Check PC-relative offset overflow in GOT PLT entry. */
5650 got_after_plt
= got
->output_section
->vma
> plt
->output_section
->vma
;
5651 if ((got_after_plt
&& got_pcrel_offset
< 0)
5652 || (!got_after_plt
&& got_pcrel_offset
> 0))
5653 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
5654 output_bfd
, h
->root
.root
.string
);
5656 bfd_put_32 (output_bfd
, got_pcrel_offset
,
5657 plt
->contents
+ plt_offset
+ plt_got_offset
);
5660 if (!local_undefweak
5662 && (h
->plt
.offset
!= (bfd_vma
) -1
5663 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5665 /* Mark the symbol as undefined, rather than as defined in
5666 the .plt section. Leave the value if there were any
5667 relocations where pointer equality matters (this is a clue
5668 for the dynamic linker, to make function pointer
5669 comparisons work between an application and shared
5670 library), otherwise set it to zero. If a function is only
5671 called from a binary, there is no need to slow down
5672 shared libraries because of that. */
5673 sym
->st_shndx
= SHN_UNDEF
;
5674 if (!h
->pointer_equality_needed
)
5678 /* Don't generate dynamic GOT relocation against undefined weak
5679 symbol in executable. */
5680 if (h
->got
.offset
!= (bfd_vma
) -1
5681 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
5682 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
5683 && !local_undefweak
)
5685 Elf_Internal_Rela rela
;
5687 /* This symbol has an entry in the global offset table. Set it
5689 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5692 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5693 + htab
->elf
.sgot
->output_offset
5694 + (h
->got
.offset
&~ (bfd_vma
) 1));
5696 /* If this is a static link, or it is a -Bsymbolic link and the
5697 symbol is defined locally or was forced to be local because
5698 of a version file, we just want to emit a RELATIVE reloc.
5699 The entry in the global offset table will already have been
5700 initialized in the relocate_section function. */
5702 && h
->type
== STT_GNU_IFUNC
)
5704 if (bfd_link_pic (info
))
5706 /* Generate R_X86_64_GLOB_DAT. */
5713 if (!h
->pointer_equality_needed
)
5716 /* For non-shared object, we can't use .got.plt, which
5717 contains the real function addres if we need pointer
5718 equality. We load the GOT entry with the PLT entry. */
5719 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5720 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5721 + plt
->output_offset
5723 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5727 else if (bfd_link_pic (info
)
5728 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5730 if (!h
->def_regular
)
5732 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5733 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
5734 rela
.r_addend
= (h
->root
.u
.def
.value
5735 + h
->root
.u
.def
.section
->output_section
->vma
5736 + h
->root
.u
.def
.section
->output_offset
);
5740 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5742 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5743 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5744 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
5748 elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &rela
);
5753 Elf_Internal_Rela rela
;
5755 /* This symbol needs a copy reloc. Set it up. */
5757 if (h
->dynindx
== -1
5758 || (h
->root
.type
!= bfd_link_hash_defined
5759 && h
->root
.type
!= bfd_link_hash_defweak
)
5760 || htab
->srelbss
== NULL
)
5763 rela
.r_offset
= (h
->root
.u
.def
.value
5764 + h
->root
.u
.def
.section
->output_section
->vma
5765 + h
->root
.u
.def
.section
->output_offset
);
5766 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
5768 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
5774 /* Finish up local dynamic symbol handling. We set the contents of
5775 various dynamic sections here. */
5778 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
5780 struct elf_link_hash_entry
*h
5781 = (struct elf_link_hash_entry
*) *slot
;
5782 struct bfd_link_info
*info
5783 = (struct bfd_link_info
*) inf
;
5785 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5789 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5790 here since undefined weak symbol may not be dynamic and may not be
5791 called for elf_x86_64_finish_dynamic_symbol. */
5794 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
5797 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
5798 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5800 if (h
->root
.type
!= bfd_link_hash_undefweak
5801 || h
->dynindx
!= -1)
5804 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5808 /* Used to decide how to sort relocs in an optimal manner for the
5809 dynamic linker, before writing them out. */
5811 static enum elf_reloc_type_class
5812 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info
,
5813 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5814 const Elf_Internal_Rela
*rela
)
5816 bfd
*abfd
= info
->output_bfd
;
5817 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5818 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
5820 if (htab
->elf
.dynsym
!= NULL
5821 && htab
->elf
.dynsym
->contents
!= NULL
)
5823 /* Check relocation against STT_GNU_IFUNC symbol if there are
5825 unsigned long r_symndx
= htab
->r_sym (rela
->r_info
);
5826 Elf_Internal_Sym sym
;
5827 if (!bed
->s
->swap_symbol_in (abfd
,
5828 (htab
->elf
.dynsym
->contents
5829 + r_symndx
* bed
->s
->sizeof_sym
),
5833 if (ELF_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
5834 return reloc_class_ifunc
;
5837 switch ((int) ELF32_R_TYPE (rela
->r_info
))
5839 case R_X86_64_RELATIVE
:
5840 case R_X86_64_RELATIVE64
:
5841 return reloc_class_relative
;
5842 case R_X86_64_JUMP_SLOT
:
5843 return reloc_class_plt
;
5845 return reloc_class_copy
;
5847 return reloc_class_normal
;
5851 /* Finish up the dynamic sections. */
5854 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
5855 struct bfd_link_info
*info
)
5857 struct elf_x86_64_link_hash_table
*htab
;
5860 const struct elf_x86_64_backend_data
*abed
;
5862 htab
= elf_x86_64_hash_table (info
);
5866 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5867 section only if there is .plt section. */
5868 abed
= (htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
5869 ? &elf_x86_64_bnd_arch_bed
5870 : get_elf_x86_64_backend_data (output_bfd
));
5872 dynobj
= htab
->elf
.dynobj
;
5873 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
5875 if (htab
->elf
.dynamic_sections_created
)
5877 bfd_byte
*dyncon
, *dynconend
;
5878 const struct elf_backend_data
*bed
;
5879 bfd_size_type sizeof_dyn
;
5881 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
5884 bed
= get_elf_backend_data (dynobj
);
5885 sizeof_dyn
= bed
->s
->sizeof_dyn
;
5886 dyncon
= sdyn
->contents
;
5887 dynconend
= sdyn
->contents
+ sdyn
->size
;
5888 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
5890 Elf_Internal_Dyn dyn
;
5893 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
5901 s
= htab
->elf
.sgotplt
;
5902 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5906 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
5910 s
= htab
->elf
.srelplt
->output_section
;
5911 dyn
.d_un
.d_val
= s
->size
;
5915 /* The procedure linkage table relocs (DT_JMPREL) should
5916 not be included in the overall relocs (DT_RELA).
5917 Therefore, we override the DT_RELASZ entry here to
5918 make it not include the JMPREL relocs. Since the
5919 linker script arranges for .rela.plt to follow all
5920 other relocation sections, we don't have to worry
5921 about changing the DT_RELA entry. */
5922 if (htab
->elf
.srelplt
!= NULL
)
5924 s
= htab
->elf
.srelplt
->output_section
;
5925 dyn
.d_un
.d_val
-= s
->size
;
5929 case DT_TLSDESC_PLT
:
5931 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5932 + htab
->tlsdesc_plt
;
5935 case DT_TLSDESC_GOT
:
5937 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5938 + htab
->tlsdesc_got
;
5942 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
5945 /* Fill in the special first entry in the procedure linkage table. */
5946 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
5948 /* Fill in the first entry in the procedure linkage table. */
5949 memcpy (htab
->elf
.splt
->contents
,
5950 abed
->plt0_entry
, abed
->plt_entry_size
);
5951 /* Add offset for pushq GOT+8(%rip), since the instruction
5952 uses 6 bytes subtract this value. */
5953 bfd_put_32 (output_bfd
,
5954 (htab
->elf
.sgotplt
->output_section
->vma
5955 + htab
->elf
.sgotplt
->output_offset
5957 - htab
->elf
.splt
->output_section
->vma
5958 - htab
->elf
.splt
->output_offset
5960 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
5961 /* Add offset for the PC-relative instruction accessing GOT+16,
5962 subtracting the offset to the end of that instruction. */
5963 bfd_put_32 (output_bfd
,
5964 (htab
->elf
.sgotplt
->output_section
->vma
5965 + htab
->elf
.sgotplt
->output_offset
5967 - htab
->elf
.splt
->output_section
->vma
5968 - htab
->elf
.splt
->output_offset
5969 - abed
->plt0_got2_insn_end
),
5970 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
5972 elf_section_data (htab
->elf
.splt
->output_section
)
5973 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
5975 if (htab
->tlsdesc_plt
)
5977 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5978 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
5980 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
5981 abed
->plt0_entry
, abed
->plt_entry_size
);
5983 /* Add offset for pushq GOT+8(%rip), since the
5984 instruction uses 6 bytes subtract this value. */
5985 bfd_put_32 (output_bfd
,
5986 (htab
->elf
.sgotplt
->output_section
->vma
5987 + htab
->elf
.sgotplt
->output_offset
5989 - htab
->elf
.splt
->output_section
->vma
5990 - htab
->elf
.splt
->output_offset
5993 htab
->elf
.splt
->contents
5994 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
5995 /* Add offset for the PC-relative instruction accessing GOT+TDG,
5996 where TGD stands for htab->tlsdesc_got, subtracting the offset
5997 to the end of that instruction. */
5998 bfd_put_32 (output_bfd
,
5999 (htab
->elf
.sgot
->output_section
->vma
6000 + htab
->elf
.sgot
->output_offset
6002 - htab
->elf
.splt
->output_section
->vma
6003 - htab
->elf
.splt
->output_offset
6005 - abed
->plt0_got2_insn_end
),
6006 htab
->elf
.splt
->contents
6007 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
6012 if (htab
->plt_bnd
!= NULL
)
6013 elf_section_data (htab
->plt_bnd
->output_section
)
6014 ->this_hdr
.sh_entsize
= sizeof (elf_x86_64_bnd_plt2_entry
);
6016 if (htab
->elf
.sgotplt
)
6018 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
6020 (*_bfd_error_handler
)
6021 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
6025 /* Fill in the first three entries in the global offset table. */
6026 if (htab
->elf
.sgotplt
->size
> 0)
6028 /* Set the first entry in the global offset table to the address of
6029 the dynamic section. */
6031 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
6033 bfd_put_64 (output_bfd
,
6034 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
6035 htab
->elf
.sgotplt
->contents
);
6036 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
6037 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
6038 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
6041 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
6045 /* Adjust .eh_frame for .plt section. */
6046 if (htab
->plt_eh_frame
!= NULL
6047 && htab
->plt_eh_frame
->contents
!= NULL
)
6049 if (htab
->elf
.splt
!= NULL
6050 && htab
->elf
.splt
->size
!= 0
6051 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
6052 && htab
->elf
.splt
->output_section
!= NULL
6053 && htab
->plt_eh_frame
->output_section
!= NULL
)
6055 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
6056 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
6057 + htab
->plt_eh_frame
->output_offset
6058 + PLT_FDE_START_OFFSET
;
6059 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6060 htab
->plt_eh_frame
->contents
6061 + PLT_FDE_START_OFFSET
);
6063 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
6065 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6067 htab
->plt_eh_frame
->contents
))
6072 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
6073 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
6076 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
6077 htab_traverse (htab
->loc_hash_table
,
6078 elf_x86_64_finish_local_dynamic_symbol
,
6081 /* Fill PLT entries for undefined weak symbols in PIE. */
6082 if (bfd_link_pie (info
))
6083 bfd_hash_traverse (&info
->hash
->table
,
6084 elf_x86_64_pie_finish_undefweak_symbol
,
6090 /* Return an array of PLT entry symbol values. */
6093 elf_x86_64_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
6096 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
6099 bfd_vma
*plt_sym_val
;
6101 bfd_byte
*plt_contents
;
6102 const struct elf_x86_64_backend_data
*bed
;
6103 Elf_Internal_Shdr
*hdr
;
6106 /* Get the .plt section contents. PLT passed down may point to the
6107 .plt.bnd section. Make sure that PLT always points to the .plt
6109 plt_bnd
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6114 plt
= bfd_get_section_by_name (abfd
, ".plt");
6117 bed
= &elf_x86_64_bnd_arch_bed
;
6120 bed
= get_elf_x86_64_backend_data (abfd
);
6122 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
6123 if (plt_contents
== NULL
)
6125 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
6126 plt_contents
, 0, plt
->size
))
6129 free (plt_contents
);
6133 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
6134 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
6137 hdr
= &elf_section_data (relplt
)->this_hdr
;
6138 count
= relplt
->size
/ hdr
->sh_entsize
;
6140 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
6141 if (plt_sym_val
== NULL
)
6144 for (i
= 0; i
< count
; i
++)
6145 plt_sym_val
[i
] = -1;
6147 plt_offset
= bed
->plt_entry_size
;
6148 p
= relplt
->relocation
;
6149 for (i
= 0; i
< count
; i
++, p
++)
6153 /* Skip unknown relocation. */
6154 if (p
->howto
== NULL
)
6157 if (p
->howto
->type
!= R_X86_64_JUMP_SLOT
6158 && p
->howto
->type
!= R_X86_64_IRELATIVE
)
6161 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
6162 + bed
->plt_reloc_offset
));
6163 if (reloc_index
< count
)
6167 /* This is the index in .plt section. */
6168 long plt_index
= plt_offset
/ bed
->plt_entry_size
;
6169 /* Store VMA + the offset in .plt.bnd section. */
6170 plt_sym_val
[reloc_index
] =
6172 + (plt_index
- 1) * sizeof (elf_x86_64_legacy_plt2_entry
));
6175 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
6177 plt_offset
+= bed
->plt_entry_size
;
6179 /* PR binutils/18437: Skip extra relocations in the .rela.plt
6181 if (plt_offset
>= plt
->size
)
6185 free (plt_contents
);
6190 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
6194 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
6201 /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
6202 as PLT if it exists. */
6203 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6205 plt
= bfd_get_section_by_name (abfd
, ".plt");
6206 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
6207 dynsymcount
, dynsyms
, ret
,
6209 elf_x86_64_get_plt_sym_val
);
6212 /* Handle an x86-64 specific section when reading an object file. This
6213 is called when elfcode.h finds a section with an unknown type. */
6216 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
6217 const char *name
, int shindex
)
6219 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
6222 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
6228 /* Hook called by the linker routine which adds symbols from an object
6229 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
6233 elf_x86_64_add_symbol_hook (bfd
*abfd
,
6234 struct bfd_link_info
*info
,
6235 Elf_Internal_Sym
*sym
,
6236 const char **namep ATTRIBUTE_UNUSED
,
6237 flagword
*flagsp ATTRIBUTE_UNUSED
,
6243 switch (sym
->st_shndx
)
6245 case SHN_X86_64_LCOMMON
:
6246 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
6249 lcomm
= bfd_make_section_with_flags (abfd
,
6253 | SEC_LINKER_CREATED
));
6256 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
6259 *valp
= sym
->st_size
;
6263 if (ELF_ST_BIND (sym
->st_info
) == STB_GNU_UNIQUE
6264 && (abfd
->flags
& DYNAMIC
) == 0
6265 && bfd_get_flavour (info
->output_bfd
) == bfd_target_elf_flavour
)
6266 elf_tdata (info
->output_bfd
)->has_gnu_symbols
6267 |= elf_gnu_symbol_unique
;
6273 /* Given a BFD section, try to locate the corresponding ELF section
6277 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
6278 asection
*sec
, int *index_return
)
6280 if (sec
== &_bfd_elf_large_com_section
)
6282 *index_return
= SHN_X86_64_LCOMMON
;
6288 /* Process a symbol. */
6291 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
6294 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
6296 switch (elfsym
->internal_elf_sym
.st_shndx
)
6298 case SHN_X86_64_LCOMMON
:
6299 asym
->section
= &_bfd_elf_large_com_section
;
6300 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
6301 /* Common symbol doesn't set BSF_GLOBAL. */
6302 asym
->flags
&= ~BSF_GLOBAL
;
6308 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
6310 return (sym
->st_shndx
== SHN_COMMON
6311 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
6315 elf_x86_64_common_section_index (asection
*sec
)
6317 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6320 return SHN_X86_64_LCOMMON
;
6324 elf_x86_64_common_section (asection
*sec
)
6326 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6327 return bfd_com_section_ptr
;
6329 return &_bfd_elf_large_com_section
;
6333 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
6334 const Elf_Internal_Sym
*sym
,
6339 const asection
*oldsec
)
6341 /* A normal common symbol and a large common symbol result in a
6342 normal common symbol. We turn the large common symbol into a
6345 && h
->root
.type
== bfd_link_hash_common
6347 && bfd_is_com_section (*psec
)
6350 if (sym
->st_shndx
== SHN_COMMON
6351 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
6353 h
->root
.u
.c
.p
->section
6354 = bfd_make_section_old_way (oldbfd
, "COMMON");
6355 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
6357 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
6358 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
6359 *psec
= bfd_com_section_ptr
;
6366 elf_x86_64_additional_program_headers (bfd
*abfd
,
6367 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6372 /* Check to see if we need a large readonly segment. */
6373 s
= bfd_get_section_by_name (abfd
, ".lrodata");
6374 if (s
&& (s
->flags
& SEC_LOAD
))
6377 /* Check to see if we need a large data segment. Since .lbss sections
6378 is placed right after the .bss section, there should be no need for
6379 a large data segment just because of .lbss. */
6380 s
= bfd_get_section_by_name (abfd
, ".ldata");
6381 if (s
&& (s
->flags
& SEC_LOAD
))
6387 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6390 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
6392 if (h
->plt
.offset
!= (bfd_vma
) -1
6394 && !h
->pointer_equality_needed
)
6397 return _bfd_elf_hash_symbol (h
);
6400 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
6403 elf_x86_64_relocs_compatible (const bfd_target
*input
,
6404 const bfd_target
*output
)
6406 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
6407 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
6408 && _bfd_elf_relocs_compatible (input
, output
));
6411 static const struct bfd_elf_special_section
6412 elf_x86_64_special_sections
[]=
6414 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6415 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6416 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
6417 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6418 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6419 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6420 { NULL
, 0, 0, 0, 0 }
6423 #define TARGET_LITTLE_SYM x86_64_elf64_vec
6424 #define TARGET_LITTLE_NAME "elf64-x86-64"
6425 #define ELF_ARCH bfd_arch_i386
6426 #define ELF_TARGET_ID X86_64_ELF_DATA
6427 #define ELF_MACHINE_CODE EM_X86_64
6428 #define ELF_MAXPAGESIZE 0x200000
6429 #define ELF_MINPAGESIZE 0x1000
6430 #define ELF_COMMONPAGESIZE 0x1000
6432 #define elf_backend_can_gc_sections 1
6433 #define elf_backend_can_refcount 1
6434 #define elf_backend_want_got_plt 1
6435 #define elf_backend_plt_readonly 1
6436 #define elf_backend_want_plt_sym 0
6437 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
6438 #define elf_backend_rela_normal 1
6439 #define elf_backend_plt_alignment 4
6440 #define elf_backend_extern_protected_data 1
6442 #define elf_info_to_howto elf_x86_64_info_to_howto
6444 #define bfd_elf64_bfd_link_hash_table_create \
6445 elf_x86_64_link_hash_table_create
6446 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
6447 #define bfd_elf64_bfd_reloc_name_lookup \
6448 elf_x86_64_reloc_name_lookup
6450 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
6451 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
6452 #define elf_backend_check_relocs elf_x86_64_check_relocs
6453 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
6454 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
6455 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
6456 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
6457 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
6458 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
6459 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
6461 #define elf_backend_write_core_note elf_x86_64_write_core_note
6463 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
6464 #define elf_backend_relocate_section elf_x86_64_relocate_section
6465 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
6466 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
6467 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
6468 #define elf_backend_object_p elf64_x86_64_elf_object_p
6469 #define bfd_elf64_mkobject elf_x86_64_mkobject
6470 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
6472 #define elf_backend_section_from_shdr \
6473 elf_x86_64_section_from_shdr
6475 #define elf_backend_section_from_bfd_section \
6476 elf_x86_64_elf_section_from_bfd_section
6477 #define elf_backend_add_symbol_hook \
6478 elf_x86_64_add_symbol_hook
6479 #define elf_backend_symbol_processing \
6480 elf_x86_64_symbol_processing
6481 #define elf_backend_common_section_index \
6482 elf_x86_64_common_section_index
6483 #define elf_backend_common_section \
6484 elf_x86_64_common_section
6485 #define elf_backend_common_definition \
6486 elf_x86_64_common_definition
6487 #define elf_backend_merge_symbol \
6488 elf_x86_64_merge_symbol
6489 #define elf_backend_special_sections \
6490 elf_x86_64_special_sections
6491 #define elf_backend_additional_program_headers \
6492 elf_x86_64_additional_program_headers
6493 #define elf_backend_hash_symbol \
6494 elf_x86_64_hash_symbol
6495 #define elf_backend_omit_section_dynsym \
6496 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6497 #define elf_backend_fixup_symbol \
6498 elf_x86_64_fixup_symbol
6500 #include "elf64-target.h"
6502 /* CloudABI support. */
6504 #undef TARGET_LITTLE_SYM
6505 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
6506 #undef TARGET_LITTLE_NAME
6507 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
6510 #define ELF_OSABI ELFOSABI_CLOUDABI
6513 #define elf64_bed elf64_x86_64_cloudabi_bed
6515 #include "elf64-target.h"
6517 /* FreeBSD support. */
6519 #undef TARGET_LITTLE_SYM
6520 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
6521 #undef TARGET_LITTLE_NAME
6522 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
6525 #define ELF_OSABI ELFOSABI_FREEBSD
6528 #define elf64_bed elf64_x86_64_fbsd_bed
6530 #include "elf64-target.h"
6532 /* Solaris 2 support. */
6534 #undef TARGET_LITTLE_SYM
6535 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
6536 #undef TARGET_LITTLE_NAME
6537 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
6539 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6540 objects won't be recognized. */
6544 #define elf64_bed elf64_x86_64_sol2_bed
6546 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
6548 #undef elf_backend_static_tls_alignment
6549 #define elf_backend_static_tls_alignment 16
6551 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6553 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6555 #undef elf_backend_want_plt_sym
6556 #define elf_backend_want_plt_sym 1
6558 #undef elf_backend_strtab_flags
6559 #define elf_backend_strtab_flags SHF_STRINGS
6562 elf64_x86_64_copy_solaris_special_section_fields (const bfd
*ibfd ATTRIBUTE_UNUSED
,
6563 bfd
*obfd ATTRIBUTE_UNUSED
,
6564 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
6565 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
6567 /* PR 19938: FIXME: Need to add code for setting the sh_info
6568 and sh_link fields of Solaris specific section types. */
6572 #undef elf_backend_copy_special_section_fields
6573 #define elf_backend_copy_special_section_fields elf64_x86_64_copy_solaris_special_section_fields
6575 #include "elf64-target.h"
6577 /* Native Client support. */
6580 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
6582 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
6583 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
6587 #undef TARGET_LITTLE_SYM
6588 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
6589 #undef TARGET_LITTLE_NAME
6590 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
6592 #define elf64_bed elf64_x86_64_nacl_bed
6594 #undef ELF_MAXPAGESIZE
6595 #undef ELF_MINPAGESIZE
6596 #undef ELF_COMMONPAGESIZE
6597 #define ELF_MAXPAGESIZE 0x10000
6598 #define ELF_MINPAGESIZE 0x10000
6599 #define ELF_COMMONPAGESIZE 0x10000
6601 /* Restore defaults. */
6603 #undef elf_backend_static_tls_alignment
6604 #undef elf_backend_want_plt_sym
6605 #define elf_backend_want_plt_sym 0
6606 #undef elf_backend_strtab_flags
6607 #undef elf_backend_copy_special_section_fields
6609 /* NaCl uses substantially different PLT entries for the same effects. */
6611 #undef elf_backend_plt_alignment
6612 #define elf_backend_plt_alignment 5
6613 #define NACL_PLT_ENTRY_SIZE 64
6614 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6616 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
6618 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
6619 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
6620 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6621 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6622 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6624 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
6625 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
6627 /* 32 bytes of nop to pad out to the standard size. */
6628 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6629 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6630 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6631 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6632 0x66, /* excess data32 prefix */
6636 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6638 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
6639 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6640 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6641 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6643 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
6644 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6645 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6647 /* Lazy GOT entries point here (32-byte aligned). */
6648 0x68, /* pushq immediate */
6649 0, 0, 0, 0, /* replaced with index into relocation table. */
6650 0xe9, /* jmp relative */
6651 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
6653 /* 22 bytes of nop to pad out to the standard size. */
6654 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6655 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6656 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
6659 /* .eh_frame covering the .plt section. */
6661 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
6663 #if (PLT_CIE_LENGTH != 20 \
6664 || PLT_FDE_LENGTH != 36 \
6665 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6666 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6667 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
6669 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6670 0, 0, 0, 0, /* CIE ID */
6671 1, /* CIE version */
6672 'z', 'R', 0, /* Augmentation string */
6673 1, /* Code alignment factor */
6674 0x78, /* Data alignment factor */
6675 16, /* Return address column */
6676 1, /* Augmentation size */
6677 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6678 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
6679 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
6680 DW_CFA_nop
, DW_CFA_nop
,
6682 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6683 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
6684 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
6685 0, 0, 0, 0, /* .plt size goes here */
6686 0, /* Augmentation size */
6687 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
6688 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6689 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
6690 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6691 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6692 13, /* Block length */
6693 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
6694 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
6695 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6696 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
6697 DW_CFA_nop
, DW_CFA_nop
6700 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
6702 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
6703 elf_x86_64_nacl_plt_entry
, /* plt_entry */
6704 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6705 2, /* plt0_got1_offset */
6706 9, /* plt0_got2_offset */
6707 13, /* plt0_got2_insn_end */
6708 3, /* plt_got_offset */
6709 33, /* plt_reloc_offset */
6710 38, /* plt_plt_offset */
6711 7, /* plt_got_insn_size */
6712 42, /* plt_plt_insn_end */
6713 32, /* plt_lazy_offset */
6714 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
6715 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
6718 #undef elf_backend_arch_data
6719 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
6721 #undef elf_backend_object_p
6722 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
6723 #undef elf_backend_modify_segment_map
6724 #define elf_backend_modify_segment_map nacl_modify_segment_map
6725 #undef elf_backend_modify_program_headers
6726 #define elf_backend_modify_program_headers nacl_modify_program_headers
6727 #undef elf_backend_final_write_processing
6728 #define elf_backend_final_write_processing nacl_final_write_processing
6730 #include "elf64-target.h"
6732 /* Native Client x32 support. */
6735 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
6737 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
6738 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
6742 #undef TARGET_LITTLE_SYM
6743 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
6744 #undef TARGET_LITTLE_NAME
6745 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
6747 #define elf32_bed elf32_x86_64_nacl_bed
6749 #define bfd_elf32_bfd_link_hash_table_create \
6750 elf_x86_64_link_hash_table_create
6751 #define bfd_elf32_bfd_reloc_type_lookup \
6752 elf_x86_64_reloc_type_lookup
6753 #define bfd_elf32_bfd_reloc_name_lookup \
6754 elf_x86_64_reloc_name_lookup
6755 #define bfd_elf32_mkobject \
6757 #define bfd_elf32_get_synthetic_symtab \
6758 elf_x86_64_get_synthetic_symtab
6760 #undef elf_backend_object_p
6761 #define elf_backend_object_p \
6762 elf32_x86_64_nacl_elf_object_p
6764 #undef elf_backend_bfd_from_remote_memory
6765 #define elf_backend_bfd_from_remote_memory \
6766 _bfd_elf32_bfd_from_remote_memory
6768 #undef elf_backend_size_info
6769 #define elf_backend_size_info \
6770 _bfd_elf32_size_info
6772 #include "elf32-target.h"
6774 /* Restore defaults. */
6775 #undef elf_backend_object_p
6776 #define elf_backend_object_p elf64_x86_64_elf_object_p
6777 #undef elf_backend_bfd_from_remote_memory
6778 #undef elf_backend_size_info
6779 #undef elf_backend_modify_segment_map
6780 #undef elf_backend_modify_program_headers
6781 #undef elf_backend_final_write_processing
6783 /* Intel L1OM support. */
6786 elf64_l1om_elf_object_p (bfd
*abfd
)
6788 /* Set the right machine number for an L1OM elf64 file. */
6789 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
6793 #undef TARGET_LITTLE_SYM
6794 #define TARGET_LITTLE_SYM l1om_elf64_vec
6795 #undef TARGET_LITTLE_NAME
6796 #define TARGET_LITTLE_NAME "elf64-l1om"
6798 #define ELF_ARCH bfd_arch_l1om
6800 #undef ELF_MACHINE_CODE
6801 #define ELF_MACHINE_CODE EM_L1OM
6806 #define elf64_bed elf64_l1om_bed
6808 #undef elf_backend_object_p
6809 #define elf_backend_object_p elf64_l1om_elf_object_p
6811 /* Restore defaults. */
6812 #undef ELF_MAXPAGESIZE
6813 #undef ELF_MINPAGESIZE
6814 #undef ELF_COMMONPAGESIZE
6815 #define ELF_MAXPAGESIZE 0x200000
6816 #define ELF_MINPAGESIZE 0x1000
6817 #define ELF_COMMONPAGESIZE 0x1000
6818 #undef elf_backend_plt_alignment
6819 #define elf_backend_plt_alignment 4
6820 #undef elf_backend_arch_data
6821 #define elf_backend_arch_data &elf_x86_64_arch_bed
6823 #include "elf64-target.h"
6825 /* FreeBSD L1OM support. */
6827 #undef TARGET_LITTLE_SYM
6828 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
6829 #undef TARGET_LITTLE_NAME
6830 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
6833 #define ELF_OSABI ELFOSABI_FREEBSD
6836 #define elf64_bed elf64_l1om_fbsd_bed
6838 #include "elf64-target.h"
6840 /* Intel K1OM support. */
6843 elf64_k1om_elf_object_p (bfd
*abfd
)
6845 /* Set the right machine number for an K1OM elf64 file. */
6846 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
6850 #undef TARGET_LITTLE_SYM
6851 #define TARGET_LITTLE_SYM k1om_elf64_vec
6852 #undef TARGET_LITTLE_NAME
6853 #define TARGET_LITTLE_NAME "elf64-k1om"
6855 #define ELF_ARCH bfd_arch_k1om
6857 #undef ELF_MACHINE_CODE
6858 #define ELF_MACHINE_CODE EM_K1OM
6863 #define elf64_bed elf64_k1om_bed
6865 #undef elf_backend_object_p
6866 #define elf_backend_object_p elf64_k1om_elf_object_p
6868 #undef elf_backend_static_tls_alignment
6870 #undef elf_backend_want_plt_sym
6871 #define elf_backend_want_plt_sym 0
6873 #include "elf64-target.h"
6875 /* FreeBSD K1OM support. */
6877 #undef TARGET_LITTLE_SYM
6878 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
6879 #undef TARGET_LITTLE_NAME
6880 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
6883 #define ELF_OSABI ELFOSABI_FREEBSD
6886 #define elf64_bed elf64_k1om_fbsd_bed
6888 #include "elf64-target.h"
6890 /* 32bit x86-64 support. */
6892 #undef TARGET_LITTLE_SYM
6893 #define TARGET_LITTLE_SYM x86_64_elf32_vec
6894 #undef TARGET_LITTLE_NAME
6895 #define TARGET_LITTLE_NAME "elf32-x86-64"
6899 #define ELF_ARCH bfd_arch_i386
6901 #undef ELF_MACHINE_CODE
6902 #define ELF_MACHINE_CODE EM_X86_64
6906 #undef elf_backend_object_p
6907 #define elf_backend_object_p \
6908 elf32_x86_64_elf_object_p
6910 #undef elf_backend_bfd_from_remote_memory
6911 #define elf_backend_bfd_from_remote_memory \
6912 _bfd_elf32_bfd_from_remote_memory
6914 #undef elf_backend_size_info
6915 #define elf_backend_size_info \
6916 _bfd_elf32_size_info
6918 #include "elf32-target.h"