1 /* X86-64 specific support for ELF
2 Copyright (C) 2000-2016 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka <jh@suse.cz>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
28 #include "bfd_stdint.h"
32 #include "libiberty.h"
34 #include "opcode/i386.h"
35 #include "elf/x86-64.h"
42 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
43 #define MINUS_ONE (~ (bfd_vma) 0)
45 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
46 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
47 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
48 since they are the same. */
50 #define ABI_64_P(abfd) \
51 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
53 /* The relocation "howto" table. Order of fields:
54 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
55 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
56 static reloc_howto_type x86_64_elf_howto_table
[] =
58 HOWTO(R_X86_64_NONE
, 0, 3, 0, FALSE
, 0, complain_overflow_dont
,
59 bfd_elf_generic_reloc
, "R_X86_64_NONE", FALSE
, 0x00000000, 0x00000000,
61 HOWTO(R_X86_64_64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
62 bfd_elf_generic_reloc
, "R_X86_64_64", FALSE
, MINUS_ONE
, MINUS_ONE
,
64 HOWTO(R_X86_64_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
65 bfd_elf_generic_reloc
, "R_X86_64_PC32", FALSE
, 0xffffffff, 0xffffffff,
67 HOWTO(R_X86_64_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
68 bfd_elf_generic_reloc
, "R_X86_64_GOT32", FALSE
, 0xffffffff, 0xffffffff,
70 HOWTO(R_X86_64_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
71 bfd_elf_generic_reloc
, "R_X86_64_PLT32", FALSE
, 0xffffffff, 0xffffffff,
73 HOWTO(R_X86_64_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
74 bfd_elf_generic_reloc
, "R_X86_64_COPY", FALSE
, 0xffffffff, 0xffffffff,
76 HOWTO(R_X86_64_GLOB_DAT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
77 bfd_elf_generic_reloc
, "R_X86_64_GLOB_DAT", FALSE
, MINUS_ONE
,
79 HOWTO(R_X86_64_JUMP_SLOT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
80 bfd_elf_generic_reloc
, "R_X86_64_JUMP_SLOT", FALSE
, MINUS_ONE
,
82 HOWTO(R_X86_64_RELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
83 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE", FALSE
, MINUS_ONE
,
85 HOWTO(R_X86_64_GOTPCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
86 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL", FALSE
, 0xffffffff,
88 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
89 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
91 HOWTO(R_X86_64_32S
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
92 bfd_elf_generic_reloc
, "R_X86_64_32S", FALSE
, 0xffffffff, 0xffffffff,
94 HOWTO(R_X86_64_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
95 bfd_elf_generic_reloc
, "R_X86_64_16", FALSE
, 0xffff, 0xffff, FALSE
),
96 HOWTO(R_X86_64_PC16
,0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
97 bfd_elf_generic_reloc
, "R_X86_64_PC16", FALSE
, 0xffff, 0xffff, TRUE
),
98 HOWTO(R_X86_64_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
99 bfd_elf_generic_reloc
, "R_X86_64_8", FALSE
, 0xff, 0xff, FALSE
),
100 HOWTO(R_X86_64_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
101 bfd_elf_generic_reloc
, "R_X86_64_PC8", FALSE
, 0xff, 0xff, TRUE
),
102 HOWTO(R_X86_64_DTPMOD64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
103 bfd_elf_generic_reloc
, "R_X86_64_DTPMOD64", FALSE
, MINUS_ONE
,
105 HOWTO(R_X86_64_DTPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
106 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF64", FALSE
, MINUS_ONE
,
108 HOWTO(R_X86_64_TPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
109 bfd_elf_generic_reloc
, "R_X86_64_TPOFF64", FALSE
, MINUS_ONE
,
111 HOWTO(R_X86_64_TLSGD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
112 bfd_elf_generic_reloc
, "R_X86_64_TLSGD", FALSE
, 0xffffffff,
114 HOWTO(R_X86_64_TLSLD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
115 bfd_elf_generic_reloc
, "R_X86_64_TLSLD", FALSE
, 0xffffffff,
117 HOWTO(R_X86_64_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
118 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF32", FALSE
, 0xffffffff,
120 HOWTO(R_X86_64_GOTTPOFF
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
121 bfd_elf_generic_reloc
, "R_X86_64_GOTTPOFF", FALSE
, 0xffffffff,
123 HOWTO(R_X86_64_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
124 bfd_elf_generic_reloc
, "R_X86_64_TPOFF32", FALSE
, 0xffffffff,
126 HOWTO(R_X86_64_PC64
, 0, 4, 64, TRUE
, 0, complain_overflow_bitfield
,
127 bfd_elf_generic_reloc
, "R_X86_64_PC64", FALSE
, MINUS_ONE
, MINUS_ONE
,
129 HOWTO(R_X86_64_GOTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
130 bfd_elf_generic_reloc
, "R_X86_64_GOTOFF64",
131 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
132 HOWTO(R_X86_64_GOTPC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
133 bfd_elf_generic_reloc
, "R_X86_64_GOTPC32",
134 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
135 HOWTO(R_X86_64_GOT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
136 bfd_elf_generic_reloc
, "R_X86_64_GOT64", FALSE
, MINUS_ONE
, MINUS_ONE
,
138 HOWTO(R_X86_64_GOTPCREL64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
139 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL64", FALSE
, MINUS_ONE
,
141 HOWTO(R_X86_64_GOTPC64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
142 bfd_elf_generic_reloc
, "R_X86_64_GOTPC64",
143 FALSE
, MINUS_ONE
, MINUS_ONE
, TRUE
),
144 HOWTO(R_X86_64_GOTPLT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
145 bfd_elf_generic_reloc
, "R_X86_64_GOTPLT64", FALSE
, MINUS_ONE
,
147 HOWTO(R_X86_64_PLTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
148 bfd_elf_generic_reloc
, "R_X86_64_PLTOFF64", FALSE
, MINUS_ONE
,
150 HOWTO(R_X86_64_SIZE32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
151 bfd_elf_generic_reloc
, "R_X86_64_SIZE32", FALSE
, 0xffffffff, 0xffffffff,
153 HOWTO(R_X86_64_SIZE64
, 0, 4, 64, FALSE
, 0, complain_overflow_unsigned
,
154 bfd_elf_generic_reloc
, "R_X86_64_SIZE64", FALSE
, MINUS_ONE
, MINUS_ONE
,
156 HOWTO(R_X86_64_GOTPC32_TLSDESC
, 0, 2, 32, TRUE
, 0,
157 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
158 "R_X86_64_GOTPC32_TLSDESC",
159 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
160 HOWTO(R_X86_64_TLSDESC_CALL
, 0, 0, 0, FALSE
, 0,
161 complain_overflow_dont
, bfd_elf_generic_reloc
,
162 "R_X86_64_TLSDESC_CALL",
164 HOWTO(R_X86_64_TLSDESC
, 0, 4, 64, FALSE
, 0,
165 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
167 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
168 HOWTO(R_X86_64_IRELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
169 bfd_elf_generic_reloc
, "R_X86_64_IRELATIVE", FALSE
, MINUS_ONE
,
171 HOWTO(R_X86_64_RELATIVE64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
172 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE64", FALSE
, MINUS_ONE
,
174 HOWTO(R_X86_64_PC32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
175 bfd_elf_generic_reloc
, "R_X86_64_PC32_BND", FALSE
, 0xffffffff, 0xffffffff,
177 HOWTO(R_X86_64_PLT32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
178 bfd_elf_generic_reloc
, "R_X86_64_PLT32_BND", FALSE
, 0xffffffff, 0xffffffff,
180 HOWTO(R_X86_64_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
181 bfd_elf_generic_reloc
, "R_X86_64_GOTPCRELX", FALSE
, 0xffffffff,
183 HOWTO(R_X86_64_REX_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
184 bfd_elf_generic_reloc
, "R_X86_64_REX_GOTPCRELX", FALSE
, 0xffffffff,
187 /* We have a gap in the reloc numbers here.
188 R_X86_64_standard counts the number up to this point, and
189 R_X86_64_vt_offset is the value to subtract from a reloc type of
190 R_X86_64_GNU_VT* to form an index into this table. */
191 #define R_X86_64_standard (R_X86_64_REX_GOTPCRELX + 1)
192 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
194 /* GNU extension to record C++ vtable hierarchy. */
195 HOWTO (R_X86_64_GNU_VTINHERIT
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
196 NULL
, "R_X86_64_GNU_VTINHERIT", FALSE
, 0, 0, FALSE
),
198 /* GNU extension to record C++ vtable member usage. */
199 HOWTO (R_X86_64_GNU_VTENTRY
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
200 _bfd_elf_rel_vtable_reloc_fn
, "R_X86_64_GNU_VTENTRY", FALSE
, 0, 0,
203 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
204 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
205 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
209 #define IS_X86_64_PCREL_TYPE(TYPE) \
210 ( ((TYPE) == R_X86_64_PC8) \
211 || ((TYPE) == R_X86_64_PC16) \
212 || ((TYPE) == R_X86_64_PC32) \
213 || ((TYPE) == R_X86_64_PC32_BND) \
214 || ((TYPE) == R_X86_64_PC64))
216 /* Map BFD relocs to the x86_64 elf relocs. */
219 bfd_reloc_code_real_type bfd_reloc_val
;
220 unsigned char elf_reloc_val
;
223 static const struct elf_reloc_map x86_64_reloc_map
[] =
225 { BFD_RELOC_NONE
, R_X86_64_NONE
, },
226 { BFD_RELOC_64
, R_X86_64_64
, },
227 { BFD_RELOC_32_PCREL
, R_X86_64_PC32
, },
228 { BFD_RELOC_X86_64_GOT32
, R_X86_64_GOT32
,},
229 { BFD_RELOC_X86_64_PLT32
, R_X86_64_PLT32
,},
230 { BFD_RELOC_X86_64_COPY
, R_X86_64_COPY
, },
231 { BFD_RELOC_X86_64_GLOB_DAT
, R_X86_64_GLOB_DAT
, },
232 { BFD_RELOC_X86_64_JUMP_SLOT
, R_X86_64_JUMP_SLOT
, },
233 { BFD_RELOC_X86_64_RELATIVE
, R_X86_64_RELATIVE
, },
234 { BFD_RELOC_X86_64_GOTPCREL
, R_X86_64_GOTPCREL
, },
235 { BFD_RELOC_32
, R_X86_64_32
, },
236 { BFD_RELOC_X86_64_32S
, R_X86_64_32S
, },
237 { BFD_RELOC_16
, R_X86_64_16
, },
238 { BFD_RELOC_16_PCREL
, R_X86_64_PC16
, },
239 { BFD_RELOC_8
, R_X86_64_8
, },
240 { BFD_RELOC_8_PCREL
, R_X86_64_PC8
, },
241 { BFD_RELOC_X86_64_DTPMOD64
, R_X86_64_DTPMOD64
, },
242 { BFD_RELOC_X86_64_DTPOFF64
, R_X86_64_DTPOFF64
, },
243 { BFD_RELOC_X86_64_TPOFF64
, R_X86_64_TPOFF64
, },
244 { BFD_RELOC_X86_64_TLSGD
, R_X86_64_TLSGD
, },
245 { BFD_RELOC_X86_64_TLSLD
, R_X86_64_TLSLD
, },
246 { BFD_RELOC_X86_64_DTPOFF32
, R_X86_64_DTPOFF32
, },
247 { BFD_RELOC_X86_64_GOTTPOFF
, R_X86_64_GOTTPOFF
, },
248 { BFD_RELOC_X86_64_TPOFF32
, R_X86_64_TPOFF32
, },
249 { BFD_RELOC_64_PCREL
, R_X86_64_PC64
, },
250 { BFD_RELOC_X86_64_GOTOFF64
, R_X86_64_GOTOFF64
, },
251 { BFD_RELOC_X86_64_GOTPC32
, R_X86_64_GOTPC32
, },
252 { BFD_RELOC_X86_64_GOT64
, R_X86_64_GOT64
, },
253 { BFD_RELOC_X86_64_GOTPCREL64
,R_X86_64_GOTPCREL64
, },
254 { BFD_RELOC_X86_64_GOTPC64
, R_X86_64_GOTPC64
, },
255 { BFD_RELOC_X86_64_GOTPLT64
, R_X86_64_GOTPLT64
, },
256 { BFD_RELOC_X86_64_PLTOFF64
, R_X86_64_PLTOFF64
, },
257 { BFD_RELOC_SIZE32
, R_X86_64_SIZE32
, },
258 { BFD_RELOC_SIZE64
, R_X86_64_SIZE64
, },
259 { BFD_RELOC_X86_64_GOTPC32_TLSDESC
, R_X86_64_GOTPC32_TLSDESC
, },
260 { BFD_RELOC_X86_64_TLSDESC_CALL
, R_X86_64_TLSDESC_CALL
, },
261 { BFD_RELOC_X86_64_TLSDESC
, R_X86_64_TLSDESC
, },
262 { BFD_RELOC_X86_64_IRELATIVE
, R_X86_64_IRELATIVE
, },
263 { BFD_RELOC_X86_64_PC32_BND
, R_X86_64_PC32_BND
, },
264 { BFD_RELOC_X86_64_PLT32_BND
, R_X86_64_PLT32_BND
, },
265 { BFD_RELOC_X86_64_GOTPCRELX
, R_X86_64_GOTPCRELX
, },
266 { BFD_RELOC_X86_64_REX_GOTPCRELX
, R_X86_64_REX_GOTPCRELX
, },
267 { BFD_RELOC_VTABLE_INHERIT
, R_X86_64_GNU_VTINHERIT
, },
268 { BFD_RELOC_VTABLE_ENTRY
, R_X86_64_GNU_VTENTRY
, },
271 static reloc_howto_type
*
272 elf_x86_64_rtype_to_howto (bfd
*abfd
, unsigned r_type
)
276 if (r_type
== (unsigned int) R_X86_64_32
)
281 i
= ARRAY_SIZE (x86_64_elf_howto_table
) - 1;
283 else if (r_type
< (unsigned int) R_X86_64_GNU_VTINHERIT
284 || r_type
>= (unsigned int) R_X86_64_max
)
286 if (r_type
>= (unsigned int) R_X86_64_standard
)
288 (*_bfd_error_handler
) (_("%B: invalid relocation type %d"),
290 r_type
= R_X86_64_NONE
;
295 i
= r_type
- (unsigned int) R_X86_64_vt_offset
;
296 BFD_ASSERT (x86_64_elf_howto_table
[i
].type
== r_type
);
297 return &x86_64_elf_howto_table
[i
];
300 /* Given a BFD reloc type, return a HOWTO structure. */
301 static reloc_howto_type
*
302 elf_x86_64_reloc_type_lookup (bfd
*abfd
,
303 bfd_reloc_code_real_type code
)
307 for (i
= 0; i
< sizeof (x86_64_reloc_map
) / sizeof (struct elf_reloc_map
);
310 if (x86_64_reloc_map
[i
].bfd_reloc_val
== code
)
311 return elf_x86_64_rtype_to_howto (abfd
,
312 x86_64_reloc_map
[i
].elf_reloc_val
);
317 static reloc_howto_type
*
318 elf_x86_64_reloc_name_lookup (bfd
*abfd
,
323 if (!ABI_64_P (abfd
) && strcasecmp (r_name
, "R_X86_64_32") == 0)
325 /* Get x32 R_X86_64_32. */
326 reloc_howto_type
*reloc
327 = &x86_64_elf_howto_table
[ARRAY_SIZE (x86_64_elf_howto_table
) - 1];
328 BFD_ASSERT (reloc
->type
== (unsigned int) R_X86_64_32
);
332 for (i
= 0; i
< ARRAY_SIZE (x86_64_elf_howto_table
); i
++)
333 if (x86_64_elf_howto_table
[i
].name
!= NULL
334 && strcasecmp (x86_64_elf_howto_table
[i
].name
, r_name
) == 0)
335 return &x86_64_elf_howto_table
[i
];
340 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
343 elf_x86_64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
344 Elf_Internal_Rela
*dst
)
348 r_type
= ELF32_R_TYPE (dst
->r_info
);
349 cache_ptr
->howto
= elf_x86_64_rtype_to_howto (abfd
, r_type
);
350 BFD_ASSERT (r_type
== cache_ptr
->howto
->type
);
353 /* Support for core dump NOTE sections. */
355 elf_x86_64_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
360 switch (note
->descsz
)
365 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
367 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
370 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
378 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
380 elf_tdata (abfd
)->core
->signal
381 = bfd_get_16 (abfd
, note
->descdata
+ 12);
384 elf_tdata (abfd
)->core
->lwpid
385 = bfd_get_32 (abfd
, note
->descdata
+ 32);
394 /* Make a ".reg/999" section. */
395 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
396 size
, note
->descpos
+ offset
);
400 elf_x86_64_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
402 switch (note
->descsz
)
407 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
408 elf_tdata (abfd
)->core
->pid
409 = bfd_get_32 (abfd
, note
->descdata
+ 12);
410 elf_tdata (abfd
)->core
->program
411 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
412 elf_tdata (abfd
)->core
->command
413 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
416 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
417 elf_tdata (abfd
)->core
->pid
418 = bfd_get_32 (abfd
, note
->descdata
+ 24);
419 elf_tdata (abfd
)->core
->program
420 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
421 elf_tdata (abfd
)->core
->command
422 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
425 /* Note that for some reason, a spurious space is tacked
426 onto the end of the args in some (at least one anyway)
427 implementations, so strip it off if it exists. */
430 char *command
= elf_tdata (abfd
)->core
->command
;
431 int n
= strlen (command
);
433 if (0 < n
&& command
[n
- 1] == ' ')
434 command
[n
- 1] = '\0';
442 elf_x86_64_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
,
445 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
447 const char *fname
, *psargs
;
458 va_start (ap
, note_type
);
459 fname
= va_arg (ap
, const char *);
460 psargs
= va_arg (ap
, const char *);
463 if (bed
->s
->elfclass
== ELFCLASS32
)
466 memset (&data
, 0, sizeof (data
));
467 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
468 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
469 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
470 &data
, sizeof (data
));
475 memset (&data
, 0, sizeof (data
));
476 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
477 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
478 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
479 &data
, sizeof (data
));
484 va_start (ap
, note_type
);
485 pid
= va_arg (ap
, long);
486 cursig
= va_arg (ap
, int);
487 gregs
= va_arg (ap
, const void *);
490 if (bed
->s
->elfclass
== ELFCLASS32
)
492 if (bed
->elf_machine_code
== EM_X86_64
)
494 prstatusx32_t prstat
;
495 memset (&prstat
, 0, sizeof (prstat
));
497 prstat
.pr_cursig
= cursig
;
498 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
499 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
500 &prstat
, sizeof (prstat
));
505 memset (&prstat
, 0, sizeof (prstat
));
507 prstat
.pr_cursig
= cursig
;
508 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
509 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
510 &prstat
, sizeof (prstat
));
516 memset (&prstat
, 0, sizeof (prstat
));
518 prstat
.pr_cursig
= cursig
;
519 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
520 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
521 &prstat
, sizeof (prstat
));
528 /* Functions for the x86-64 ELF linker. */
530 /* The name of the dynamic interpreter. This is put in the .interp
533 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
534 #define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
536 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
537 copying dynamic variables from a shared lib into an app's dynbss
538 section, and instead use a dynamic relocation to point into the
540 #define ELIMINATE_COPY_RELOCS 1
542 /* The size in bytes of an entry in the global offset table. */
544 #define GOT_ENTRY_SIZE 8
546 /* The size in bytes of an entry in the procedure linkage table. */
548 #define PLT_ENTRY_SIZE 16
550 /* The first entry in a procedure linkage table looks like this. See the
551 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
553 static const bfd_byte elf_x86_64_plt0_entry
[PLT_ENTRY_SIZE
] =
555 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
556 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
557 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
560 /* Subsequent entries in a procedure linkage table look like this. */
562 static const bfd_byte elf_x86_64_plt_entry
[PLT_ENTRY_SIZE
] =
564 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
565 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
566 0x68, /* pushq immediate */
567 0, 0, 0, 0, /* replaced with index into relocation table. */
568 0xe9, /* jmp relative */
569 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
572 /* The first entry in a procedure linkage table with BND relocations
575 static const bfd_byte elf_x86_64_bnd_plt0_entry
[PLT_ENTRY_SIZE
] =
577 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
578 0xf2, 0xff, 0x25, 16, 0, 0, 0, /* bnd jmpq *GOT+16(%rip) */
579 0x0f, 0x1f, 0 /* nopl (%rax) */
582 /* Subsequent entries for legacy branches in a procedure linkage table
583 with BND relocations look like this. */
585 static const bfd_byte elf_x86_64_legacy_plt_entry
[PLT_ENTRY_SIZE
] =
587 0x68, 0, 0, 0, 0, /* pushq immediate */
588 0xe9, 0, 0, 0, 0, /* jmpq relative */
589 0x66, 0x0f, 0x1f, 0x44, 0, 0 /* nopw (%rax,%rax,1) */
592 /* Subsequent entries for branches with BND prefx in a procedure linkage
593 table with BND relocations look like this. */
595 static const bfd_byte elf_x86_64_bnd_plt_entry
[PLT_ENTRY_SIZE
] =
597 0x68, 0, 0, 0, 0, /* pushq immediate */
598 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
599 0x0f, 0x1f, 0x44, 0, 0 /* nopl 0(%rax,%rax,1) */
602 /* Entries for legacy branches in the second procedure linkage table
605 static const bfd_byte elf_x86_64_legacy_plt2_entry
[8] =
607 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
608 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
609 0x66, 0x90 /* xchg %ax,%ax */
612 /* Entries for branches with BND prefix in the second procedure linkage
613 table look like this. */
615 static const bfd_byte elf_x86_64_bnd_plt2_entry
[8] =
617 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
618 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
622 /* .eh_frame covering the .plt section. */
624 static const bfd_byte elf_x86_64_eh_frame_plt
[] =
626 #define PLT_CIE_LENGTH 20
627 #define PLT_FDE_LENGTH 36
628 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
629 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
630 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
631 0, 0, 0, 0, /* CIE ID */
633 'z', 'R', 0, /* Augmentation string */
634 1, /* Code alignment factor */
635 0x78, /* Data alignment factor */
636 16, /* Return address column */
637 1, /* Augmentation size */
638 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
639 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
640 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
641 DW_CFA_nop
, DW_CFA_nop
,
643 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
644 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
645 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
646 0, 0, 0, 0, /* .plt size goes here */
647 0, /* Augmentation size */
648 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
649 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
650 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
651 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
652 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
653 11, /* Block length */
654 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
655 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
656 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
657 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
658 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
661 /* Architecture-specific backend data for x86-64. */
663 struct elf_x86_64_backend_data
665 /* Templates for the initial PLT entry and for subsequent entries. */
666 const bfd_byte
*plt0_entry
;
667 const bfd_byte
*plt_entry
;
668 unsigned int plt_entry_size
; /* Size of each PLT entry. */
670 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
671 unsigned int plt0_got1_offset
;
672 unsigned int plt0_got2_offset
;
674 /* Offset of the end of the PC-relative instruction containing
676 unsigned int plt0_got2_insn_end
;
678 /* Offsets into plt_entry that are to be replaced with... */
679 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
680 unsigned int plt_reloc_offset
; /* ... offset into relocation table. */
681 unsigned int plt_plt_offset
; /* ... offset to start of .plt. */
683 /* Length of the PC-relative instruction containing plt_got_offset. */
684 unsigned int plt_got_insn_size
;
686 /* Offset of the end of the PC-relative jump to plt0_entry. */
687 unsigned int plt_plt_insn_end
;
689 /* Offset into plt_entry where the initial value of the GOT entry points. */
690 unsigned int plt_lazy_offset
;
692 /* .eh_frame covering the .plt section. */
693 const bfd_byte
*eh_frame_plt
;
694 unsigned int eh_frame_plt_size
;
697 #define get_elf_x86_64_arch_data(bed) \
698 ((const struct elf_x86_64_backend_data *) (bed)->arch_data)
700 #define get_elf_x86_64_backend_data(abfd) \
701 get_elf_x86_64_arch_data (get_elf_backend_data (abfd))
703 #define GET_PLT_ENTRY_SIZE(abfd) \
704 get_elf_x86_64_backend_data (abfd)->plt_entry_size
706 /* These are the standard parameters. */
707 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed
=
709 elf_x86_64_plt0_entry
, /* plt0_entry */
710 elf_x86_64_plt_entry
, /* plt_entry */
711 sizeof (elf_x86_64_plt_entry
), /* plt_entry_size */
712 2, /* plt0_got1_offset */
713 8, /* plt0_got2_offset */
714 12, /* plt0_got2_insn_end */
715 2, /* plt_got_offset */
716 7, /* plt_reloc_offset */
717 12, /* plt_plt_offset */
718 6, /* plt_got_insn_size */
719 PLT_ENTRY_SIZE
, /* plt_plt_insn_end */
720 6, /* plt_lazy_offset */
721 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
722 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
725 static const struct elf_x86_64_backend_data elf_x86_64_bnd_arch_bed
=
727 elf_x86_64_bnd_plt0_entry
, /* plt0_entry */
728 elf_x86_64_bnd_plt_entry
, /* plt_entry */
729 sizeof (elf_x86_64_bnd_plt_entry
), /* plt_entry_size */
730 2, /* plt0_got1_offset */
731 1+8, /* plt0_got2_offset */
732 1+12, /* plt0_got2_insn_end */
733 1+2, /* plt_got_offset */
734 1, /* plt_reloc_offset */
735 7, /* plt_plt_offset */
736 1+6, /* plt_got_insn_size */
737 11, /* plt_plt_insn_end */
738 0, /* plt_lazy_offset */
739 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
740 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
743 #define elf_backend_arch_data &elf_x86_64_arch_bed
745 /* Is a undefined weak symbol which is resolved to 0. Reference to an
746 undefined weak symbol is resolved to 0 when building executable if
748 1. Has non-GOT/non-PLT relocations in text section. Or
749 2. Has no GOT/PLT relocation.
751 #define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, GOT_RELOC, EH) \
752 ((EH)->elf.root.type == bfd_link_hash_undefweak \
753 && bfd_link_executable (INFO) \
754 && (elf_x86_64_hash_table (INFO)->interp == NULL \
756 || (EH)->has_non_got_reloc \
757 || !(INFO)->dynamic_undefined_weak))
759 /* x86-64 ELF linker hash entry. */
761 struct elf_x86_64_link_hash_entry
763 struct elf_link_hash_entry elf
;
765 /* Track dynamic relocs copied for this symbol. */
766 struct elf_dyn_relocs
*dyn_relocs
;
768 #define GOT_UNKNOWN 0
772 #define GOT_TLS_GDESC 4
773 #define GOT_TLS_GD_BOTH_P(type) \
774 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
775 #define GOT_TLS_GD_P(type) \
776 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
777 #define GOT_TLS_GDESC_P(type) \
778 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
779 #define GOT_TLS_GD_ANY_P(type) \
780 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
781 unsigned char tls_type
;
783 /* TRUE if a weak symbol with a real definition needs a copy reloc.
784 When there is a weak symbol with a real definition, the processor
785 independent code will have arranged for us to see the real
786 definition first. We need to copy the needs_copy bit from the
787 real definition and check it when allowing copy reloc in PIE. */
788 unsigned int needs_copy
: 1;
790 /* TRUE if symbol has at least one BND relocation. */
791 unsigned int has_bnd_reloc
: 1;
793 /* TRUE if symbol has GOT or PLT relocations. */
794 unsigned int has_got_reloc
: 1;
796 /* TRUE if symbol has non-GOT/non-PLT relocations in text sections. */
797 unsigned int has_non_got_reloc
: 1;
799 /* Reference count of C/C++ function pointer relocations in read-write
800 section which can be resolved at run-time. */
801 bfd_signed_vma func_pointer_refcount
;
803 /* Information about the GOT PLT entry. Filled when there are both
804 GOT and PLT relocations against the same function. */
805 union gotplt_union plt_got
;
807 /* Information about the second PLT entry. Filled when has_bnd_reloc is
809 union gotplt_union plt_bnd
;
811 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
812 starting at the end of the jump table. */
816 #define elf_x86_64_hash_entry(ent) \
817 ((struct elf_x86_64_link_hash_entry *)(ent))
819 struct elf_x86_64_obj_tdata
821 struct elf_obj_tdata root
;
823 /* tls_type for each local got entry. */
824 char *local_got_tls_type
;
826 /* GOTPLT entries for TLS descriptors. */
827 bfd_vma
*local_tlsdesc_gotent
;
830 #define elf_x86_64_tdata(abfd) \
831 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
833 #define elf_x86_64_local_got_tls_type(abfd) \
834 (elf_x86_64_tdata (abfd)->local_got_tls_type)
836 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
837 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
839 #define is_x86_64_elf(bfd) \
840 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
841 && elf_tdata (bfd) != NULL \
842 && elf_object_id (bfd) == X86_64_ELF_DATA)
845 elf_x86_64_mkobject (bfd
*abfd
)
847 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_x86_64_obj_tdata
),
851 /* x86-64 ELF linker hash table. */
853 struct elf_x86_64_link_hash_table
855 struct elf_link_hash_table elf
;
857 /* Short-cuts to get to dynamic linker sections. */
861 asection
*plt_eh_frame
;
867 bfd_signed_vma refcount
;
871 /* The amount of space used by the jump slots in the GOT. */
872 bfd_vma sgotplt_jump_table_size
;
874 /* Small local sym cache. */
875 struct sym_cache sym_cache
;
877 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
878 bfd_vma (*r_sym
) (bfd_vma
);
879 unsigned int pointer_r_type
;
880 const char *dynamic_interpreter
;
881 int dynamic_interpreter_size
;
883 /* _TLS_MODULE_BASE_ symbol. */
884 struct bfd_link_hash_entry
*tls_module_base
;
886 /* Used by local STT_GNU_IFUNC symbols. */
887 htab_t loc_hash_table
;
888 void * loc_hash_memory
;
890 /* The offset into splt of the PLT entry for the TLS descriptor
891 resolver. Special values are 0, if not necessary (or not found
892 to be necessary yet), and -1 if needed but not determined
895 /* The offset into sgot of the GOT entry used by the PLT entry
899 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
900 bfd_vma next_jump_slot_index
;
901 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
902 bfd_vma next_irelative_index
;
904 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
905 to read-only sections. */
906 bfd_boolean readonly_dynrelocs_against_ifunc
;
909 /* Get the x86-64 ELF linker hash table from a link_info structure. */
911 #define elf_x86_64_hash_table(p) \
912 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
913 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
915 #define elf_x86_64_compute_jump_table_size(htab) \
916 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
918 /* Create an entry in an x86-64 ELF linker hash table. */
920 static struct bfd_hash_entry
*
921 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
922 struct bfd_hash_table
*table
,
925 /* Allocate the structure if it has not already been allocated by a
929 entry
= (struct bfd_hash_entry
*)
930 bfd_hash_allocate (table
,
931 sizeof (struct elf_x86_64_link_hash_entry
));
936 /* Call the allocation method of the superclass. */
937 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
940 struct elf_x86_64_link_hash_entry
*eh
;
942 eh
= (struct elf_x86_64_link_hash_entry
*) entry
;
943 eh
->dyn_relocs
= NULL
;
944 eh
->tls_type
= GOT_UNKNOWN
;
946 eh
->has_bnd_reloc
= 0;
947 eh
->has_got_reloc
= 0;
948 eh
->has_non_got_reloc
= 0;
949 eh
->func_pointer_refcount
= 0;
950 eh
->plt_bnd
.offset
= (bfd_vma
) -1;
951 eh
->plt_got
.offset
= (bfd_vma
) -1;
952 eh
->tlsdesc_got
= (bfd_vma
) -1;
958 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
959 for local symbol so that we can handle local STT_GNU_IFUNC symbols
960 as global symbol. We reuse indx and dynstr_index for local symbol
961 hash since they aren't used by global symbols in this backend. */
964 elf_x86_64_local_htab_hash (const void *ptr
)
966 struct elf_link_hash_entry
*h
967 = (struct elf_link_hash_entry
*) ptr
;
968 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
971 /* Compare local hash entries. */
974 elf_x86_64_local_htab_eq (const void *ptr1
, const void *ptr2
)
976 struct elf_link_hash_entry
*h1
977 = (struct elf_link_hash_entry
*) ptr1
;
978 struct elf_link_hash_entry
*h2
979 = (struct elf_link_hash_entry
*) ptr2
;
981 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
984 /* Find and/or create a hash entry for local symbol. */
986 static struct elf_link_hash_entry
*
987 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table
*htab
,
988 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
991 struct elf_x86_64_link_hash_entry e
, *ret
;
992 asection
*sec
= abfd
->sections
;
993 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
994 htab
->r_sym (rel
->r_info
));
997 e
.elf
.indx
= sec
->id
;
998 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
999 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
1000 create
? INSERT
: NO_INSERT
);
1007 ret
= (struct elf_x86_64_link_hash_entry
*) *slot
;
1011 ret
= (struct elf_x86_64_link_hash_entry
*)
1012 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
1013 sizeof (struct elf_x86_64_link_hash_entry
));
1016 memset (ret
, 0, sizeof (*ret
));
1017 ret
->elf
.indx
= sec
->id
;
1018 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
1019 ret
->elf
.dynindx
= -1;
1020 ret
->func_pointer_refcount
= 0;
1021 ret
->plt_got
.offset
= (bfd_vma
) -1;
1027 /* Destroy an X86-64 ELF linker hash table. */
1030 elf_x86_64_link_hash_table_free (bfd
*obfd
)
1032 struct elf_x86_64_link_hash_table
*htab
1033 = (struct elf_x86_64_link_hash_table
*) obfd
->link
.hash
;
1035 if (htab
->loc_hash_table
)
1036 htab_delete (htab
->loc_hash_table
);
1037 if (htab
->loc_hash_memory
)
1038 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
1039 _bfd_elf_link_hash_table_free (obfd
);
1042 /* Create an X86-64 ELF linker hash table. */
1044 static struct bfd_link_hash_table
*
1045 elf_x86_64_link_hash_table_create (bfd
*abfd
)
1047 struct elf_x86_64_link_hash_table
*ret
;
1048 bfd_size_type amt
= sizeof (struct elf_x86_64_link_hash_table
);
1050 ret
= (struct elf_x86_64_link_hash_table
*) bfd_zmalloc (amt
);
1054 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1055 elf_x86_64_link_hash_newfunc
,
1056 sizeof (struct elf_x86_64_link_hash_entry
),
1063 if (ABI_64_P (abfd
))
1065 ret
->r_info
= elf64_r_info
;
1066 ret
->r_sym
= elf64_r_sym
;
1067 ret
->pointer_r_type
= R_X86_64_64
;
1068 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
1069 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
1073 ret
->r_info
= elf32_r_info
;
1074 ret
->r_sym
= elf32_r_sym
;
1075 ret
->pointer_r_type
= R_X86_64_32
;
1076 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
1077 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
1080 ret
->loc_hash_table
= htab_try_create (1024,
1081 elf_x86_64_local_htab_hash
,
1082 elf_x86_64_local_htab_eq
,
1084 ret
->loc_hash_memory
= objalloc_create ();
1085 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1087 elf_x86_64_link_hash_table_free (abfd
);
1090 ret
->elf
.root
.hash_table_free
= elf_x86_64_link_hash_table_free
;
1092 return &ret
->elf
.root
;
1095 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1096 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1100 elf_x86_64_create_dynamic_sections (bfd
*dynobj
,
1101 struct bfd_link_info
*info
)
1103 struct elf_x86_64_link_hash_table
*htab
;
1105 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1108 htab
= elf_x86_64_hash_table (info
);
1112 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
)->has_got_reloc
,
2294 elf_x86_64_hash_entry (h
)))
2297 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2303 /* Adjust a symbol defined by a dynamic object and referenced by a
2304 regular object. The current definition is in some section of the
2305 dynamic object, but we're not including those sections. We have to
2306 change the definition to something the rest of the link can
2310 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2311 struct elf_link_hash_entry
*h
)
2313 struct elf_x86_64_link_hash_table
*htab
;
2315 struct elf_x86_64_link_hash_entry
*eh
;
2316 struct elf_dyn_relocs
*p
;
2318 /* STT_GNU_IFUNC symbol must go through PLT. */
2319 if (h
->type
== STT_GNU_IFUNC
)
2321 /* All local STT_GNU_IFUNC references must be treate as local
2322 calls via local PLT. */
2324 && SYMBOL_CALLS_LOCAL (info
, h
))
2326 bfd_size_type pc_count
= 0, count
= 0;
2327 struct elf_dyn_relocs
**pp
;
2329 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2330 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2332 pc_count
+= p
->pc_count
;
2333 p
->count
-= p
->pc_count
;
2342 if (pc_count
|| count
)
2346 if (h
->plt
.refcount
<= 0)
2347 h
->plt
.refcount
= 1;
2349 h
->plt
.refcount
+= 1;
2353 if (h
->plt
.refcount
<= 0)
2355 h
->plt
.offset
= (bfd_vma
) -1;
2361 /* If this is a function, put it in the procedure linkage table. We
2362 will fill in the contents of the procedure linkage table later,
2363 when we know the address of the .got section. */
2364 if (h
->type
== STT_FUNC
2367 if (h
->plt
.refcount
<= 0
2368 || SYMBOL_CALLS_LOCAL (info
, h
)
2369 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2370 && h
->root
.type
== bfd_link_hash_undefweak
))
2372 /* This case can occur if we saw a PLT32 reloc in an input
2373 file, but the symbol was never referred to by a dynamic
2374 object, or if all references were garbage collected. In
2375 such a case, we don't actually need to build a procedure
2376 linkage table, and we can just do a PC32 reloc instead. */
2377 h
->plt
.offset
= (bfd_vma
) -1;
2384 /* It's possible that we incorrectly decided a .plt reloc was
2385 needed for an R_X86_64_PC32 reloc to a non-function sym in
2386 check_relocs. We can't decide accurately between function and
2387 non-function syms in check-relocs; Objects loaded later in
2388 the link may change h->type. So fix it now. */
2389 h
->plt
.offset
= (bfd_vma
) -1;
2391 /* If this is a weak symbol, and there is a real definition, the
2392 processor independent code will have arranged for us to see the
2393 real definition first, and we can just use the same value. */
2394 if (h
->u
.weakdef
!= NULL
)
2396 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2397 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2398 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2399 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2400 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2402 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2403 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2404 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
2409 /* This is a reference to a symbol defined by a dynamic object which
2410 is not a function. */
2412 /* If we are creating a shared library, we must presume that the
2413 only references to the symbol are via the global offset table.
2414 For such cases we need not do anything here; the relocations will
2415 be handled correctly by relocate_section. */
2416 if (!bfd_link_executable (info
))
2419 /* If there are no references to this symbol that do not use the
2420 GOT, we don't need to generate a copy reloc. */
2421 if (!h
->non_got_ref
)
2424 /* If -z nocopyreloc was given, we won't generate them either. */
2425 if (info
->nocopyreloc
)
2431 if (ELIMINATE_COPY_RELOCS
)
2433 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2434 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2436 s
= p
->sec
->output_section
;
2437 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2441 /* If we didn't find any dynamic relocs in read-only sections, then
2442 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2450 /* We must allocate the symbol in our .dynbss section, which will
2451 become part of the .bss section of the executable. There will be
2452 an entry for this symbol in the .dynsym section. The dynamic
2453 object will contain position independent code, so all references
2454 from the dynamic object to this symbol will go through the global
2455 offset table. The dynamic linker will use the .dynsym entry to
2456 determine the address it must put in the global offset table, so
2457 both the dynamic object and the regular object will refer to the
2458 same memory location for the variable. */
2460 htab
= elf_x86_64_hash_table (info
);
2464 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2465 to copy the initial value out of the dynamic object and into the
2466 runtime process image. */
2467 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2469 const struct elf_backend_data
*bed
;
2470 bed
= get_elf_backend_data (info
->output_bfd
);
2471 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
2477 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2480 /* Allocate space in .plt, .got and associated reloc sections for
2484 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2486 struct bfd_link_info
*info
;
2487 struct elf_x86_64_link_hash_table
*htab
;
2488 struct elf_x86_64_link_hash_entry
*eh
;
2489 struct elf_dyn_relocs
*p
;
2490 const struct elf_backend_data
*bed
;
2491 unsigned int plt_entry_size
;
2492 bfd_boolean resolved_to_zero
;
2494 if (h
->root
.type
== bfd_link_hash_indirect
)
2497 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2499 info
= (struct bfd_link_info
*) inf
;
2500 htab
= elf_x86_64_hash_table (info
);
2503 bed
= get_elf_backend_data (info
->output_bfd
);
2504 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2506 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2510 /* We can't use the GOT PLT if pointer equality is needed since
2511 finish_dynamic_symbol won't clear symbol value and the dynamic
2512 linker won't update the GOT slot. We will get into an infinite
2513 loop at run-time. */
2514 if (htab
->plt_got
!= NULL
2515 && h
->type
!= STT_GNU_IFUNC
2516 && !h
->pointer_equality_needed
2517 && h
->plt
.refcount
> 0
2518 && h
->got
.refcount
> 0)
2520 /* Don't use the regular PLT if there are both GOT and GOTPLT
2522 h
->plt
.offset
= (bfd_vma
) -1;
2524 /* Use the GOT PLT. */
2525 eh
->plt_got
.refcount
= 1;
2528 /* Clear the reference count of function pointer relocations if
2529 symbol isn't a normal function. */
2530 if (h
->type
!= STT_FUNC
)
2531 eh
->func_pointer_refcount
= 0;
2533 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2534 here if it is defined and referenced in a non-shared object. */
2535 if (h
->type
== STT_GNU_IFUNC
2538 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
2540 &htab
->readonly_dynrelocs_against_ifunc
,
2545 asection
*s
= htab
->plt_bnd
;
2546 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
2548 /* Use the .plt.bnd section if it is created. */
2549 eh
->plt_bnd
.offset
= s
->size
;
2551 /* Make room for this entry in the .plt.bnd section. */
2552 s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2560 /* Don't create the PLT entry if there are only function pointer
2561 relocations which can be resolved at run-time. */
2562 else if (htab
->elf
.dynamic_sections_created
2563 && (h
->plt
.refcount
> eh
->func_pointer_refcount
2564 || eh
->plt_got
.refcount
> 0))
2566 bfd_boolean use_plt_got
;
2568 /* Clear the reference count of function pointer relocations
2570 eh
->func_pointer_refcount
= 0;
2572 if ((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2574 /* Don't use the regular PLT for DF_BIND_NOW. */
2575 h
->plt
.offset
= (bfd_vma
) -1;
2577 /* Use the GOT PLT. */
2578 h
->got
.refcount
= 1;
2579 eh
->plt_got
.refcount
= 1;
2582 use_plt_got
= eh
->plt_got
.refcount
> 0;
2584 /* Make sure this symbol is output as a dynamic symbol.
2585 Undefined weak syms won't yet be marked as dynamic. */
2586 if (h
->dynindx
== -1
2588 && !resolved_to_zero
)
2590 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2594 if (bfd_link_pic (info
)
2595 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2597 asection
*s
= htab
->elf
.splt
;
2598 asection
*bnd_s
= htab
->plt_bnd
;
2599 asection
*got_s
= htab
->plt_got
;
2601 /* If this is the first .plt entry, make room for the special
2602 first entry. The .plt section is used by prelink to undo
2603 prelinking for dynamic relocations. */
2605 s
->size
= plt_entry_size
;
2608 eh
->plt_got
.offset
= got_s
->size
;
2611 h
->plt
.offset
= s
->size
;
2613 eh
->plt_bnd
.offset
= bnd_s
->size
;
2616 /* If this symbol is not defined in a regular file, and we are
2617 not generating a shared library, then set the symbol to this
2618 location in the .plt. This is required to make function
2619 pointers compare as equal between the normal executable and
2620 the shared library. */
2621 if (! bfd_link_pic (info
)
2626 /* We need to make a call to the entry of the GOT PLT
2627 instead of regular PLT entry. */
2628 h
->root
.u
.def
.section
= got_s
;
2629 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
2635 /* We need to make a call to the entry of the second
2636 PLT instead of regular PLT entry. */
2637 h
->root
.u
.def
.section
= bnd_s
;
2638 h
->root
.u
.def
.value
= eh
->plt_bnd
.offset
;
2642 h
->root
.u
.def
.section
= s
;
2643 h
->root
.u
.def
.value
= h
->plt
.offset
;
2648 /* Make room for this entry. */
2650 got_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2653 s
->size
+= plt_entry_size
;
2655 bnd_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2657 /* We also need to make an entry in the .got.plt section,
2658 which will be placed in the .got section by the linker
2660 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
2662 /* There should be no PLT relocation against resolved
2663 undefined weak symbol in executable. */
2664 if (!resolved_to_zero
)
2666 /* We also need to make an entry in the .rela.plt
2668 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2669 htab
->elf
.srelplt
->reloc_count
++;
2675 eh
->plt_got
.offset
= (bfd_vma
) -1;
2676 h
->plt
.offset
= (bfd_vma
) -1;
2682 eh
->plt_got
.offset
= (bfd_vma
) -1;
2683 h
->plt
.offset
= (bfd_vma
) -1;
2687 eh
->tlsdesc_got
= (bfd_vma
) -1;
2689 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2690 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2691 if (h
->got
.refcount
> 0
2692 && bfd_link_executable (info
)
2694 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
2696 h
->got
.offset
= (bfd_vma
) -1;
2698 else if (h
->got
.refcount
> 0)
2702 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
2704 /* Make sure this symbol is output as a dynamic symbol.
2705 Undefined weak syms won't yet be marked as dynamic. */
2706 if (h
->dynindx
== -1
2708 && !resolved_to_zero
)
2710 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2714 if (GOT_TLS_GDESC_P (tls_type
))
2716 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2717 - elf_x86_64_compute_jump_table_size (htab
);
2718 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2719 h
->got
.offset
= (bfd_vma
) -2;
2721 if (! GOT_TLS_GDESC_P (tls_type
)
2722 || GOT_TLS_GD_P (tls_type
))
2725 h
->got
.offset
= s
->size
;
2726 s
->size
+= GOT_ENTRY_SIZE
;
2727 if (GOT_TLS_GD_P (tls_type
))
2728 s
->size
+= GOT_ENTRY_SIZE
;
2730 dyn
= htab
->elf
.dynamic_sections_created
;
2731 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2732 and two if global. R_X86_64_GOTTPOFF needs one dynamic
2733 relocation. No dynamic relocation against resolved undefined
2734 weak symbol in executable. */
2735 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2736 || tls_type
== GOT_TLS_IE
)
2737 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2738 else if (GOT_TLS_GD_P (tls_type
))
2739 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
2740 else if (! GOT_TLS_GDESC_P (tls_type
)
2741 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2742 && !resolved_to_zero
)
2743 || h
->root
.type
!= bfd_link_hash_undefweak
)
2744 && (bfd_link_pic (info
)
2745 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2746 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2747 if (GOT_TLS_GDESC_P (tls_type
))
2749 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2750 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2754 h
->got
.offset
= (bfd_vma
) -1;
2756 if (eh
->dyn_relocs
== NULL
)
2759 /* In the shared -Bsymbolic case, discard space allocated for
2760 dynamic pc-relative relocs against symbols which turn out to be
2761 defined in regular objects. For the normal shared case, discard
2762 space for pc-relative relocs that have become local due to symbol
2763 visibility changes. */
2765 if (bfd_link_pic (info
))
2767 /* Relocs that use pc_count are those that appear on a call
2768 insn, or certain REL relocs that can generated via assembly.
2769 We want calls to protected symbols to resolve directly to the
2770 function rather than going via the plt. If people want
2771 function pointer comparisons to work as expected then they
2772 should avoid writing weird assembly. */
2773 if (SYMBOL_CALLS_LOCAL (info
, h
))
2775 struct elf_dyn_relocs
**pp
;
2777 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2779 p
->count
-= p
->pc_count
;
2788 /* Also discard relocs on undefined weak syms with non-default
2789 visibility or in PIE. */
2790 if (eh
->dyn_relocs
!= NULL
)
2792 if (h
->root
.type
== bfd_link_hash_undefweak
)
2794 /* Undefined weak symbol is never bound locally in shared
2796 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2797 || resolved_to_zero
)
2798 eh
->dyn_relocs
= NULL
;
2799 else if (h
->dynindx
== -1
2800 && ! h
->forced_local
2801 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2804 /* For PIE, discard space for pc-relative relocs against
2805 symbols which turn out to need copy relocs. */
2806 else if (bfd_link_executable (info
)
2807 && (h
->needs_copy
|| eh
->needs_copy
)
2811 struct elf_dyn_relocs
**pp
;
2813 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2815 if (p
->pc_count
!= 0)
2823 else if (ELIMINATE_COPY_RELOCS
)
2825 /* For the non-shared case, discard space for relocs against
2826 symbols which turn out to need copy relocs or are not
2827 dynamic. Keep dynamic relocations for run-time function
2828 pointer initialization. */
2830 if ((!h
->non_got_ref
2831 || eh
->func_pointer_refcount
> 0
2832 || (h
->root
.type
== bfd_link_hash_undefweak
2833 && !resolved_to_zero
))
2836 || (htab
->elf
.dynamic_sections_created
2837 && (h
->root
.type
== bfd_link_hash_undefweak
2838 || h
->root
.type
== bfd_link_hash_undefined
))))
2840 /* Make sure this symbol is output as a dynamic symbol.
2841 Undefined weak syms won't yet be marked as dynamic. */
2842 if (h
->dynindx
== -1
2843 && ! h
->forced_local
2844 && ! resolved_to_zero
2845 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2848 /* If that succeeded, we know we'll be keeping all the
2850 if (h
->dynindx
!= -1)
2854 eh
->dyn_relocs
= NULL
;
2855 eh
->func_pointer_refcount
= 0;
2860 /* Finally, allocate space. */
2861 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2865 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2867 BFD_ASSERT (sreloc
!= NULL
);
2869 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2875 /* Allocate space in .plt, .got and associated reloc sections for
2876 local dynamic relocs. */
2879 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
2881 struct elf_link_hash_entry
*h
2882 = (struct elf_link_hash_entry
*) *slot
;
2884 if (h
->type
!= STT_GNU_IFUNC
2888 || h
->root
.type
!= bfd_link_hash_defined
)
2891 return elf_x86_64_allocate_dynrelocs (h
, inf
);
2894 /* Find any dynamic relocs that apply to read-only sections. */
2897 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
2900 struct elf_x86_64_link_hash_entry
*eh
;
2901 struct elf_dyn_relocs
*p
;
2903 /* Skip local IFUNC symbols. */
2904 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
2907 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2908 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2910 asection
*s
= p
->sec
->output_section
;
2912 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2914 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2916 info
->flags
|= DF_TEXTREL
;
2918 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
2919 || info
->error_textrel
)
2920 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
2921 p
->sec
->owner
, h
->root
.root
.string
,
2924 /* Not an error, just cut short the traversal. */
2931 /* With the local symbol, foo, we convert
2932 mov foo@GOTPCREL(%rip), %reg
2936 call/jmp *foo@GOTPCREL(%rip)
2938 nop call foo/jmp foo nop
2939 When PIC is false, convert
2940 test %reg, foo@GOTPCREL(%rip)
2944 binop foo@GOTPCREL(%rip), %reg
2947 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
2951 elf_x86_64_convert_load (bfd
*abfd
, asection
*sec
,
2952 struct bfd_link_info
*link_info
)
2954 Elf_Internal_Shdr
*symtab_hdr
;
2955 Elf_Internal_Rela
*internal_relocs
;
2956 Elf_Internal_Rela
*irel
, *irelend
;
2958 struct elf_x86_64_link_hash_table
*htab
;
2959 bfd_boolean changed_contents
;
2960 bfd_boolean changed_relocs
;
2961 bfd_signed_vma
*local_got_refcounts
;
2962 bfd_vma maxpagesize
;
2964 bfd_boolean require_reloc_pc32
;
2966 /* Don't even try to convert non-ELF outputs. */
2967 if (!is_elf_hash_table (link_info
->hash
))
2970 /* Nothing to do if there is no need or no output. */
2971 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
2972 || sec
->need_convert_load
== 0
2973 || bfd_is_abs_section (sec
->output_section
))
2976 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2978 /* Load the relocations for this section. */
2979 internal_relocs
= (_bfd_elf_link_read_relocs
2980 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
2981 link_info
->keep_memory
));
2982 if (internal_relocs
== NULL
)
2985 htab
= elf_x86_64_hash_table (link_info
);
2986 changed_contents
= FALSE
;
2987 changed_relocs
= FALSE
;
2988 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2989 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2991 /* Get the section contents. */
2992 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2993 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2996 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
3000 is_pic
= bfd_link_pic (link_info
);
3002 /* TRUE if we can convert only to R_X86_64_PC32. Enable it for
3005 = link_info
->disable_target_specific_optimizations
> 1;
3007 irelend
= internal_relocs
+ sec
->reloc_count
;
3008 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3010 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
3011 unsigned int r_symndx
= htab
->r_sym (irel
->r_info
);
3013 struct elf_link_hash_entry
*h
;
3017 bfd_signed_vma raddend
;
3018 unsigned int opcode
;
3021 bfd_boolean to_reloc_pc32
;
3023 relocx
= (r_type
== R_X86_64_GOTPCRELX
3024 || r_type
== R_X86_64_REX_GOTPCRELX
);
3025 if (!relocx
&& r_type
!= R_X86_64_GOTPCREL
)
3028 roff
= irel
->r_offset
;
3029 if (roff
< (r_type
== R_X86_64_REX_GOTPCRELX
? 3 : 2))
3032 raddend
= irel
->r_addend
;
3033 /* Addend for 32-bit PC-relative relocation must be -4. */
3037 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
3039 /* Convert mov to lea since it has been done for a while. */
3042 /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
3043 for call, jmp or one of adc, add, and, cmp, or, sbb, sub,
3044 test, xor instructions. */
3049 /* We convert only to R_X86_64_PC32:
3051 2. R_X86_64_GOTPCREL since we can't modify REX byte.
3052 3. require_reloc_pc32 is true.
3055 to_reloc_pc32
= (opcode
== 0xff
3057 || require_reloc_pc32
3060 /* Get the symbol referred to by the reloc. */
3061 if (r_symndx
< symtab_hdr
->sh_info
)
3063 Elf_Internal_Sym
*isym
;
3065 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
3068 symtype
= ELF_ST_TYPE (isym
->st_info
);
3070 /* STT_GNU_IFUNC must keep GOTPCREL relocations and skip
3071 relocation against undefined symbols. */
3072 if (symtype
== STT_GNU_IFUNC
|| isym
->st_shndx
== SHN_UNDEF
)
3075 if (isym
->st_shndx
== SHN_ABS
)
3076 tsec
= bfd_abs_section_ptr
;
3077 else if (isym
->st_shndx
== SHN_COMMON
)
3078 tsec
= bfd_com_section_ptr
;
3079 else if (isym
->st_shndx
== SHN_X86_64_LCOMMON
)
3080 tsec
= &_bfd_elf_large_com_section
;
3082 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
3085 toff
= isym
->st_value
;
3089 indx
= r_symndx
- symtab_hdr
->sh_info
;
3090 h
= elf_sym_hashes (abfd
)[indx
];
3091 BFD_ASSERT (h
!= NULL
);
3093 while (h
->root
.type
== bfd_link_hash_indirect
3094 || h
->root
.type
== bfd_link_hash_warning
)
3095 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3097 /* STT_GNU_IFUNC must keep GOTPCREL relocations. We also
3098 avoid optimizing GOTPCREL relocations againt _DYNAMIC
3099 since ld.so may use its link-time address. */
3100 if (h
->type
== STT_GNU_IFUNC
)
3103 /* Undefined weak symbol is only bound locally in executable
3104 and its reference is resolved as 0 without relocation
3105 overflow. We can only perform this optimization for
3106 GOTPCRELX relocations since we need to modify REX byte.
3107 It is OK convert mov with R_X86_64_GOTPCREL to
3109 if ((relocx
|| opcode
== 0x8b)
3110 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
,
3112 elf_x86_64_hash_entry (h
)))
3116 /* Skip for branch instructions since R_X86_64_PC32
3118 if (require_reloc_pc32
)
3123 /* For non-branch instructions, we can convert to
3124 R_X86_64_32/R_X86_64_32S since we know if there
3126 to_reloc_pc32
= FALSE
;
3129 /* Since we don't know the current PC when PIC is true,
3130 we can't convert to R_X86_64_PC32. */
3131 if (to_reloc_pc32
&& is_pic
)
3136 else if ((h
->def_regular
3137 || h
->root
.type
== bfd_link_hash_defined
3138 || h
->root
.type
== bfd_link_hash_defweak
)
3139 && h
!= htab
->elf
.hdynamic
3140 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
3142 /* bfd_link_hash_new or bfd_link_hash_undefined is
3143 set by an assignment in a linker script in
3144 bfd_elf_record_link_assignment. */
3146 && (h
->root
.type
== bfd_link_hash_new
3147 || h
->root
.type
== bfd_link_hash_undefined
))
3149 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */
3150 if (require_reloc_pc32
)
3154 tsec
= h
->root
.u
.def
.section
;
3155 toff
= h
->root
.u
.def
.value
;
3162 /* We can only estimate relocation overflow for R_X86_64_PC32. */
3166 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
3168 /* At this stage in linking, no SEC_MERGE symbol has been
3169 adjusted, so all references to such symbols need to be
3170 passed through _bfd_merged_section_offset. (Later, in
3171 relocate_section, all SEC_MERGE symbols *except* for
3172 section symbols have been adjusted.)
3174 gas may reduce relocations against symbols in SEC_MERGE
3175 sections to a relocation against the section symbol when
3176 the original addend was zero. When the reloc is against
3177 a section symbol we should include the addend in the
3178 offset passed to _bfd_merged_section_offset, since the
3179 location of interest is the original symbol. On the
3180 other hand, an access to "sym+addend" where "sym" is not
3181 a section symbol should not include the addend; Such an
3182 access is presumed to be an offset from "sym"; The
3183 location of interest is just "sym". */
3184 if (symtype
== STT_SECTION
)
3187 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
3188 elf_section_data (tsec
)->sec_info
,
3191 if (symtype
!= STT_SECTION
)
3197 /* Don't convert if R_X86_64_PC32 relocation overflows. */
3198 if (tsec
->output_section
== sec
->output_section
)
3200 if ((toff
- roff
+ 0x80000000) > 0xffffffff)
3205 bfd_signed_vma distance
;
3207 /* At this point, we don't know the load addresses of TSEC
3208 section nor SEC section. We estimate the distrance between
3209 SEC and TSEC. We store the estimated distances in the
3210 compressed_size field of the output section, which is only
3211 used to decompress the compressed input section. */
3212 if (sec
->output_section
->compressed_size
== 0)
3215 bfd_size_type size
= 0;
3216 for (asect
= link_info
->output_bfd
->sections
;
3218 asect
= asect
->next
)
3219 /* Skip debug sections since compressed_size is used to
3220 compress debug sections. */
3221 if ((asect
->flags
& SEC_DEBUGGING
) == 0)
3224 for (i
= asect
->map_head
.s
;
3228 size
= align_power (size
, i
->alignment_power
);
3231 asect
->compressed_size
= size
;
3235 /* Don't convert GOTPCREL relocations if TSEC isn't placed
3237 distance
= (tsec
->output_section
->compressed_size
3238 - sec
->output_section
->compressed_size
);
3242 /* Take PT_GNU_RELRO segment into account by adding
3244 if ((toff
+ distance
+ maxpagesize
- roff
+ 0x80000000)
3252 /* We have "call/jmp *foo@GOTPCREL(%rip)". */
3257 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
3259 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
3262 /* Convert to "jmp foo nop". */
3265 nop_offset
= irel
->r_offset
+ 3;
3266 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
3267 irel
->r_offset
-= 1;
3268 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
3272 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
3275 nop
= link_info
->call_nop_byte
;
3276 if (link_info
->call_nop_as_suffix
)
3278 nop_offset
= irel
->r_offset
+ 3;
3279 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
3280 irel
->r_offset
-= 1;
3281 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
3284 nop_offset
= irel
->r_offset
- 2;
3286 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
3287 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
3288 r_type
= R_X86_64_PC32
;
3293 unsigned int rex_mask
= REX_R
;
3295 if (r_type
== R_X86_64_REX_GOTPCRELX
)
3296 rex
= bfd_get_8 (abfd
, contents
+ roff
- 3);
3304 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
3305 "lea foo(%rip), %reg". */
3307 r_type
= R_X86_64_PC32
;
3311 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
3312 "mov $foo, %reg". */
3314 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
3315 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
3316 if ((rex
& REX_W
) != 0
3317 && ABI_64_P (link_info
->output_bfd
))
3319 /* Keep the REX_W bit in REX byte for LP64. */
3320 r_type
= R_X86_64_32S
;
3321 goto rewrite_modrm_rex
;
3325 /* If the REX_W bit in REX byte isn't needed,
3326 use R_X86_64_32 and clear the W bit to avoid
3327 sign-extend imm32 to imm64. */
3328 r_type
= R_X86_64_32
;
3329 /* Clear the W bit in REX byte. */
3331 goto rewrite_modrm_rex
;
3337 /* R_X86_64_PC32 isn't supported. */
3341 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
3344 /* Convert "test %reg, foo@GOTPCREL(%rip)" to
3345 "test $foo, %reg". */
3346 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
3351 /* Convert "binop foo@GOTPCREL(%rip), %reg" to
3352 "binop $foo, %reg". */
3353 modrm
= 0xc0 | (modrm
& 0x38) >> 3 | (opcode
& 0x3c);
3357 /* Use R_X86_64_32 with 32-bit operand to avoid relocation
3358 overflow when sign-extending imm32 to imm64. */
3359 r_type
= (rex
& REX_W
) != 0 ? R_X86_64_32S
: R_X86_64_32
;
3362 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
3366 /* Move the R bit to the B bit in REX byte. */
3367 rex
= (rex
& ~rex_mask
) | (rex
& REX_R
) >> 2;
3368 bfd_put_8 (abfd
, rex
, contents
+ roff
- 3);
3371 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */
3375 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
3378 irel
->r_info
= htab
->r_info (r_symndx
, r_type
);
3379 changed_contents
= TRUE
;
3380 changed_relocs
= TRUE
;
3384 if (h
->got
.refcount
> 0)
3385 h
->got
.refcount
-= 1;
3389 if (local_got_refcounts
!= NULL
3390 && local_got_refcounts
[r_symndx
] > 0)
3391 local_got_refcounts
[r_symndx
] -= 1;
3395 if (contents
!= NULL
3396 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3398 if (!changed_contents
&& !link_info
->keep_memory
)
3402 /* Cache the section contents for elf_link_input_bfd. */
3403 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3407 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3409 if (!changed_relocs
)
3410 free (internal_relocs
);
3412 elf_section_data (sec
)->relocs
= internal_relocs
;
3418 if (contents
!= NULL
3419 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3421 if (internal_relocs
!= NULL
3422 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3423 free (internal_relocs
);
3427 /* Set the sizes of the dynamic sections. */
3430 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
3431 struct bfd_link_info
*info
)
3433 struct elf_x86_64_link_hash_table
*htab
;
3438 const struct elf_backend_data
*bed
;
3440 htab
= elf_x86_64_hash_table (info
);
3443 bed
= get_elf_backend_data (output_bfd
);
3445 dynobj
= htab
->elf
.dynobj
;
3449 if (htab
->elf
.dynamic_sections_created
)
3451 /* Set the contents of the .interp section to the interpreter. */
3452 if (bfd_link_executable (info
) && !info
->nointerp
)
3454 s
= bfd_get_linker_section (dynobj
, ".interp");
3457 s
->size
= htab
->dynamic_interpreter_size
;
3458 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
3463 /* Set up .got offsets for local syms, and space for local dynamic
3465 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3467 bfd_signed_vma
*local_got
;
3468 bfd_signed_vma
*end_local_got
;
3469 char *local_tls_type
;
3470 bfd_vma
*local_tlsdesc_gotent
;
3471 bfd_size_type locsymcount
;
3472 Elf_Internal_Shdr
*symtab_hdr
;
3475 if (! is_x86_64_elf (ibfd
))
3478 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3480 struct elf_dyn_relocs
*p
;
3482 if (!elf_x86_64_convert_load (ibfd
, s
, info
))
3485 for (p
= (struct elf_dyn_relocs
*)
3486 (elf_section_data (s
)->local_dynrel
);
3490 if (!bfd_is_abs_section (p
->sec
)
3491 && bfd_is_abs_section (p
->sec
->output_section
))
3493 /* Input section has been discarded, either because
3494 it is a copy of a linkonce section or due to
3495 linker script /DISCARD/, so we'll be discarding
3498 else if (p
->count
!= 0)
3500 srel
= elf_section_data (p
->sec
)->sreloc
;
3501 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3502 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3503 && (info
->flags
& DF_TEXTREL
) == 0)
3505 info
->flags
|= DF_TEXTREL
;
3506 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3507 || info
->error_textrel
)
3508 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3509 p
->sec
->owner
, p
->sec
);
3515 local_got
= elf_local_got_refcounts (ibfd
);
3519 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3520 locsymcount
= symtab_hdr
->sh_info
;
3521 end_local_got
= local_got
+ locsymcount
;
3522 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
3523 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
3525 srel
= htab
->elf
.srelgot
;
3526 for (; local_got
< end_local_got
;
3527 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3529 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3532 if (GOT_TLS_GDESC_P (*local_tls_type
))
3534 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3535 - elf_x86_64_compute_jump_table_size (htab
);
3536 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3537 *local_got
= (bfd_vma
) -2;
3539 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3540 || GOT_TLS_GD_P (*local_tls_type
))
3542 *local_got
= s
->size
;
3543 s
->size
+= GOT_ENTRY_SIZE
;
3544 if (GOT_TLS_GD_P (*local_tls_type
))
3545 s
->size
+= GOT_ENTRY_SIZE
;
3547 if (bfd_link_pic (info
)
3548 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3549 || *local_tls_type
== GOT_TLS_IE
)
3551 if (GOT_TLS_GDESC_P (*local_tls_type
))
3553 htab
->elf
.srelplt
->size
3554 += bed
->s
->sizeof_rela
;
3555 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3557 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3558 || GOT_TLS_GD_P (*local_tls_type
))
3559 srel
->size
+= bed
->s
->sizeof_rela
;
3563 *local_got
= (bfd_vma
) -1;
3567 if (htab
->tls_ld_got
.refcount
> 0)
3569 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3571 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
3572 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
3573 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3576 htab
->tls_ld_got
.offset
= -1;
3578 /* Allocate global sym .plt and .got entries, and space for global
3579 sym dynamic relocs. */
3580 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
3583 /* Allocate .plt and .got entries, and space for local symbols. */
3584 htab_traverse (htab
->loc_hash_table
,
3585 elf_x86_64_allocate_local_dynrelocs
,
3588 /* For every jump slot reserved in the sgotplt, reloc_count is
3589 incremented. However, when we reserve space for TLS descriptors,
3590 it's not incremented, so in order to compute the space reserved
3591 for them, it suffices to multiply the reloc count by the jump
3594 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3595 so that R_X86_64_IRELATIVE entries come last. */
3596 if (htab
->elf
.srelplt
)
3598 htab
->sgotplt_jump_table_size
3599 = elf_x86_64_compute_jump_table_size (htab
);
3600 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3602 else if (htab
->elf
.irelplt
)
3603 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3605 if (htab
->tlsdesc_plt
)
3607 /* If we're not using lazy TLS relocations, don't generate the
3608 PLT and GOT entries they require. */
3609 if ((info
->flags
& DF_BIND_NOW
))
3610 htab
->tlsdesc_plt
= 0;
3613 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
3614 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
3615 /* Reserve room for the initial entry.
3616 FIXME: we could probably do away with it in this case. */
3617 if (htab
->elf
.splt
->size
== 0)
3618 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3619 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
3620 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3624 if (htab
->elf
.sgotplt
)
3626 /* Don't allocate .got.plt section if there are no GOT nor PLT
3627 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3628 if ((htab
->elf
.hgot
== NULL
3629 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3630 && (htab
->elf
.sgotplt
->size
3631 == get_elf_backend_data (output_bfd
)->got_header_size
)
3632 && (htab
->elf
.splt
== NULL
3633 || htab
->elf
.splt
->size
== 0)
3634 && (htab
->elf
.sgot
== NULL
3635 || htab
->elf
.sgot
->size
== 0)
3636 && (htab
->elf
.iplt
== NULL
3637 || htab
->elf
.iplt
->size
== 0)
3638 && (htab
->elf
.igotplt
== NULL
3639 || htab
->elf
.igotplt
->size
== 0))
3640 htab
->elf
.sgotplt
->size
= 0;
3643 if (htab
->plt_eh_frame
!= NULL
3644 && htab
->elf
.splt
!= NULL
3645 && htab
->elf
.splt
->size
!= 0
3646 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3647 && _bfd_elf_eh_frame_present (info
))
3649 const struct elf_x86_64_backend_data
*arch_data
3650 = get_elf_x86_64_arch_data (bed
);
3651 htab
->plt_eh_frame
->size
= arch_data
->eh_frame_plt_size
;
3654 /* We now have determined the sizes of the various dynamic sections.
3655 Allocate memory for them. */
3657 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3659 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3662 if (s
== htab
->elf
.splt
3663 || s
== htab
->elf
.sgot
3664 || s
== htab
->elf
.sgotplt
3665 || s
== htab
->elf
.iplt
3666 || s
== htab
->elf
.igotplt
3667 || s
== htab
->plt_bnd
3668 || s
== htab
->plt_got
3669 || s
== htab
->plt_eh_frame
3670 || s
== htab
->sdynbss
)
3672 /* Strip this section if we don't need it; see the
3675 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3677 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
3680 /* We use the reloc_count field as a counter if we need
3681 to copy relocs into the output file. */
3682 if (s
!= htab
->elf
.srelplt
)
3687 /* It's not one of our sections, so don't allocate space. */
3693 /* If we don't need this section, strip it from the
3694 output file. This is mostly to handle .rela.bss and
3695 .rela.plt. We must create both sections in
3696 create_dynamic_sections, because they must be created
3697 before the linker maps input sections to output
3698 sections. The linker does that before
3699 adjust_dynamic_symbol is called, and it is that
3700 function which decides whether anything needs to go
3701 into these sections. */
3703 s
->flags
|= SEC_EXCLUDE
;
3707 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3710 /* Allocate memory for the section contents. We use bfd_zalloc
3711 here in case unused entries are not reclaimed before the
3712 section's contents are written out. This should not happen,
3713 but this way if it does, we get a R_X86_64_NONE reloc instead
3715 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3716 if (s
->contents
== NULL
)
3720 if (htab
->plt_eh_frame
!= NULL
3721 && htab
->plt_eh_frame
->contents
!= NULL
)
3723 const struct elf_x86_64_backend_data
*arch_data
3724 = get_elf_x86_64_arch_data (bed
);
3726 memcpy (htab
->plt_eh_frame
->contents
,
3727 arch_data
->eh_frame_plt
, htab
->plt_eh_frame
->size
);
3728 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3729 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3732 if (htab
->elf
.dynamic_sections_created
)
3734 /* Add some entries to the .dynamic section. We fill in the
3735 values later, in elf_x86_64_finish_dynamic_sections, but we
3736 must add the entries now so that we get the correct size for
3737 the .dynamic section. The DT_DEBUG entry is filled in by the
3738 dynamic linker and used by the debugger. */
3739 #define add_dynamic_entry(TAG, VAL) \
3740 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3742 if (bfd_link_executable (info
))
3744 if (!add_dynamic_entry (DT_DEBUG
, 0))
3748 if (htab
->elf
.splt
->size
!= 0)
3750 /* DT_PLTGOT is used by prelink even if there is no PLT
3752 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3755 if (htab
->elf
.srelplt
->size
!= 0)
3757 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3758 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3759 || !add_dynamic_entry (DT_JMPREL
, 0))
3763 if (htab
->tlsdesc_plt
3764 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3765 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3771 if (!add_dynamic_entry (DT_RELA
, 0)
3772 || !add_dynamic_entry (DT_RELASZ
, 0)
3773 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3776 /* If any dynamic relocs apply to a read-only section,
3777 then we need a DT_TEXTREL entry. */
3778 if ((info
->flags
& DF_TEXTREL
) == 0)
3779 elf_link_hash_traverse (&htab
->elf
,
3780 elf_x86_64_readonly_dynrelocs
,
3783 if ((info
->flags
& DF_TEXTREL
) != 0)
3785 if (htab
->readonly_dynrelocs_against_ifunc
)
3787 info
->callbacks
->einfo
3788 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3789 bfd_set_error (bfd_error_bad_value
);
3793 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3798 #undef add_dynamic_entry
3804 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3805 struct bfd_link_info
*info
)
3807 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3811 struct elf_link_hash_entry
*tlsbase
;
3813 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3814 "_TLS_MODULE_BASE_",
3815 FALSE
, FALSE
, FALSE
);
3817 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3819 struct elf_x86_64_link_hash_table
*htab
;
3820 struct bfd_link_hash_entry
*bh
= NULL
;
3821 const struct elf_backend_data
*bed
3822 = get_elf_backend_data (output_bfd
);
3824 htab
= elf_x86_64_hash_table (info
);
3828 if (!(_bfd_generic_link_add_one_symbol
3829 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3830 tls_sec
, 0, NULL
, FALSE
,
3831 bed
->collect
, &bh
)))
3834 htab
->tls_module_base
= bh
;
3836 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3837 tlsbase
->def_regular
= 1;
3838 tlsbase
->other
= STV_HIDDEN
;
3839 tlsbase
->root
.linker_def
= 1;
3840 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3847 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3848 executables. Rather than setting it to the beginning of the TLS
3849 section, we have to set it to the end. This function may be called
3850 multiple times, it is idempotent. */
3853 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
3855 struct elf_x86_64_link_hash_table
*htab
;
3856 struct bfd_link_hash_entry
*base
;
3858 if (!bfd_link_executable (info
))
3861 htab
= elf_x86_64_hash_table (info
);
3865 base
= htab
->tls_module_base
;
3869 base
->u
.def
.value
= htab
->elf
.tls_size
;
3872 /* Return the base VMA address which should be subtracted from real addresses
3873 when resolving @dtpoff relocation.
3874 This is PT_TLS segment p_vaddr. */
3877 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
3879 /* If tls_sec is NULL, we should have signalled an error already. */
3880 if (elf_hash_table (info
)->tls_sec
== NULL
)
3882 return elf_hash_table (info
)->tls_sec
->vma
;
3885 /* Return the relocation value for @tpoff relocation
3886 if STT_TLS virtual address is ADDRESS. */
3889 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3891 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3892 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
3893 bfd_vma static_tls_size
;
3895 /* If tls_segment is NULL, we should have signalled an error already. */
3896 if (htab
->tls_sec
== NULL
)
3899 /* Consider special static TLS alignment requirements. */
3900 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
3901 return address
- static_tls_size
- htab
->tls_sec
->vma
;
3904 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
3908 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
3910 /* Opcode Instruction
3913 0x0f 0x8x conditional jump */
3915 && (contents
[offset
- 1] == 0xe8
3916 || contents
[offset
- 1] == 0xe9))
3918 && contents
[offset
- 2] == 0x0f
3919 && (contents
[offset
- 1] & 0xf0) == 0x80));
3922 /* Relocate an x86_64 ELF section. */
3925 elf_x86_64_relocate_section (bfd
*output_bfd
,
3926 struct bfd_link_info
*info
,
3928 asection
*input_section
,
3930 Elf_Internal_Rela
*relocs
,
3931 Elf_Internal_Sym
*local_syms
,
3932 asection
**local_sections
)
3934 struct elf_x86_64_link_hash_table
*htab
;
3935 Elf_Internal_Shdr
*symtab_hdr
;
3936 struct elf_link_hash_entry
**sym_hashes
;
3937 bfd_vma
*local_got_offsets
;
3938 bfd_vma
*local_tlsdesc_gotents
;
3939 Elf_Internal_Rela
*rel
;
3940 Elf_Internal_Rela
*wrel
;
3941 Elf_Internal_Rela
*relend
;
3942 const unsigned int plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
3944 BFD_ASSERT (is_x86_64_elf (input_bfd
));
3946 /* Skip if check_relocs failed. */
3947 if (input_section
->check_relocs_failed
)
3950 htab
= elf_x86_64_hash_table (info
);
3953 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
3954 sym_hashes
= elf_sym_hashes (input_bfd
);
3955 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3956 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
3958 elf_x86_64_set_tls_module_base (info
);
3960 rel
= wrel
= relocs
;
3961 relend
= relocs
+ input_section
->reloc_count
;
3962 for (; rel
< relend
; wrel
++, rel
++)
3964 unsigned int r_type
;
3965 reloc_howto_type
*howto
;
3966 unsigned long r_symndx
;
3967 struct elf_link_hash_entry
*h
;
3968 struct elf_x86_64_link_hash_entry
*eh
;
3969 Elf_Internal_Sym
*sym
;
3971 bfd_vma off
, offplt
, plt_offset
;
3973 bfd_boolean unresolved_reloc
;
3974 bfd_reloc_status_type r
;
3976 asection
*base_got
, *resolved_plt
;
3978 bfd_boolean resolved_to_zero
;
3980 r_type
= ELF32_R_TYPE (rel
->r_info
);
3981 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
3982 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
3989 if (r_type
>= (int) R_X86_64_standard
)
3991 (*_bfd_error_handler
)
3992 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
3993 input_bfd
, input_section
, r_type
);
3994 bfd_set_error (bfd_error_bad_value
);
3998 if (r_type
!= (int) R_X86_64_32
3999 || ABI_64_P (output_bfd
))
4000 howto
= x86_64_elf_howto_table
+ r_type
;
4002 howto
= (x86_64_elf_howto_table
4003 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
4004 r_symndx
= htab
->r_sym (rel
->r_info
);
4008 unresolved_reloc
= FALSE
;
4009 if (r_symndx
< symtab_hdr
->sh_info
)
4011 sym
= local_syms
+ r_symndx
;
4012 sec
= local_sections
[r_symndx
];
4014 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
4016 st_size
= sym
->st_size
;
4018 /* Relocate against local STT_GNU_IFUNC symbol. */
4019 if (!bfd_link_relocatable (info
)
4020 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
4022 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
4027 /* Set STT_GNU_IFUNC symbol value. */
4028 h
->root
.u
.def
.value
= sym
->st_value
;
4029 h
->root
.u
.def
.section
= sec
;
4034 bfd_boolean warned ATTRIBUTE_UNUSED
;
4035 bfd_boolean ignored ATTRIBUTE_UNUSED
;
4037 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
4038 r_symndx
, symtab_hdr
, sym_hashes
,
4040 unresolved_reloc
, warned
, ignored
);
4044 if (sec
!= NULL
&& discarded_section (sec
))
4046 _bfd_clear_contents (howto
, input_bfd
, input_section
,
4047 contents
+ rel
->r_offset
);
4048 wrel
->r_offset
= rel
->r_offset
;
4052 /* For ld -r, remove relocations in debug sections against
4053 sections defined in discarded sections. Not done for
4054 eh_frame editing code expects to be present. */
4055 if (bfd_link_relocatable (info
)
4056 && (input_section
->flags
& SEC_DEBUGGING
))
4062 if (bfd_link_relocatable (info
))
4069 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
4071 if (r_type
== R_X86_64_64
)
4073 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
4074 zero-extend it to 64bit if addend is zero. */
4075 r_type
= R_X86_64_32
;
4076 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4078 else if (r_type
== R_X86_64_SIZE64
)
4080 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
4081 zero-extend it to 64bit if addend is zero. */
4082 r_type
= R_X86_64_SIZE32
;
4083 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4087 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
4089 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
4090 it here if it is defined in a non-shared object. */
4092 && h
->type
== STT_GNU_IFUNC
4098 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4100 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4101 sections because such sections are not SEC_ALLOC and
4102 thus ld.so will not process them. */
4103 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
4107 else if (h
->plt
.offset
== (bfd_vma
) -1)
4110 /* STT_GNU_IFUNC symbol must go through PLT. */
4111 if (htab
->elf
.splt
!= NULL
)
4113 if (htab
->plt_bnd
!= NULL
)
4115 resolved_plt
= htab
->plt_bnd
;
4116 plt_offset
= eh
->plt_bnd
.offset
;
4120 resolved_plt
= htab
->elf
.splt
;
4121 plt_offset
= h
->plt
.offset
;
4126 resolved_plt
= htab
->elf
.iplt
;
4127 plt_offset
= h
->plt
.offset
;
4130 relocation
= (resolved_plt
->output_section
->vma
4131 + resolved_plt
->output_offset
+ plt_offset
);
4136 if (h
->root
.root
.string
)
4137 name
= h
->root
.root
.string
;
4139 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4141 (*_bfd_error_handler
)
4142 (_("%B: relocation %s against STT_GNU_IFUNC "
4143 "symbol `%s' isn't handled by %s"), input_bfd
,
4144 howto
->name
, name
, __FUNCTION__
);
4145 bfd_set_error (bfd_error_bad_value
);
4149 if (bfd_link_pic (info
))
4154 if (ABI_64_P (output_bfd
))
4158 if (rel
->r_addend
!= 0)
4160 if (h
->root
.root
.string
)
4161 name
= h
->root
.root
.string
;
4163 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4165 (*_bfd_error_handler
)
4166 (_("%B: relocation %s against STT_GNU_IFUNC "
4167 "symbol `%s' has non-zero addend: %d"),
4168 input_bfd
, howto
->name
, name
, rel
->r_addend
);
4169 bfd_set_error (bfd_error_bad_value
);
4173 /* Generate dynamic relcoation only when there is a
4174 non-GOT reference in a shared object. */
4175 if (bfd_link_pic (info
) && h
->non_got_ref
)
4177 Elf_Internal_Rela outrel
;
4180 /* Need a dynamic relocation to get the real function
4182 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
4186 if (outrel
.r_offset
== (bfd_vma
) -1
4187 || outrel
.r_offset
== (bfd_vma
) -2)
4190 outrel
.r_offset
+= (input_section
->output_section
->vma
4191 + input_section
->output_offset
);
4193 if (h
->dynindx
== -1
4195 || bfd_link_executable (info
))
4197 /* This symbol is resolved locally. */
4198 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4199 outrel
.r_addend
= (h
->root
.u
.def
.value
4200 + h
->root
.u
.def
.section
->output_section
->vma
4201 + h
->root
.u
.def
.section
->output_offset
);
4205 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4206 outrel
.r_addend
= 0;
4209 sreloc
= htab
->elf
.irelifunc
;
4210 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4212 /* If this reloc is against an external symbol, we
4213 do not want to fiddle with the addend. Otherwise,
4214 we need to include the symbol value so that it
4215 becomes an addend for the dynamic reloc. For an
4216 internal symbol, we have updated addend. */
4221 case R_X86_64_PC32_BND
:
4223 case R_X86_64_PLT32
:
4224 case R_X86_64_PLT32_BND
:
4227 case R_X86_64_GOTPCREL
:
4228 case R_X86_64_GOTPCRELX
:
4229 case R_X86_64_REX_GOTPCRELX
:
4230 case R_X86_64_GOTPCREL64
:
4231 base_got
= htab
->elf
.sgot
;
4232 off
= h
->got
.offset
;
4234 if (base_got
== NULL
)
4237 if (off
== (bfd_vma
) -1)
4239 /* We can't use h->got.offset here to save state, or
4240 even just remember the offset, as finish_dynamic_symbol
4241 would use that as offset into .got. */
4243 if (htab
->elf
.splt
!= NULL
)
4245 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4246 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4247 base_got
= htab
->elf
.sgotplt
;
4251 plt_index
= h
->plt
.offset
/ plt_entry_size
;
4252 off
= plt_index
* GOT_ENTRY_SIZE
;
4253 base_got
= htab
->elf
.igotplt
;
4256 if (h
->dynindx
== -1
4260 /* This references the local defitionion. We must
4261 initialize this entry in the global offset table.
4262 Since the offset must always be a multiple of 8,
4263 we use the least significant bit to record
4264 whether we have initialized it already.
4266 When doing a dynamic link, we create a .rela.got
4267 relocation entry to initialize the value. This
4268 is done in the finish_dynamic_symbol routine. */
4273 bfd_put_64 (output_bfd
, relocation
,
4274 base_got
->contents
+ off
);
4275 /* Note that this is harmless for the GOTPLT64
4276 case, as -1 | 1 still is -1. */
4282 relocation
= (base_got
->output_section
->vma
4283 + base_got
->output_offset
+ off
);
4289 resolved_to_zero
= (eh
!= NULL
4290 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
4294 /* When generating a shared object, the relocations handled here are
4295 copied into the output file to be resolved at run time. */
4298 case R_X86_64_GOT32
:
4299 case R_X86_64_GOT64
:
4300 /* Relocation is to the entry for this symbol in the global
4302 case R_X86_64_GOTPCREL
:
4303 case R_X86_64_GOTPCRELX
:
4304 case R_X86_64_REX_GOTPCRELX
:
4305 case R_X86_64_GOTPCREL64
:
4306 /* Use global offset table entry as symbol value. */
4307 case R_X86_64_GOTPLT64
:
4308 /* This is obsolete and treated the the same as GOT64. */
4309 base_got
= htab
->elf
.sgot
;
4311 if (htab
->elf
.sgot
== NULL
)
4318 off
= h
->got
.offset
;
4320 && h
->plt
.offset
!= (bfd_vma
)-1
4321 && off
== (bfd_vma
)-1)
4323 /* We can't use h->got.offset here to save
4324 state, or even just remember the offset, as
4325 finish_dynamic_symbol would use that as offset into
4327 bfd_vma plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4328 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4329 base_got
= htab
->elf
.sgotplt
;
4332 dyn
= htab
->elf
.dynamic_sections_created
;
4334 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
4335 || (bfd_link_pic (info
)
4336 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4337 || (ELF_ST_VISIBILITY (h
->other
)
4338 && h
->root
.type
== bfd_link_hash_undefweak
))
4340 /* This is actually a static link, or it is a -Bsymbolic
4341 link and the symbol is defined locally, or the symbol
4342 was forced to be local because of a version file. We
4343 must initialize this entry in the global offset table.
4344 Since the offset must always be a multiple of 8, we
4345 use the least significant bit to record whether we
4346 have initialized it already.
4348 When doing a dynamic link, we create a .rela.got
4349 relocation entry to initialize the value. This is
4350 done in the finish_dynamic_symbol routine. */
4355 bfd_put_64 (output_bfd
, relocation
,
4356 base_got
->contents
+ off
);
4357 /* Note that this is harmless for the GOTPLT64 case,
4358 as -1 | 1 still is -1. */
4363 unresolved_reloc
= FALSE
;
4367 if (local_got_offsets
== NULL
)
4370 off
= local_got_offsets
[r_symndx
];
4372 /* The offset must always be a multiple of 8. We use
4373 the least significant bit to record whether we have
4374 already generated the necessary reloc. */
4379 bfd_put_64 (output_bfd
, relocation
,
4380 base_got
->contents
+ off
);
4382 if (bfd_link_pic (info
))
4385 Elf_Internal_Rela outrel
;
4387 /* We need to generate a R_X86_64_RELATIVE reloc
4388 for the dynamic linker. */
4389 s
= htab
->elf
.srelgot
;
4393 outrel
.r_offset
= (base_got
->output_section
->vma
4394 + base_got
->output_offset
4396 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4397 outrel
.r_addend
= relocation
;
4398 elf_append_rela (output_bfd
, s
, &outrel
);
4401 local_got_offsets
[r_symndx
] |= 1;
4405 if (off
>= (bfd_vma
) -2)
4408 relocation
= base_got
->output_section
->vma
4409 + base_got
->output_offset
+ off
;
4410 if (r_type
!= R_X86_64_GOTPCREL
4411 && r_type
!= R_X86_64_GOTPCRELX
4412 && r_type
!= R_X86_64_REX_GOTPCRELX
4413 && r_type
!= R_X86_64_GOTPCREL64
)
4414 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4415 - htab
->elf
.sgotplt
->output_offset
;
4419 case R_X86_64_GOTOFF64
:
4420 /* Relocation is relative to the start of the global offset
4423 /* Check to make sure it isn't a protected function or data
4424 symbol for shared library since it may not be local when
4425 used as function address or with copy relocation. We also
4426 need to make sure that a symbol is referenced locally. */
4427 if (bfd_link_pic (info
) && h
)
4429 if (!h
->def_regular
)
4433 switch (ELF_ST_VISIBILITY (h
->other
))
4436 v
= _("hidden symbol");
4439 v
= _("internal symbol");
4442 v
= _("protected symbol");
4449 (*_bfd_error_handler
)
4450 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s `%s' can not be used when making a shared object"),
4451 input_bfd
, v
, h
->root
.root
.string
);
4452 bfd_set_error (bfd_error_bad_value
);
4455 else if (!bfd_link_executable (info
)
4456 && !SYMBOL_REFERENCES_LOCAL (info
, h
)
4457 && (h
->type
== STT_FUNC
4458 || h
->type
== STT_OBJECT
)
4459 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4461 (*_bfd_error_handler
)
4462 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s `%s' can not be used when making a shared object"),
4464 h
->type
== STT_FUNC
? "function" : "data",
4465 h
->root
.root
.string
);
4466 bfd_set_error (bfd_error_bad_value
);
4471 /* Note that sgot is not involved in this
4472 calculation. We always want the start of .got.plt. If we
4473 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4474 permitted by the ABI, we might have to change this
4476 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4477 + htab
->elf
.sgotplt
->output_offset
;
4480 case R_X86_64_GOTPC32
:
4481 case R_X86_64_GOTPC64
:
4482 /* Use global offset table as symbol value. */
4483 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4484 + htab
->elf
.sgotplt
->output_offset
;
4485 unresolved_reloc
= FALSE
;
4488 case R_X86_64_PLTOFF64
:
4489 /* Relocation is PLT entry relative to GOT. For local
4490 symbols it's the symbol itself relative to GOT. */
4492 /* See PLT32 handling. */
4493 && h
->plt
.offset
!= (bfd_vma
) -1
4494 && htab
->elf
.splt
!= NULL
)
4496 if (htab
->plt_bnd
!= NULL
)
4498 resolved_plt
= htab
->plt_bnd
;
4499 plt_offset
= eh
->plt_bnd
.offset
;
4503 resolved_plt
= htab
->elf
.splt
;
4504 plt_offset
= h
->plt
.offset
;
4507 relocation
= (resolved_plt
->output_section
->vma
4508 + resolved_plt
->output_offset
4510 unresolved_reloc
= FALSE
;
4513 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4514 + htab
->elf
.sgotplt
->output_offset
;
4517 case R_X86_64_PLT32
:
4518 case R_X86_64_PLT32_BND
:
4519 /* Relocation is to the entry for this symbol in the
4520 procedure linkage table. */
4522 /* Resolve a PLT32 reloc against a local symbol directly,
4523 without using the procedure linkage table. */
4527 if ((h
->plt
.offset
== (bfd_vma
) -1
4528 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4529 || htab
->elf
.splt
== NULL
)
4531 /* We didn't make a PLT entry for this symbol. This
4532 happens when statically linking PIC code, or when
4533 using -Bsymbolic. */
4537 if (h
->plt
.offset
!= (bfd_vma
) -1)
4539 if (htab
->plt_bnd
!= NULL
)
4541 resolved_plt
= htab
->plt_bnd
;
4542 plt_offset
= eh
->plt_bnd
.offset
;
4546 resolved_plt
= htab
->elf
.splt
;
4547 plt_offset
= h
->plt
.offset
;
4552 /* Use the GOT PLT. */
4553 resolved_plt
= htab
->plt_got
;
4554 plt_offset
= eh
->plt_got
.offset
;
4557 relocation
= (resolved_plt
->output_section
->vma
4558 + resolved_plt
->output_offset
4560 unresolved_reloc
= FALSE
;
4563 case R_X86_64_SIZE32
:
4564 case R_X86_64_SIZE64
:
4565 /* Set to symbol size. */
4566 relocation
= st_size
;
4572 case R_X86_64_PC32_BND
:
4573 /* Don't complain about -fPIC if the symbol is undefined when
4574 building executable unless it is unresolved weak symbol. */
4575 if ((input_section
->flags
& SEC_ALLOC
) != 0
4576 && (input_section
->flags
& SEC_READONLY
) != 0
4578 && ((bfd_link_executable (info
)
4579 && h
->root
.type
== bfd_link_hash_undefweak
4580 && !resolved_to_zero
)
4581 || (bfd_link_pic (info
)
4582 && !(bfd_link_pie (info
)
4583 && h
->root
.type
== bfd_link_hash_undefined
))))
4585 bfd_boolean fail
= FALSE
;
4587 = ((r_type
== R_X86_64_PC32
4588 || r_type
== R_X86_64_PC32_BND
)
4589 && is_32bit_relative_branch (contents
, rel
->r_offset
));
4591 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
4593 /* Symbol is referenced locally. Make sure it is
4594 defined locally or for a branch. */
4595 fail
= !h
->def_regular
&& !branch
;
4597 else if (!(bfd_link_pie (info
)
4598 && (h
->needs_copy
|| eh
->needs_copy
)))
4600 /* Symbol doesn't need copy reloc and isn't referenced
4601 locally. We only allow branch to symbol with
4602 non-default visibility. */
4604 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
4608 return elf_x86_64_need_pic (input_bfd
, input_section
,
4609 h
, NULL
, NULL
, howto
);
4618 /* FIXME: The ABI says the linker should make sure the value is
4619 the same when it's zeroextended to 64 bit. */
4622 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4625 /* Don't copy a pc-relative relocation into the output file
4626 if the symbol needs copy reloc or the symbol is undefined
4627 when building executable. Copy dynamic function pointer
4628 relocations. Don't generate dynamic relocations against
4629 resolved undefined weak symbols in PIE. */
4630 if ((bfd_link_pic (info
)
4631 && !(bfd_link_pie (info
)
4635 || h
->root
.type
== bfd_link_hash_undefined
)
4636 && IS_X86_64_PCREL_TYPE (r_type
))
4638 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4639 && !resolved_to_zero
)
4640 || h
->root
.type
!= bfd_link_hash_undefweak
))
4641 && ((! IS_X86_64_PCREL_TYPE (r_type
)
4642 && r_type
!= R_X86_64_SIZE32
4643 && r_type
!= R_X86_64_SIZE64
)
4644 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
4645 || (ELIMINATE_COPY_RELOCS
4646 && !bfd_link_pic (info
)
4650 || eh
->func_pointer_refcount
> 0
4651 || (h
->root
.type
== bfd_link_hash_undefweak
4652 && !resolved_to_zero
))
4653 && ((h
->def_dynamic
&& !h
->def_regular
)
4654 /* Undefined weak symbol is bound locally when
4656 || h
->root
.type
== bfd_link_hash_undefined
)))
4658 Elf_Internal_Rela outrel
;
4659 bfd_boolean skip
, relocate
;
4662 /* When generating a shared object, these relocations
4663 are copied into the output file to be resolved at run
4669 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4671 if (outrel
.r_offset
== (bfd_vma
) -1)
4673 else if (outrel
.r_offset
== (bfd_vma
) -2)
4674 skip
= TRUE
, relocate
= TRUE
;
4676 outrel
.r_offset
+= (input_section
->output_section
->vma
4677 + input_section
->output_offset
);
4680 memset (&outrel
, 0, sizeof outrel
);
4682 /* h->dynindx may be -1 if this symbol was marked to
4686 && (IS_X86_64_PCREL_TYPE (r_type
)
4687 || !(bfd_link_executable (info
)
4688 || SYMBOLIC_BIND (info
, h
))
4689 || ! h
->def_regular
))
4691 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4692 outrel
.r_addend
= rel
->r_addend
;
4696 /* This symbol is local, or marked to become local.
4697 When relocation overflow check is disabled, we
4698 convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */
4699 if (r_type
== htab
->pointer_r_type
4700 || (r_type
== R_X86_64_32
4701 && info
->no_reloc_overflow_check
))
4704 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4705 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4707 else if (r_type
== R_X86_64_64
4708 && !ABI_64_P (output_bfd
))
4711 outrel
.r_info
= htab
->r_info (0,
4712 R_X86_64_RELATIVE64
);
4713 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4714 /* Check addend overflow. */
4715 if ((outrel
.r_addend
& 0x80000000)
4716 != (rel
->r_addend
& 0x80000000))
4719 int addend
= rel
->r_addend
;
4720 if (h
&& h
->root
.root
.string
)
4721 name
= h
->root
.root
.string
;
4723 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4726 (*_bfd_error_handler
)
4727 (_("%B: addend -0x%x in relocation %s against "
4728 "symbol `%s' at 0x%lx in section `%A' is "
4730 input_bfd
, input_section
, addend
,
4732 (unsigned long) rel
->r_offset
);
4734 (*_bfd_error_handler
)
4735 (_("%B: addend 0x%x in relocation %s against "
4736 "symbol `%s' at 0x%lx in section `%A' is "
4738 input_bfd
, input_section
, addend
,
4740 (unsigned long) rel
->r_offset
);
4741 bfd_set_error (bfd_error_bad_value
);
4749 if (bfd_is_abs_section (sec
))
4751 else if (sec
== NULL
|| sec
->owner
== NULL
)
4753 bfd_set_error (bfd_error_bad_value
);
4760 /* We are turning this relocation into one
4761 against a section symbol. It would be
4762 proper to subtract the symbol's value,
4763 osec->vma, from the emitted reloc addend,
4764 but ld.so expects buggy relocs. */
4765 osec
= sec
->output_section
;
4766 sindx
= elf_section_data (osec
)->dynindx
;
4769 asection
*oi
= htab
->elf
.text_index_section
;
4770 sindx
= elf_section_data (oi
)->dynindx
;
4772 BFD_ASSERT (sindx
!= 0);
4775 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
4776 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4780 sreloc
= elf_section_data (input_section
)->sreloc
;
4782 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4784 r
= bfd_reloc_notsupported
;
4785 goto check_relocation_error
;
4788 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4790 /* If this reloc is against an external symbol, we do
4791 not want to fiddle with the addend. Otherwise, we
4792 need to include the symbol value so that it becomes
4793 an addend for the dynamic reloc. */
4800 case R_X86_64_TLSGD
:
4801 case R_X86_64_GOTPC32_TLSDESC
:
4802 case R_X86_64_TLSDESC_CALL
:
4803 case R_X86_64_GOTTPOFF
:
4804 tls_type
= GOT_UNKNOWN
;
4805 if (h
== NULL
&& local_got_offsets
)
4806 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
4808 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
4810 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4811 input_section
, contents
,
4812 symtab_hdr
, sym_hashes
,
4813 &r_type
, tls_type
, rel
,
4814 relend
, h
, r_symndx
))
4817 if (r_type
== R_X86_64_TPOFF32
)
4819 bfd_vma roff
= rel
->r_offset
;
4821 BFD_ASSERT (! unresolved_reloc
);
4823 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4825 /* GD->LE transition. For 64bit, change
4826 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4827 .word 0x6666; rex64; call __tls_get_addr
4830 leaq foo@tpoff(%rax), %rax
4832 leaq foo@tlsgd(%rip), %rdi
4833 .word 0x6666; rex64; call __tls_get_addr
4836 leaq foo@tpoff(%rax), %rax
4837 For largepic, change:
4838 leaq foo@tlsgd(%rip), %rdi
4839 movabsq $__tls_get_addr@pltoff, %rax
4844 leaq foo@tpoff(%rax), %rax
4845 nopw 0x0(%rax,%rax,1) */
4847 if (ABI_64_P (output_bfd
)
4848 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
4850 memcpy (contents
+ roff
- 3,
4851 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
4852 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4855 else if (ABI_64_P (output_bfd
))
4856 memcpy (contents
+ roff
- 4,
4857 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4860 memcpy (contents
+ roff
- 3,
4861 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4863 bfd_put_32 (output_bfd
,
4864 elf_x86_64_tpoff (info
, relocation
),
4865 contents
+ roff
+ 8 + largepic
);
4866 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4871 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
4873 /* GDesc -> LE transition.
4874 It's originally something like:
4875 leaq x@tlsdesc(%rip), %rax
4878 movl $x@tpoff, %rax. */
4880 unsigned int val
, type
;
4882 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4883 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4884 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
4885 contents
+ roff
- 3);
4886 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
4887 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
4888 contents
+ roff
- 1);
4889 bfd_put_32 (output_bfd
,
4890 elf_x86_64_tpoff (info
, relocation
),
4894 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
4896 /* GDesc -> LE transition.
4901 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4902 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4905 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
4907 /* IE->LE transition:
4908 For 64bit, originally it can be one of:
4909 movq foo@gottpoff(%rip), %reg
4910 addq foo@gottpoff(%rip), %reg
4913 leaq foo(%reg), %reg
4915 For 32bit, originally it can be one of:
4916 movq foo@gottpoff(%rip), %reg
4917 addl foo@gottpoff(%rip), %reg
4920 leal foo(%reg), %reg
4923 unsigned int val
, type
, reg
;
4926 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4929 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
4930 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4936 bfd_put_8 (output_bfd
, 0x49,
4937 contents
+ roff
- 3);
4938 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4939 bfd_put_8 (output_bfd
, 0x41,
4940 contents
+ roff
- 3);
4941 bfd_put_8 (output_bfd
, 0xc7,
4942 contents
+ roff
- 2);
4943 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4944 contents
+ roff
- 1);
4948 /* addq/addl -> addq/addl - addressing with %rsp/%r12
4951 bfd_put_8 (output_bfd
, 0x49,
4952 contents
+ roff
- 3);
4953 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4954 bfd_put_8 (output_bfd
, 0x41,
4955 contents
+ roff
- 3);
4956 bfd_put_8 (output_bfd
, 0x81,
4957 contents
+ roff
- 2);
4958 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4959 contents
+ roff
- 1);
4963 /* addq/addl -> leaq/leal */
4965 bfd_put_8 (output_bfd
, 0x4d,
4966 contents
+ roff
- 3);
4967 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4968 bfd_put_8 (output_bfd
, 0x45,
4969 contents
+ roff
- 3);
4970 bfd_put_8 (output_bfd
, 0x8d,
4971 contents
+ roff
- 2);
4972 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
4973 contents
+ roff
- 1);
4975 bfd_put_32 (output_bfd
,
4976 elf_x86_64_tpoff (info
, relocation
),
4984 if (htab
->elf
.sgot
== NULL
)
4989 off
= h
->got
.offset
;
4990 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
4994 if (local_got_offsets
== NULL
)
4997 off
= local_got_offsets
[r_symndx
];
4998 offplt
= local_tlsdesc_gotents
[r_symndx
];
5005 Elf_Internal_Rela outrel
;
5009 if (htab
->elf
.srelgot
== NULL
)
5012 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
5014 if (GOT_TLS_GDESC_P (tls_type
))
5016 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
5017 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
5018 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
5019 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5020 + htab
->elf
.sgotplt
->output_offset
5022 + htab
->sgotplt_jump_table_size
);
5023 sreloc
= htab
->elf
.srelplt
;
5025 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5027 outrel
.r_addend
= 0;
5028 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5031 sreloc
= htab
->elf
.srelgot
;
5033 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5034 + htab
->elf
.sgot
->output_offset
+ off
);
5036 if (GOT_TLS_GD_P (tls_type
))
5037 dr_type
= R_X86_64_DTPMOD64
;
5038 else if (GOT_TLS_GDESC_P (tls_type
))
5041 dr_type
= R_X86_64_TPOFF64
;
5043 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
5044 outrel
.r_addend
= 0;
5045 if ((dr_type
== R_X86_64_TPOFF64
5046 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
5047 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5048 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
5050 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5052 if (GOT_TLS_GD_P (tls_type
))
5056 BFD_ASSERT (! unresolved_reloc
);
5057 bfd_put_64 (output_bfd
,
5058 relocation
- elf_x86_64_dtpoff_base (info
),
5059 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5063 bfd_put_64 (output_bfd
, 0,
5064 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5065 outrel
.r_info
= htab
->r_info (indx
,
5067 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
5068 elf_append_rela (output_bfd
, sreloc
,
5077 local_got_offsets
[r_symndx
] |= 1;
5080 if (off
>= (bfd_vma
) -2
5081 && ! GOT_TLS_GDESC_P (tls_type
))
5083 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
5085 if (r_type
== R_X86_64_GOTPC32_TLSDESC
5086 || r_type
== R_X86_64_TLSDESC_CALL
)
5087 relocation
= htab
->elf
.sgotplt
->output_section
->vma
5088 + htab
->elf
.sgotplt
->output_offset
5089 + offplt
+ htab
->sgotplt_jump_table_size
;
5091 relocation
= htab
->elf
.sgot
->output_section
->vma
5092 + htab
->elf
.sgot
->output_offset
+ off
;
5093 unresolved_reloc
= FALSE
;
5097 bfd_vma roff
= rel
->r_offset
;
5099 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5101 /* GD->IE transition. For 64bit, change
5102 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5103 .word 0x6666; rex64; call __tls_get_addr@plt
5106 addq foo@gottpoff(%rip), %rax
5108 leaq foo@tlsgd(%rip), %rdi
5109 .word 0x6666; rex64; call __tls_get_addr@plt
5112 addq foo@gottpoff(%rip), %rax
5113 For largepic, change:
5114 leaq foo@tlsgd(%rip), %rdi
5115 movabsq $__tls_get_addr@pltoff, %rax
5120 addq foo@gottpoff(%rax), %rax
5121 nopw 0x0(%rax,%rax,1) */
5123 if (ABI_64_P (output_bfd
)
5124 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
5126 memcpy (contents
+ roff
- 3,
5127 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
5128 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5131 else if (ABI_64_P (output_bfd
))
5132 memcpy (contents
+ roff
- 4,
5133 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5136 memcpy (contents
+ roff
- 3,
5137 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5140 relocation
= (htab
->elf
.sgot
->output_section
->vma
5141 + htab
->elf
.sgot
->output_offset
+ off
5144 - input_section
->output_section
->vma
5145 - input_section
->output_offset
5147 bfd_put_32 (output_bfd
, relocation
,
5148 contents
+ roff
+ 8 + largepic
);
5149 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5154 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5156 /* GDesc -> IE transition.
5157 It's originally something like:
5158 leaq x@tlsdesc(%rip), %rax
5161 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
5163 /* Now modify the instruction as appropriate. To
5164 turn a leaq into a movq in the form we use it, it
5165 suffices to change the second byte from 0x8d to
5167 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
5169 bfd_put_32 (output_bfd
,
5170 htab
->elf
.sgot
->output_section
->vma
5171 + htab
->elf
.sgot
->output_offset
+ off
5173 - input_section
->output_section
->vma
5174 - input_section
->output_offset
5179 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5181 /* GDesc -> IE transition.
5188 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5189 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5197 case R_X86_64_TLSLD
:
5198 if (! elf_x86_64_tls_transition (info
, input_bfd
,
5199 input_section
, contents
,
5200 symtab_hdr
, sym_hashes
,
5201 &r_type
, GOT_UNKNOWN
,
5202 rel
, relend
, h
, r_symndx
))
5205 if (r_type
!= R_X86_64_TLSLD
)
5207 /* LD->LE transition:
5208 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
5209 For 64bit, we change it into:
5210 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
5211 For 32bit, we change it into:
5212 nopl 0x0(%rax); movl %fs:0, %eax.
5213 For largepic, change:
5214 leaq foo@tlsgd(%rip), %rdi
5215 movabsq $__tls_get_addr@pltoff, %rax
5219 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
5222 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
5223 if (ABI_64_P (output_bfd
)
5224 && contents
[rel
->r_offset
+ 5] == (bfd_byte
) '\xb8')
5225 memcpy (contents
+ rel
->r_offset
- 3,
5226 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
5227 "\x64\x48\x8b\x04\x25\0\0\0", 22);
5228 else if (ABI_64_P (output_bfd
))
5229 memcpy (contents
+ rel
->r_offset
- 3,
5230 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
5232 memcpy (contents
+ rel
->r_offset
- 3,
5233 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
5234 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5240 if (htab
->elf
.sgot
== NULL
)
5243 off
= htab
->tls_ld_got
.offset
;
5248 Elf_Internal_Rela outrel
;
5250 if (htab
->elf
.srelgot
== NULL
)
5253 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5254 + htab
->elf
.sgot
->output_offset
+ off
);
5256 bfd_put_64 (output_bfd
, 0,
5257 htab
->elf
.sgot
->contents
+ off
);
5258 bfd_put_64 (output_bfd
, 0,
5259 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5260 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
5261 outrel
.r_addend
= 0;
5262 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
5264 htab
->tls_ld_got
.offset
|= 1;
5266 relocation
= htab
->elf
.sgot
->output_section
->vma
5267 + htab
->elf
.sgot
->output_offset
+ off
;
5268 unresolved_reloc
= FALSE
;
5271 case R_X86_64_DTPOFF32
:
5272 if (!bfd_link_executable (info
)
5273 || (input_section
->flags
& SEC_CODE
) == 0)
5274 relocation
-= elf_x86_64_dtpoff_base (info
);
5276 relocation
= elf_x86_64_tpoff (info
, relocation
);
5279 case R_X86_64_TPOFF32
:
5280 case R_X86_64_TPOFF64
:
5281 BFD_ASSERT (bfd_link_executable (info
));
5282 relocation
= elf_x86_64_tpoff (info
, relocation
);
5285 case R_X86_64_DTPOFF64
:
5286 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
5287 relocation
-= elf_x86_64_dtpoff_base (info
);
5294 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5295 because such sections are not SEC_ALLOC and thus ld.so will
5296 not process them. */
5297 if (unresolved_reloc
5298 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
5300 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5301 rel
->r_offset
) != (bfd_vma
) -1)
5303 (*_bfd_error_handler
)
5304 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5307 (long) rel
->r_offset
,
5309 h
->root
.root
.string
);
5314 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5315 contents
, rel
->r_offset
,
5316 relocation
, rel
->r_addend
);
5318 check_relocation_error
:
5319 if (r
!= bfd_reloc_ok
)
5324 name
= h
->root
.root
.string
;
5327 name
= bfd_elf_string_from_elf_section (input_bfd
,
5328 symtab_hdr
->sh_link
,
5333 name
= bfd_section_name (input_bfd
, sec
);
5336 if (r
== bfd_reloc_overflow
)
5338 if (! ((*info
->callbacks
->reloc_overflow
)
5339 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5340 (bfd_vma
) 0, input_bfd
, input_section
,
5346 (*_bfd_error_handler
)
5347 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5348 input_bfd
, input_section
,
5349 (long) rel
->r_offset
, name
, (int) r
);
5360 Elf_Internal_Shdr
*rel_hdr
;
5361 size_t deleted
= rel
- wrel
;
5363 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
5364 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5365 if (rel_hdr
->sh_size
== 0)
5367 /* It is too late to remove an empty reloc section. Leave
5369 ??? What is wrong with an empty section??? */
5370 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
5373 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5374 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5375 input_section
->reloc_count
-= deleted
;
5381 /* Finish up dynamic symbol handling. We set the contents of various
5382 dynamic sections here. */
5385 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
5386 struct bfd_link_info
*info
,
5387 struct elf_link_hash_entry
*h
,
5388 Elf_Internal_Sym
*sym
)
5390 struct elf_x86_64_link_hash_table
*htab
;
5391 const struct elf_x86_64_backend_data
*abed
;
5392 bfd_boolean use_plt_bnd
;
5393 struct elf_x86_64_link_hash_entry
*eh
;
5394 bfd_boolean local_undefweak
;
5396 htab
= elf_x86_64_hash_table (info
);
5400 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5401 section only if there is .plt section. */
5402 use_plt_bnd
= htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
;
5404 ? &elf_x86_64_bnd_arch_bed
5405 : get_elf_x86_64_backend_data (output_bfd
));
5407 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
5409 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5410 resolved undefined weak symbols in executable so that their
5411 references have value 0 at run-time. */
5412 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
5416 if (h
->plt
.offset
!= (bfd_vma
) -1)
5419 bfd_vma got_offset
, plt_offset
, plt_plt_offset
, plt_got_offset
;
5420 bfd_vma plt_plt_insn_end
, plt_got_insn_size
;
5421 Elf_Internal_Rela rela
;
5423 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
5424 const struct elf_backend_data
*bed
;
5425 bfd_vma plt_got_pcrel_offset
;
5427 /* When building a static executable, use .iplt, .igot.plt and
5428 .rela.iplt sections for STT_GNU_IFUNC symbols. */
5429 if (htab
->elf
.splt
!= NULL
)
5431 plt
= htab
->elf
.splt
;
5432 gotplt
= htab
->elf
.sgotplt
;
5433 relplt
= htab
->elf
.srelplt
;
5437 plt
= htab
->elf
.iplt
;
5438 gotplt
= htab
->elf
.igotplt
;
5439 relplt
= htab
->elf
.irelplt
;
5442 /* This symbol has an entry in the procedure linkage table. Set
5444 if ((h
->dynindx
== -1
5446 && !((h
->forced_local
|| bfd_link_executable (info
))
5448 && h
->type
== STT_GNU_IFUNC
))
5454 /* Get the index in the procedure linkage table which
5455 corresponds to this symbol. This is the index of this symbol
5456 in all the symbols for which we are making plt entries. The
5457 first entry in the procedure linkage table is reserved.
5459 Get the offset into the .got table of the entry that
5460 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
5461 bytes. The first three are reserved for the dynamic linker.
5463 For static executables, we don't reserve anything. */
5465 if (plt
== htab
->elf
.splt
)
5467 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
5468 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
5472 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
5473 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
5476 plt_plt_insn_end
= abed
->plt_plt_insn_end
;
5477 plt_plt_offset
= abed
->plt_plt_offset
;
5478 plt_got_insn_size
= abed
->plt_got_insn_size
;
5479 plt_got_offset
= abed
->plt_got_offset
;
5482 /* Use the second PLT with BND relocations. */
5483 const bfd_byte
*plt_entry
, *plt2_entry
;
5485 if (eh
->has_bnd_reloc
)
5487 plt_entry
= elf_x86_64_bnd_plt_entry
;
5488 plt2_entry
= elf_x86_64_bnd_plt2_entry
;
5492 plt_entry
= elf_x86_64_legacy_plt_entry
;
5493 plt2_entry
= elf_x86_64_legacy_plt2_entry
;
5495 /* Subtract 1 since there is no BND prefix. */
5496 plt_plt_insn_end
-= 1;
5497 plt_plt_offset
-= 1;
5498 plt_got_insn_size
-= 1;
5499 plt_got_offset
-= 1;
5502 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry
)
5503 == sizeof (elf_x86_64_legacy_plt_entry
));
5505 /* Fill in the entry in the procedure linkage table. */
5506 memcpy (plt
->contents
+ h
->plt
.offset
,
5507 plt_entry
, sizeof (elf_x86_64_legacy_plt_entry
));
5508 /* Fill in the entry in the second PLT. */
5509 memcpy (htab
->plt_bnd
->contents
+ eh
->plt_bnd
.offset
,
5510 plt2_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5512 resolved_plt
= htab
->plt_bnd
;
5513 plt_offset
= eh
->plt_bnd
.offset
;
5517 /* Fill in the entry in the procedure linkage table. */
5518 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
5519 abed
->plt_entry_size
);
5522 plt_offset
= h
->plt
.offset
;
5525 /* Insert the relocation positions of the plt section. */
5527 /* Put offset the PC-relative instruction referring to the GOT entry,
5528 subtracting the size of that instruction. */
5529 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
5530 + gotplt
->output_offset
5532 - resolved_plt
->output_section
->vma
5533 - resolved_plt
->output_offset
5535 - plt_got_insn_size
);
5537 /* Check PC-relative offset overflow in PLT entry. */
5538 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
5539 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5540 output_bfd
, h
->root
.root
.string
);
5542 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
5543 resolved_plt
->contents
+ plt_offset
+ plt_got_offset
);
5545 /* Fill in the entry in the global offset table, initially this
5546 points to the second part of the PLT entry. Leave the entry
5547 as zero for undefined weak symbol in PIE. No PLT relocation
5548 against undefined weak symbol in PIE. */
5549 if (!local_undefweak
)
5551 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5552 + plt
->output_offset
5554 + abed
->plt_lazy_offset
),
5555 gotplt
->contents
+ got_offset
);
5557 /* Fill in the entry in the .rela.plt section. */
5558 rela
.r_offset
= (gotplt
->output_section
->vma
5559 + gotplt
->output_offset
5561 if (h
->dynindx
== -1
5562 || ((bfd_link_executable (info
)
5563 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5565 && h
->type
== STT_GNU_IFUNC
))
5567 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5568 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
5569 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
5570 rela
.r_addend
= (h
->root
.u
.def
.value
5571 + h
->root
.u
.def
.section
->output_section
->vma
5572 + h
->root
.u
.def
.section
->output_offset
);
5573 /* R_X86_64_IRELATIVE comes last. */
5574 plt_index
= htab
->next_irelative_index
--;
5578 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
5580 plt_index
= htab
->next_jump_slot_index
++;
5583 /* Don't fill PLT entry for static executables. */
5584 if (plt
== htab
->elf
.splt
)
5586 bfd_vma plt0_offset
= h
->plt
.offset
+ plt_plt_insn_end
;
5588 /* Put relocation index. */
5589 bfd_put_32 (output_bfd
, plt_index
,
5590 (plt
->contents
+ h
->plt
.offset
5591 + abed
->plt_reloc_offset
));
5593 /* Put offset for jmp .PLT0 and check for overflow. We don't
5594 check relocation index for overflow since branch displacement
5595 will overflow first. */
5596 if (plt0_offset
> 0x80000000)
5597 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5598 output_bfd
, h
->root
.root
.string
);
5599 bfd_put_32 (output_bfd
, - plt0_offset
,
5600 plt
->contents
+ h
->plt
.offset
+ plt_plt_offset
);
5603 bed
= get_elf_backend_data (output_bfd
);
5604 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
5605 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
5608 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5610 bfd_vma got_offset
, plt_offset
, plt_got_offset
, plt_got_insn_size
;
5611 asection
*plt
, *got
;
5612 bfd_boolean got_after_plt
;
5613 int32_t got_pcrel_offset
;
5614 const bfd_byte
*got_plt_entry
;
5616 /* Set the entry in the GOT procedure linkage table. */
5617 plt
= htab
->plt_got
;
5618 got
= htab
->elf
.sgot
;
5619 got_offset
= h
->got
.offset
;
5621 if (got_offset
== (bfd_vma
) -1
5622 || h
->type
== STT_GNU_IFUNC
5627 /* Use the second PLT entry template for the GOT PLT since they
5628 are the identical. */
5629 plt_got_insn_size
= elf_x86_64_bnd_arch_bed
.plt_got_insn_size
;
5630 plt_got_offset
= elf_x86_64_bnd_arch_bed
.plt_got_offset
;
5631 if (eh
->has_bnd_reloc
)
5632 got_plt_entry
= elf_x86_64_bnd_plt2_entry
;
5635 got_plt_entry
= elf_x86_64_legacy_plt2_entry
;
5637 /* Subtract 1 since there is no BND prefix. */
5638 plt_got_insn_size
-= 1;
5639 plt_got_offset
-= 1;
5642 /* Fill in the entry in the GOT procedure linkage table. */
5643 plt_offset
= eh
->plt_got
.offset
;
5644 memcpy (plt
->contents
+ plt_offset
,
5645 got_plt_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5647 /* Put offset the PC-relative instruction referring to the GOT
5648 entry, subtracting the size of that instruction. */
5649 got_pcrel_offset
= (got
->output_section
->vma
5650 + got
->output_offset
5652 - plt
->output_section
->vma
5653 - plt
->output_offset
5655 - plt_got_insn_size
);
5657 /* Check PC-relative offset overflow in GOT PLT entry. */
5658 got_after_plt
= got
->output_section
->vma
> plt
->output_section
->vma
;
5659 if ((got_after_plt
&& got_pcrel_offset
< 0)
5660 || (!got_after_plt
&& got_pcrel_offset
> 0))
5661 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
5662 output_bfd
, h
->root
.root
.string
);
5664 bfd_put_32 (output_bfd
, got_pcrel_offset
,
5665 plt
->contents
+ plt_offset
+ plt_got_offset
);
5668 if (!local_undefweak
5670 && (h
->plt
.offset
!= (bfd_vma
) -1
5671 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5673 /* Mark the symbol as undefined, rather than as defined in
5674 the .plt section. Leave the value if there were any
5675 relocations where pointer equality matters (this is a clue
5676 for the dynamic linker, to make function pointer
5677 comparisons work between an application and shared
5678 library), otherwise set it to zero. If a function is only
5679 called from a binary, there is no need to slow down
5680 shared libraries because of that. */
5681 sym
->st_shndx
= SHN_UNDEF
;
5682 if (!h
->pointer_equality_needed
)
5686 /* Don't generate dynamic GOT relocation against undefined weak
5687 symbol in executable. */
5688 if (h
->got
.offset
!= (bfd_vma
) -1
5689 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
5690 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
5691 && !local_undefweak
)
5693 Elf_Internal_Rela rela
;
5695 /* This symbol has an entry in the global offset table. Set it
5697 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5700 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5701 + htab
->elf
.sgot
->output_offset
5702 + (h
->got
.offset
&~ (bfd_vma
) 1));
5704 /* If this is a static link, or it is a -Bsymbolic link and the
5705 symbol is defined locally or was forced to be local because
5706 of a version file, we just want to emit a RELATIVE reloc.
5707 The entry in the global offset table will already have been
5708 initialized in the relocate_section function. */
5710 && h
->type
== STT_GNU_IFUNC
)
5712 if (bfd_link_pic (info
))
5714 /* Generate R_X86_64_GLOB_DAT. */
5721 if (!h
->pointer_equality_needed
)
5724 /* For non-shared object, we can't use .got.plt, which
5725 contains the real function addres if we need pointer
5726 equality. We load the GOT entry with the PLT entry. */
5727 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5728 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5729 + plt
->output_offset
5731 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5735 else if (bfd_link_pic (info
)
5736 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5738 if (!h
->def_regular
)
5740 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5741 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
5742 rela
.r_addend
= (h
->root
.u
.def
.value
5743 + h
->root
.u
.def
.section
->output_section
->vma
5744 + h
->root
.u
.def
.section
->output_offset
);
5748 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5750 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5751 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5752 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
5756 elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &rela
);
5761 Elf_Internal_Rela rela
;
5763 /* This symbol needs a copy reloc. Set it up. */
5765 if (h
->dynindx
== -1
5766 || (h
->root
.type
!= bfd_link_hash_defined
5767 && h
->root
.type
!= bfd_link_hash_defweak
)
5768 || htab
->srelbss
== NULL
)
5771 rela
.r_offset
= (h
->root
.u
.def
.value
5772 + h
->root
.u
.def
.section
->output_section
->vma
5773 + h
->root
.u
.def
.section
->output_offset
);
5774 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
5776 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
5782 /* Finish up local dynamic symbol handling. We set the contents of
5783 various dynamic sections here. */
5786 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
5788 struct elf_link_hash_entry
*h
5789 = (struct elf_link_hash_entry
*) *slot
;
5790 struct bfd_link_info
*info
5791 = (struct bfd_link_info
*) inf
;
5793 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5797 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5798 here since undefined weak symbol may not be dynamic and may not be
5799 called for elf_x86_64_finish_dynamic_symbol. */
5802 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
5805 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
5806 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5808 if (h
->root
.type
!= bfd_link_hash_undefweak
5809 || h
->dynindx
!= -1)
5812 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5816 /* Used to decide how to sort relocs in an optimal manner for the
5817 dynamic linker, before writing them out. */
5819 static enum elf_reloc_type_class
5820 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info
,
5821 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5822 const Elf_Internal_Rela
*rela
)
5824 bfd
*abfd
= info
->output_bfd
;
5825 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5826 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
5828 if (htab
->elf
.dynsym
!= NULL
5829 && htab
->elf
.dynsym
->contents
!= NULL
)
5831 /* Check relocation against STT_GNU_IFUNC symbol if there are
5833 unsigned long r_symndx
= htab
->r_sym (rela
->r_info
);
5834 Elf_Internal_Sym sym
;
5835 if (!bed
->s
->swap_symbol_in (abfd
,
5836 (htab
->elf
.dynsym
->contents
5837 + r_symndx
* bed
->s
->sizeof_sym
),
5841 if (ELF_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
5842 return reloc_class_ifunc
;
5845 switch ((int) ELF32_R_TYPE (rela
->r_info
))
5847 case R_X86_64_RELATIVE
:
5848 case R_X86_64_RELATIVE64
:
5849 return reloc_class_relative
;
5850 case R_X86_64_JUMP_SLOT
:
5851 return reloc_class_plt
;
5853 return reloc_class_copy
;
5855 return reloc_class_normal
;
5859 /* Finish up the dynamic sections. */
5862 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
5863 struct bfd_link_info
*info
)
5865 struct elf_x86_64_link_hash_table
*htab
;
5868 const struct elf_x86_64_backend_data
*abed
;
5870 htab
= elf_x86_64_hash_table (info
);
5874 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5875 section only if there is .plt section. */
5876 abed
= (htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
5877 ? &elf_x86_64_bnd_arch_bed
5878 : get_elf_x86_64_backend_data (output_bfd
));
5880 dynobj
= htab
->elf
.dynobj
;
5881 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
5883 if (htab
->elf
.dynamic_sections_created
)
5885 bfd_byte
*dyncon
, *dynconend
;
5886 const struct elf_backend_data
*bed
;
5887 bfd_size_type sizeof_dyn
;
5889 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
5892 bed
= get_elf_backend_data (dynobj
);
5893 sizeof_dyn
= bed
->s
->sizeof_dyn
;
5894 dyncon
= sdyn
->contents
;
5895 dynconend
= sdyn
->contents
+ sdyn
->size
;
5896 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
5898 Elf_Internal_Dyn dyn
;
5901 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
5909 s
= htab
->elf
.sgotplt
;
5910 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5914 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
5918 s
= htab
->elf
.srelplt
->output_section
;
5919 dyn
.d_un
.d_val
= s
->size
;
5923 /* The procedure linkage table relocs (DT_JMPREL) should
5924 not be included in the overall relocs (DT_RELA).
5925 Therefore, we override the DT_RELASZ entry here to
5926 make it not include the JMPREL relocs. Since the
5927 linker script arranges for .rela.plt to follow all
5928 other relocation sections, we don't have to worry
5929 about changing the DT_RELA entry. */
5930 if (htab
->elf
.srelplt
!= NULL
)
5932 s
= htab
->elf
.srelplt
->output_section
;
5933 dyn
.d_un
.d_val
-= s
->size
;
5937 case DT_TLSDESC_PLT
:
5939 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5940 + htab
->tlsdesc_plt
;
5943 case DT_TLSDESC_GOT
:
5945 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5946 + htab
->tlsdesc_got
;
5950 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
5953 /* Fill in the special first entry in the procedure linkage table. */
5954 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
5956 /* Fill in the first entry in the procedure linkage table. */
5957 memcpy (htab
->elf
.splt
->contents
,
5958 abed
->plt0_entry
, abed
->plt_entry_size
);
5959 /* Add offset for pushq GOT+8(%rip), since the instruction
5960 uses 6 bytes subtract this value. */
5961 bfd_put_32 (output_bfd
,
5962 (htab
->elf
.sgotplt
->output_section
->vma
5963 + htab
->elf
.sgotplt
->output_offset
5965 - htab
->elf
.splt
->output_section
->vma
5966 - htab
->elf
.splt
->output_offset
5968 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
5969 /* Add offset for the PC-relative instruction accessing GOT+16,
5970 subtracting the offset to the end of that instruction. */
5971 bfd_put_32 (output_bfd
,
5972 (htab
->elf
.sgotplt
->output_section
->vma
5973 + htab
->elf
.sgotplt
->output_offset
5975 - htab
->elf
.splt
->output_section
->vma
5976 - htab
->elf
.splt
->output_offset
5977 - abed
->plt0_got2_insn_end
),
5978 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
5980 elf_section_data (htab
->elf
.splt
->output_section
)
5981 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
5983 if (htab
->tlsdesc_plt
)
5985 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5986 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
5988 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
5989 abed
->plt0_entry
, abed
->plt_entry_size
);
5991 /* Add offset for pushq GOT+8(%rip), since the
5992 instruction uses 6 bytes subtract this value. */
5993 bfd_put_32 (output_bfd
,
5994 (htab
->elf
.sgotplt
->output_section
->vma
5995 + htab
->elf
.sgotplt
->output_offset
5997 - htab
->elf
.splt
->output_section
->vma
5998 - htab
->elf
.splt
->output_offset
6001 htab
->elf
.splt
->contents
6002 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
6003 /* Add offset for the PC-relative instruction accessing GOT+TDG,
6004 where TGD stands for htab->tlsdesc_got, subtracting the offset
6005 to the end of that instruction. */
6006 bfd_put_32 (output_bfd
,
6007 (htab
->elf
.sgot
->output_section
->vma
6008 + htab
->elf
.sgot
->output_offset
6010 - htab
->elf
.splt
->output_section
->vma
6011 - htab
->elf
.splt
->output_offset
6013 - abed
->plt0_got2_insn_end
),
6014 htab
->elf
.splt
->contents
6015 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
6020 if (htab
->plt_bnd
!= NULL
)
6021 elf_section_data (htab
->plt_bnd
->output_section
)
6022 ->this_hdr
.sh_entsize
= sizeof (elf_x86_64_bnd_plt2_entry
);
6024 if (htab
->elf
.sgotplt
)
6026 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
6028 (*_bfd_error_handler
)
6029 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
6033 /* Fill in the first three entries in the global offset table. */
6034 if (htab
->elf
.sgotplt
->size
> 0)
6036 /* Set the first entry in the global offset table to the address of
6037 the dynamic section. */
6039 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
6041 bfd_put_64 (output_bfd
,
6042 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
6043 htab
->elf
.sgotplt
->contents
);
6044 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
6045 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
6046 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
6049 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
6053 /* Adjust .eh_frame for .plt section. */
6054 if (htab
->plt_eh_frame
!= NULL
6055 && htab
->plt_eh_frame
->contents
!= NULL
)
6057 if (htab
->elf
.splt
!= NULL
6058 && htab
->elf
.splt
->size
!= 0
6059 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
6060 && htab
->elf
.splt
->output_section
!= NULL
6061 && htab
->plt_eh_frame
->output_section
!= NULL
)
6063 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
6064 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
6065 + htab
->plt_eh_frame
->output_offset
6066 + PLT_FDE_START_OFFSET
;
6067 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6068 htab
->plt_eh_frame
->contents
6069 + PLT_FDE_START_OFFSET
);
6071 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
6073 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6075 htab
->plt_eh_frame
->contents
))
6080 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
6081 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
6084 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
6085 htab_traverse (htab
->loc_hash_table
,
6086 elf_x86_64_finish_local_dynamic_symbol
,
6089 /* Fill PLT entries for undefined weak symbols in PIE. */
6090 if (bfd_link_pie (info
))
6091 bfd_hash_traverse (&info
->hash
->table
,
6092 elf_x86_64_pie_finish_undefweak_symbol
,
6098 /* Return an array of PLT entry symbol values. */
6101 elf_x86_64_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
6104 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
6107 bfd_vma
*plt_sym_val
;
6109 bfd_byte
*plt_contents
;
6110 const struct elf_x86_64_backend_data
*bed
;
6111 Elf_Internal_Shdr
*hdr
;
6114 /* Get the .plt section contents. PLT passed down may point to the
6115 .plt.bnd section. Make sure that PLT always points to the .plt
6117 plt_bnd
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6122 plt
= bfd_get_section_by_name (abfd
, ".plt");
6125 bed
= &elf_x86_64_bnd_arch_bed
;
6128 bed
= get_elf_x86_64_backend_data (abfd
);
6130 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
6131 if (plt_contents
== NULL
)
6133 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
6134 plt_contents
, 0, plt
->size
))
6137 free (plt_contents
);
6141 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
6142 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
6145 hdr
= &elf_section_data (relplt
)->this_hdr
;
6146 count
= relplt
->size
/ hdr
->sh_entsize
;
6148 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
6149 if (plt_sym_val
== NULL
)
6152 for (i
= 0; i
< count
; i
++)
6153 plt_sym_val
[i
] = -1;
6155 plt_offset
= bed
->plt_entry_size
;
6156 p
= relplt
->relocation
;
6157 for (i
= 0; i
< count
; i
++, p
++)
6161 /* Skip unknown relocation. */
6162 if (p
->howto
== NULL
)
6165 if (p
->howto
->type
!= R_X86_64_JUMP_SLOT
6166 && p
->howto
->type
!= R_X86_64_IRELATIVE
)
6169 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
6170 + bed
->plt_reloc_offset
));
6171 if (reloc_index
< count
)
6175 /* This is the index in .plt section. */
6176 long plt_index
= plt_offset
/ bed
->plt_entry_size
;
6177 /* Store VMA + the offset in .plt.bnd section. */
6178 plt_sym_val
[reloc_index
] =
6180 + (plt_index
- 1) * sizeof (elf_x86_64_legacy_plt2_entry
));
6183 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
6185 plt_offset
+= bed
->plt_entry_size
;
6187 /* PR binutils/18437: Skip extra relocations in the .rela.plt
6189 if (plt_offset
>= plt
->size
)
6193 free (plt_contents
);
6198 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
6202 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
6209 /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
6210 as PLT if it exists. */
6211 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6213 plt
= bfd_get_section_by_name (abfd
, ".plt");
6214 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
6215 dynsymcount
, dynsyms
, ret
,
6217 elf_x86_64_get_plt_sym_val
);
6220 /* Handle an x86-64 specific section when reading an object file. This
6221 is called when elfcode.h finds a section with an unknown type. */
6224 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
6225 const char *name
, int shindex
)
6227 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
6230 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
6236 /* Hook called by the linker routine which adds symbols from an object
6237 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
6241 elf_x86_64_add_symbol_hook (bfd
*abfd
,
6242 struct bfd_link_info
*info
,
6243 Elf_Internal_Sym
*sym
,
6244 const char **namep ATTRIBUTE_UNUSED
,
6245 flagword
*flagsp ATTRIBUTE_UNUSED
,
6251 switch (sym
->st_shndx
)
6253 case SHN_X86_64_LCOMMON
:
6254 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
6257 lcomm
= bfd_make_section_with_flags (abfd
,
6261 | SEC_LINKER_CREATED
));
6264 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
6267 *valp
= sym
->st_size
;
6271 if (ELF_ST_BIND (sym
->st_info
) == STB_GNU_UNIQUE
6272 && (abfd
->flags
& DYNAMIC
) == 0
6273 && bfd_get_flavour (info
->output_bfd
) == bfd_target_elf_flavour
)
6274 elf_tdata (info
->output_bfd
)->has_gnu_symbols
6275 |= elf_gnu_symbol_unique
;
6281 /* Given a BFD section, try to locate the corresponding ELF section
6285 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
6286 asection
*sec
, int *index_return
)
6288 if (sec
== &_bfd_elf_large_com_section
)
6290 *index_return
= SHN_X86_64_LCOMMON
;
6296 /* Process a symbol. */
6299 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
6302 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
6304 switch (elfsym
->internal_elf_sym
.st_shndx
)
6306 case SHN_X86_64_LCOMMON
:
6307 asym
->section
= &_bfd_elf_large_com_section
;
6308 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
6309 /* Common symbol doesn't set BSF_GLOBAL. */
6310 asym
->flags
&= ~BSF_GLOBAL
;
6316 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
6318 return (sym
->st_shndx
== SHN_COMMON
6319 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
6323 elf_x86_64_common_section_index (asection
*sec
)
6325 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6328 return SHN_X86_64_LCOMMON
;
6332 elf_x86_64_common_section (asection
*sec
)
6334 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6335 return bfd_com_section_ptr
;
6337 return &_bfd_elf_large_com_section
;
6341 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
6342 const Elf_Internal_Sym
*sym
,
6347 const asection
*oldsec
)
6349 /* A normal common symbol and a large common symbol result in a
6350 normal common symbol. We turn the large common symbol into a
6353 && h
->root
.type
== bfd_link_hash_common
6355 && bfd_is_com_section (*psec
)
6358 if (sym
->st_shndx
== SHN_COMMON
6359 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
6361 h
->root
.u
.c
.p
->section
6362 = bfd_make_section_old_way (oldbfd
, "COMMON");
6363 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
6365 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
6366 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
6367 *psec
= bfd_com_section_ptr
;
6374 elf_x86_64_additional_program_headers (bfd
*abfd
,
6375 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6380 /* Check to see if we need a large readonly segment. */
6381 s
= bfd_get_section_by_name (abfd
, ".lrodata");
6382 if (s
&& (s
->flags
& SEC_LOAD
))
6385 /* Check to see if we need a large data segment. Since .lbss sections
6386 is placed right after the .bss section, there should be no need for
6387 a large data segment just because of .lbss. */
6388 s
= bfd_get_section_by_name (abfd
, ".ldata");
6389 if (s
&& (s
->flags
& SEC_LOAD
))
6395 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6398 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
6400 if (h
->plt
.offset
!= (bfd_vma
) -1
6402 && !h
->pointer_equality_needed
)
6405 return _bfd_elf_hash_symbol (h
);
6408 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
6411 elf_x86_64_relocs_compatible (const bfd_target
*input
,
6412 const bfd_target
*output
)
6414 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
6415 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
6416 && _bfd_elf_relocs_compatible (input
, output
));
6419 static const struct bfd_elf_special_section
6420 elf_x86_64_special_sections
[]=
6422 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6423 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6424 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
6425 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6426 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6427 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6428 { NULL
, 0, 0, 0, 0 }
6431 #define TARGET_LITTLE_SYM x86_64_elf64_vec
6432 #define TARGET_LITTLE_NAME "elf64-x86-64"
6433 #define ELF_ARCH bfd_arch_i386
6434 #define ELF_TARGET_ID X86_64_ELF_DATA
6435 #define ELF_MACHINE_CODE EM_X86_64
6436 #define ELF_MAXPAGESIZE 0x200000
6437 #define ELF_MINPAGESIZE 0x1000
6438 #define ELF_COMMONPAGESIZE 0x1000
6440 #define elf_backend_can_gc_sections 1
6441 #define elf_backend_can_refcount 1
6442 #define elf_backend_want_got_plt 1
6443 #define elf_backend_plt_readonly 1
6444 #define elf_backend_want_plt_sym 0
6445 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
6446 #define elf_backend_rela_normal 1
6447 #define elf_backend_plt_alignment 4
6448 #define elf_backend_extern_protected_data 1
6450 #define elf_info_to_howto elf_x86_64_info_to_howto
6452 #define bfd_elf64_bfd_link_hash_table_create \
6453 elf_x86_64_link_hash_table_create
6454 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
6455 #define bfd_elf64_bfd_reloc_name_lookup \
6456 elf_x86_64_reloc_name_lookup
6458 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
6459 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
6460 #define elf_backend_check_relocs elf_x86_64_check_relocs
6461 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
6462 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
6463 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
6464 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
6465 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
6466 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
6467 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
6469 #define elf_backend_write_core_note elf_x86_64_write_core_note
6471 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
6472 #define elf_backend_relocate_section elf_x86_64_relocate_section
6473 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
6474 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
6475 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
6476 #define elf_backend_object_p elf64_x86_64_elf_object_p
6477 #define bfd_elf64_mkobject elf_x86_64_mkobject
6478 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
6480 #define elf_backend_section_from_shdr \
6481 elf_x86_64_section_from_shdr
6483 #define elf_backend_section_from_bfd_section \
6484 elf_x86_64_elf_section_from_bfd_section
6485 #define elf_backend_add_symbol_hook \
6486 elf_x86_64_add_symbol_hook
6487 #define elf_backend_symbol_processing \
6488 elf_x86_64_symbol_processing
6489 #define elf_backend_common_section_index \
6490 elf_x86_64_common_section_index
6491 #define elf_backend_common_section \
6492 elf_x86_64_common_section
6493 #define elf_backend_common_definition \
6494 elf_x86_64_common_definition
6495 #define elf_backend_merge_symbol \
6496 elf_x86_64_merge_symbol
6497 #define elf_backend_special_sections \
6498 elf_x86_64_special_sections
6499 #define elf_backend_additional_program_headers \
6500 elf_x86_64_additional_program_headers
6501 #define elf_backend_hash_symbol \
6502 elf_x86_64_hash_symbol
6503 #define elf_backend_omit_section_dynsym \
6504 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6505 #define elf_backend_fixup_symbol \
6506 elf_x86_64_fixup_symbol
6508 #include "elf64-target.h"
6510 /* CloudABI support. */
6512 #undef TARGET_LITTLE_SYM
6513 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
6514 #undef TARGET_LITTLE_NAME
6515 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
6518 #define ELF_OSABI ELFOSABI_CLOUDABI
6521 #define elf64_bed elf64_x86_64_cloudabi_bed
6523 #include "elf64-target.h"
6525 /* FreeBSD support. */
6527 #undef TARGET_LITTLE_SYM
6528 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
6529 #undef TARGET_LITTLE_NAME
6530 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
6533 #define ELF_OSABI ELFOSABI_FREEBSD
6536 #define elf64_bed elf64_x86_64_fbsd_bed
6538 #include "elf64-target.h"
6540 /* Solaris 2 support. */
6542 #undef TARGET_LITTLE_SYM
6543 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
6544 #undef TARGET_LITTLE_NAME
6545 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
6547 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6548 objects won't be recognized. */
6552 #define elf64_bed elf64_x86_64_sol2_bed
6554 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
6556 #undef elf_backend_static_tls_alignment
6557 #define elf_backend_static_tls_alignment 16
6559 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6561 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6563 #undef elf_backend_want_plt_sym
6564 #define elf_backend_want_plt_sym 1
6566 #undef elf_backend_strtab_flags
6567 #define elf_backend_strtab_flags SHF_STRINGS
6570 elf64_x86_64_copy_solaris_special_section_fields (const bfd
*ibfd ATTRIBUTE_UNUSED
,
6571 bfd
*obfd ATTRIBUTE_UNUSED
,
6572 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
6573 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
6575 /* PR 19938: FIXME: Need to add code for setting the sh_info
6576 and sh_link fields of Solaris specific section types. */
6580 #undef elf_backend_copy_special_section_fields
6581 #define elf_backend_copy_special_section_fields elf64_x86_64_copy_solaris_special_section_fields
6583 #include "elf64-target.h"
6585 /* Native Client support. */
6588 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
6590 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
6591 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
6595 #undef TARGET_LITTLE_SYM
6596 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
6597 #undef TARGET_LITTLE_NAME
6598 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
6600 #define elf64_bed elf64_x86_64_nacl_bed
6602 #undef ELF_MAXPAGESIZE
6603 #undef ELF_MINPAGESIZE
6604 #undef ELF_COMMONPAGESIZE
6605 #define ELF_MAXPAGESIZE 0x10000
6606 #define ELF_MINPAGESIZE 0x10000
6607 #define ELF_COMMONPAGESIZE 0x10000
6609 /* Restore defaults. */
6611 #undef elf_backend_static_tls_alignment
6612 #undef elf_backend_want_plt_sym
6613 #define elf_backend_want_plt_sym 0
6614 #undef elf_backend_strtab_flags
6615 #undef elf_backend_copy_special_section_fields
6617 /* NaCl uses substantially different PLT entries for the same effects. */
6619 #undef elf_backend_plt_alignment
6620 #define elf_backend_plt_alignment 5
6621 #define NACL_PLT_ENTRY_SIZE 64
6622 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6624 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
6626 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
6627 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
6628 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6629 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6630 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6632 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
6633 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
6635 /* 32 bytes of nop to pad out to the standard size. */
6636 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6637 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6638 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6639 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6640 0x66, /* excess data32 prefix */
6644 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6646 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
6647 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6648 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6649 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6651 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
6652 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6653 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6655 /* Lazy GOT entries point here (32-byte aligned). */
6656 0x68, /* pushq immediate */
6657 0, 0, 0, 0, /* replaced with index into relocation table. */
6658 0xe9, /* jmp relative */
6659 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
6661 /* 22 bytes of nop to pad out to the standard size. */
6662 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6663 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6664 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
6667 /* .eh_frame covering the .plt section. */
6669 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
6671 #if (PLT_CIE_LENGTH != 20 \
6672 || PLT_FDE_LENGTH != 36 \
6673 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6674 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6675 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
6677 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6678 0, 0, 0, 0, /* CIE ID */
6679 1, /* CIE version */
6680 'z', 'R', 0, /* Augmentation string */
6681 1, /* Code alignment factor */
6682 0x78, /* Data alignment factor */
6683 16, /* Return address column */
6684 1, /* Augmentation size */
6685 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6686 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
6687 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
6688 DW_CFA_nop
, DW_CFA_nop
,
6690 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6691 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
6692 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
6693 0, 0, 0, 0, /* .plt size goes here */
6694 0, /* Augmentation size */
6695 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
6696 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6697 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
6698 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6699 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6700 13, /* Block length */
6701 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
6702 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
6703 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6704 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
6705 DW_CFA_nop
, DW_CFA_nop
6708 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
6710 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
6711 elf_x86_64_nacl_plt_entry
, /* plt_entry */
6712 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6713 2, /* plt0_got1_offset */
6714 9, /* plt0_got2_offset */
6715 13, /* plt0_got2_insn_end */
6716 3, /* plt_got_offset */
6717 33, /* plt_reloc_offset */
6718 38, /* plt_plt_offset */
6719 7, /* plt_got_insn_size */
6720 42, /* plt_plt_insn_end */
6721 32, /* plt_lazy_offset */
6722 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
6723 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
6726 #undef elf_backend_arch_data
6727 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
6729 #undef elf_backend_object_p
6730 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
6731 #undef elf_backend_modify_segment_map
6732 #define elf_backend_modify_segment_map nacl_modify_segment_map
6733 #undef elf_backend_modify_program_headers
6734 #define elf_backend_modify_program_headers nacl_modify_program_headers
6735 #undef elf_backend_final_write_processing
6736 #define elf_backend_final_write_processing nacl_final_write_processing
6738 #include "elf64-target.h"
6740 /* Native Client x32 support. */
6743 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
6745 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
6746 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
6750 #undef TARGET_LITTLE_SYM
6751 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
6752 #undef TARGET_LITTLE_NAME
6753 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
6755 #define elf32_bed elf32_x86_64_nacl_bed
6757 #define bfd_elf32_bfd_link_hash_table_create \
6758 elf_x86_64_link_hash_table_create
6759 #define bfd_elf32_bfd_reloc_type_lookup \
6760 elf_x86_64_reloc_type_lookup
6761 #define bfd_elf32_bfd_reloc_name_lookup \
6762 elf_x86_64_reloc_name_lookup
6763 #define bfd_elf32_mkobject \
6765 #define bfd_elf32_get_synthetic_symtab \
6766 elf_x86_64_get_synthetic_symtab
6768 #undef elf_backend_object_p
6769 #define elf_backend_object_p \
6770 elf32_x86_64_nacl_elf_object_p
6772 #undef elf_backend_bfd_from_remote_memory
6773 #define elf_backend_bfd_from_remote_memory \
6774 _bfd_elf32_bfd_from_remote_memory
6776 #undef elf_backend_size_info
6777 #define elf_backend_size_info \
6778 _bfd_elf32_size_info
6780 #include "elf32-target.h"
6782 /* Restore defaults. */
6783 #undef elf_backend_object_p
6784 #define elf_backend_object_p elf64_x86_64_elf_object_p
6785 #undef elf_backend_bfd_from_remote_memory
6786 #undef elf_backend_size_info
6787 #undef elf_backend_modify_segment_map
6788 #undef elf_backend_modify_program_headers
6789 #undef elf_backend_final_write_processing
6791 /* Intel L1OM support. */
6794 elf64_l1om_elf_object_p (bfd
*abfd
)
6796 /* Set the right machine number for an L1OM elf64 file. */
6797 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
6801 #undef TARGET_LITTLE_SYM
6802 #define TARGET_LITTLE_SYM l1om_elf64_vec
6803 #undef TARGET_LITTLE_NAME
6804 #define TARGET_LITTLE_NAME "elf64-l1om"
6806 #define ELF_ARCH bfd_arch_l1om
6808 #undef ELF_MACHINE_CODE
6809 #define ELF_MACHINE_CODE EM_L1OM
6814 #define elf64_bed elf64_l1om_bed
6816 #undef elf_backend_object_p
6817 #define elf_backend_object_p elf64_l1om_elf_object_p
6819 /* Restore defaults. */
6820 #undef ELF_MAXPAGESIZE
6821 #undef ELF_MINPAGESIZE
6822 #undef ELF_COMMONPAGESIZE
6823 #define ELF_MAXPAGESIZE 0x200000
6824 #define ELF_MINPAGESIZE 0x1000
6825 #define ELF_COMMONPAGESIZE 0x1000
6826 #undef elf_backend_plt_alignment
6827 #define elf_backend_plt_alignment 4
6828 #undef elf_backend_arch_data
6829 #define elf_backend_arch_data &elf_x86_64_arch_bed
6831 #include "elf64-target.h"
6833 /* FreeBSD L1OM support. */
6835 #undef TARGET_LITTLE_SYM
6836 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
6837 #undef TARGET_LITTLE_NAME
6838 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
6841 #define ELF_OSABI ELFOSABI_FREEBSD
6844 #define elf64_bed elf64_l1om_fbsd_bed
6846 #include "elf64-target.h"
6848 /* Intel K1OM support. */
6851 elf64_k1om_elf_object_p (bfd
*abfd
)
6853 /* Set the right machine number for an K1OM elf64 file. */
6854 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
6858 #undef TARGET_LITTLE_SYM
6859 #define TARGET_LITTLE_SYM k1om_elf64_vec
6860 #undef TARGET_LITTLE_NAME
6861 #define TARGET_LITTLE_NAME "elf64-k1om"
6863 #define ELF_ARCH bfd_arch_k1om
6865 #undef ELF_MACHINE_CODE
6866 #define ELF_MACHINE_CODE EM_K1OM
6871 #define elf64_bed elf64_k1om_bed
6873 #undef elf_backend_object_p
6874 #define elf_backend_object_p elf64_k1om_elf_object_p
6876 #undef elf_backend_static_tls_alignment
6878 #undef elf_backend_want_plt_sym
6879 #define elf_backend_want_plt_sym 0
6881 #include "elf64-target.h"
6883 /* FreeBSD K1OM support. */
6885 #undef TARGET_LITTLE_SYM
6886 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
6887 #undef TARGET_LITTLE_NAME
6888 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
6891 #define ELF_OSABI ELFOSABI_FREEBSD
6894 #define elf64_bed elf64_k1om_fbsd_bed
6896 #include "elf64-target.h"
6898 /* 32bit x86-64 support. */
6900 #undef TARGET_LITTLE_SYM
6901 #define TARGET_LITTLE_SYM x86_64_elf32_vec
6902 #undef TARGET_LITTLE_NAME
6903 #define TARGET_LITTLE_NAME "elf32-x86-64"
6907 #define ELF_ARCH bfd_arch_i386
6909 #undef ELF_MACHINE_CODE
6910 #define ELF_MACHINE_CODE EM_X86_64
6914 #undef elf_backend_object_p
6915 #define elf_backend_object_p \
6916 elf32_x86_64_elf_object_p
6918 #undef elf_backend_bfd_from_remote_memory
6919 #define elf_backend_bfd_from_remote_memory \
6920 _bfd_elf32_bfd_from_remote_memory
6922 #undef elf_backend_size_info
6923 #define elf_backend_size_info \
6924 _bfd_elf32_size_info
6926 #include "elf32-target.h"