1 /* X86-64 specific support for ELF
2 Copyright (C) 2000-2016 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka <jh@suse.cz>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
28 #include "bfd_stdint.h"
32 #include "libiberty.h"
34 #include "opcode/i386.h"
35 #include "elf/x86-64.h"
42 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
43 #define MINUS_ONE (~ (bfd_vma) 0)
45 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
46 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
47 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
48 since they are the same. */
50 #define ABI_64_P(abfd) \
51 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
53 /* The relocation "howto" table. Order of fields:
54 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
55 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
56 static reloc_howto_type x86_64_elf_howto_table
[] =
58 HOWTO(R_X86_64_NONE
, 0, 3, 0, FALSE
, 0, complain_overflow_dont
,
59 bfd_elf_generic_reloc
, "R_X86_64_NONE", FALSE
, 0x00000000, 0x00000000,
61 HOWTO(R_X86_64_64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
62 bfd_elf_generic_reloc
, "R_X86_64_64", FALSE
, MINUS_ONE
, MINUS_ONE
,
64 HOWTO(R_X86_64_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
65 bfd_elf_generic_reloc
, "R_X86_64_PC32", FALSE
, 0xffffffff, 0xffffffff,
67 HOWTO(R_X86_64_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
68 bfd_elf_generic_reloc
, "R_X86_64_GOT32", FALSE
, 0xffffffff, 0xffffffff,
70 HOWTO(R_X86_64_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
71 bfd_elf_generic_reloc
, "R_X86_64_PLT32", FALSE
, 0xffffffff, 0xffffffff,
73 HOWTO(R_X86_64_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
74 bfd_elf_generic_reloc
, "R_X86_64_COPY", FALSE
, 0xffffffff, 0xffffffff,
76 HOWTO(R_X86_64_GLOB_DAT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
77 bfd_elf_generic_reloc
, "R_X86_64_GLOB_DAT", FALSE
, MINUS_ONE
,
79 HOWTO(R_X86_64_JUMP_SLOT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
80 bfd_elf_generic_reloc
, "R_X86_64_JUMP_SLOT", FALSE
, MINUS_ONE
,
82 HOWTO(R_X86_64_RELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
83 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE", FALSE
, MINUS_ONE
,
85 HOWTO(R_X86_64_GOTPCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
86 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL", FALSE
, 0xffffffff,
88 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
89 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
91 HOWTO(R_X86_64_32S
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
92 bfd_elf_generic_reloc
, "R_X86_64_32S", FALSE
, 0xffffffff, 0xffffffff,
94 HOWTO(R_X86_64_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
95 bfd_elf_generic_reloc
, "R_X86_64_16", FALSE
, 0xffff, 0xffff, FALSE
),
96 HOWTO(R_X86_64_PC16
,0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
97 bfd_elf_generic_reloc
, "R_X86_64_PC16", FALSE
, 0xffff, 0xffff, TRUE
),
98 HOWTO(R_X86_64_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
99 bfd_elf_generic_reloc
, "R_X86_64_8", FALSE
, 0xff, 0xff, FALSE
),
100 HOWTO(R_X86_64_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
101 bfd_elf_generic_reloc
, "R_X86_64_PC8", FALSE
, 0xff, 0xff, TRUE
),
102 HOWTO(R_X86_64_DTPMOD64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
103 bfd_elf_generic_reloc
, "R_X86_64_DTPMOD64", FALSE
, MINUS_ONE
,
105 HOWTO(R_X86_64_DTPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
106 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF64", FALSE
, MINUS_ONE
,
108 HOWTO(R_X86_64_TPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
109 bfd_elf_generic_reloc
, "R_X86_64_TPOFF64", FALSE
, MINUS_ONE
,
111 HOWTO(R_X86_64_TLSGD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
112 bfd_elf_generic_reloc
, "R_X86_64_TLSGD", FALSE
, 0xffffffff,
114 HOWTO(R_X86_64_TLSLD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
115 bfd_elf_generic_reloc
, "R_X86_64_TLSLD", FALSE
, 0xffffffff,
117 HOWTO(R_X86_64_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
118 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF32", FALSE
, 0xffffffff,
120 HOWTO(R_X86_64_GOTTPOFF
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
121 bfd_elf_generic_reloc
, "R_X86_64_GOTTPOFF", FALSE
, 0xffffffff,
123 HOWTO(R_X86_64_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
124 bfd_elf_generic_reloc
, "R_X86_64_TPOFF32", FALSE
, 0xffffffff,
126 HOWTO(R_X86_64_PC64
, 0, 4, 64, TRUE
, 0, complain_overflow_bitfield
,
127 bfd_elf_generic_reloc
, "R_X86_64_PC64", FALSE
, MINUS_ONE
, MINUS_ONE
,
129 HOWTO(R_X86_64_GOTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
130 bfd_elf_generic_reloc
, "R_X86_64_GOTOFF64",
131 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
132 HOWTO(R_X86_64_GOTPC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
133 bfd_elf_generic_reloc
, "R_X86_64_GOTPC32",
134 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
135 HOWTO(R_X86_64_GOT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
136 bfd_elf_generic_reloc
, "R_X86_64_GOT64", FALSE
, MINUS_ONE
, MINUS_ONE
,
138 HOWTO(R_X86_64_GOTPCREL64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
139 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL64", FALSE
, MINUS_ONE
,
141 HOWTO(R_X86_64_GOTPC64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
142 bfd_elf_generic_reloc
, "R_X86_64_GOTPC64",
143 FALSE
, MINUS_ONE
, MINUS_ONE
, TRUE
),
144 HOWTO(R_X86_64_GOTPLT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
145 bfd_elf_generic_reloc
, "R_X86_64_GOTPLT64", FALSE
, MINUS_ONE
,
147 HOWTO(R_X86_64_PLTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
148 bfd_elf_generic_reloc
, "R_X86_64_PLTOFF64", FALSE
, MINUS_ONE
,
150 HOWTO(R_X86_64_SIZE32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
151 bfd_elf_generic_reloc
, "R_X86_64_SIZE32", FALSE
, 0xffffffff, 0xffffffff,
153 HOWTO(R_X86_64_SIZE64
, 0, 4, 64, FALSE
, 0, complain_overflow_unsigned
,
154 bfd_elf_generic_reloc
, "R_X86_64_SIZE64", FALSE
, MINUS_ONE
, MINUS_ONE
,
156 HOWTO(R_X86_64_GOTPC32_TLSDESC
, 0, 2, 32, TRUE
, 0,
157 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
158 "R_X86_64_GOTPC32_TLSDESC",
159 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
160 HOWTO(R_X86_64_TLSDESC_CALL
, 0, 0, 0, FALSE
, 0,
161 complain_overflow_dont
, bfd_elf_generic_reloc
,
162 "R_X86_64_TLSDESC_CALL",
164 HOWTO(R_X86_64_TLSDESC
, 0, 4, 64, FALSE
, 0,
165 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
167 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
168 HOWTO(R_X86_64_IRELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
169 bfd_elf_generic_reloc
, "R_X86_64_IRELATIVE", FALSE
, MINUS_ONE
,
171 HOWTO(R_X86_64_RELATIVE64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
172 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE64", FALSE
, MINUS_ONE
,
174 HOWTO(R_X86_64_PC32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
175 bfd_elf_generic_reloc
, "R_X86_64_PC32_BND", FALSE
, 0xffffffff, 0xffffffff,
177 HOWTO(R_X86_64_PLT32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
178 bfd_elf_generic_reloc
, "R_X86_64_PLT32_BND", FALSE
, 0xffffffff, 0xffffffff,
180 HOWTO(R_X86_64_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
181 bfd_elf_generic_reloc
, "R_X86_64_GOTPCRELX", FALSE
, 0xffffffff,
183 HOWTO(R_X86_64_REX_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
184 bfd_elf_generic_reloc
, "R_X86_64_REX_GOTPCRELX", FALSE
, 0xffffffff,
187 /* We have a gap in the reloc numbers here.
188 R_X86_64_standard counts the number up to this point, and
189 R_X86_64_vt_offset is the value to subtract from a reloc type of
190 R_X86_64_GNU_VT* to form an index into this table. */
191 #define R_X86_64_standard (R_X86_64_REX_GOTPCRELX + 1)
192 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
194 /* GNU extension to record C++ vtable hierarchy. */
195 HOWTO (R_X86_64_GNU_VTINHERIT
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
196 NULL
, "R_X86_64_GNU_VTINHERIT", FALSE
, 0, 0, FALSE
),
198 /* GNU extension to record C++ vtable member usage. */
199 HOWTO (R_X86_64_GNU_VTENTRY
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
200 _bfd_elf_rel_vtable_reloc_fn
, "R_X86_64_GNU_VTENTRY", FALSE
, 0, 0,
203 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
204 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
205 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
209 #define IS_X86_64_PCREL_TYPE(TYPE) \
210 ( ((TYPE) == R_X86_64_PC8) \
211 || ((TYPE) == R_X86_64_PC16) \
212 || ((TYPE) == R_X86_64_PC32) \
213 || ((TYPE) == R_X86_64_PC32_BND) \
214 || ((TYPE) == R_X86_64_PC64))
216 /* Map BFD relocs to the x86_64 elf relocs. */
219 bfd_reloc_code_real_type bfd_reloc_val
;
220 unsigned char elf_reloc_val
;
223 static const struct elf_reloc_map x86_64_reloc_map
[] =
225 { BFD_RELOC_NONE
, R_X86_64_NONE
, },
226 { BFD_RELOC_64
, R_X86_64_64
, },
227 { BFD_RELOC_32_PCREL
, R_X86_64_PC32
, },
228 { BFD_RELOC_X86_64_GOT32
, R_X86_64_GOT32
,},
229 { BFD_RELOC_X86_64_PLT32
, R_X86_64_PLT32
,},
230 { BFD_RELOC_X86_64_COPY
, R_X86_64_COPY
, },
231 { BFD_RELOC_X86_64_GLOB_DAT
, R_X86_64_GLOB_DAT
, },
232 { BFD_RELOC_X86_64_JUMP_SLOT
, R_X86_64_JUMP_SLOT
, },
233 { BFD_RELOC_X86_64_RELATIVE
, R_X86_64_RELATIVE
, },
234 { BFD_RELOC_X86_64_GOTPCREL
, R_X86_64_GOTPCREL
, },
235 { BFD_RELOC_32
, R_X86_64_32
, },
236 { BFD_RELOC_X86_64_32S
, R_X86_64_32S
, },
237 { BFD_RELOC_16
, R_X86_64_16
, },
238 { BFD_RELOC_16_PCREL
, R_X86_64_PC16
, },
239 { BFD_RELOC_8
, R_X86_64_8
, },
240 { BFD_RELOC_8_PCREL
, R_X86_64_PC8
, },
241 { BFD_RELOC_X86_64_DTPMOD64
, R_X86_64_DTPMOD64
, },
242 { BFD_RELOC_X86_64_DTPOFF64
, R_X86_64_DTPOFF64
, },
243 { BFD_RELOC_X86_64_TPOFF64
, R_X86_64_TPOFF64
, },
244 { BFD_RELOC_X86_64_TLSGD
, R_X86_64_TLSGD
, },
245 { BFD_RELOC_X86_64_TLSLD
, R_X86_64_TLSLD
, },
246 { BFD_RELOC_X86_64_DTPOFF32
, R_X86_64_DTPOFF32
, },
247 { BFD_RELOC_X86_64_GOTTPOFF
, R_X86_64_GOTTPOFF
, },
248 { BFD_RELOC_X86_64_TPOFF32
, R_X86_64_TPOFF32
, },
249 { BFD_RELOC_64_PCREL
, R_X86_64_PC64
, },
250 { BFD_RELOC_X86_64_GOTOFF64
, R_X86_64_GOTOFF64
, },
251 { BFD_RELOC_X86_64_GOTPC32
, R_X86_64_GOTPC32
, },
252 { BFD_RELOC_X86_64_GOT64
, R_X86_64_GOT64
, },
253 { BFD_RELOC_X86_64_GOTPCREL64
,R_X86_64_GOTPCREL64
, },
254 { BFD_RELOC_X86_64_GOTPC64
, R_X86_64_GOTPC64
, },
255 { BFD_RELOC_X86_64_GOTPLT64
, R_X86_64_GOTPLT64
, },
256 { BFD_RELOC_X86_64_PLTOFF64
, R_X86_64_PLTOFF64
, },
257 { BFD_RELOC_SIZE32
, R_X86_64_SIZE32
, },
258 { BFD_RELOC_SIZE64
, R_X86_64_SIZE64
, },
259 { BFD_RELOC_X86_64_GOTPC32_TLSDESC
, R_X86_64_GOTPC32_TLSDESC
, },
260 { BFD_RELOC_X86_64_TLSDESC_CALL
, R_X86_64_TLSDESC_CALL
, },
261 { BFD_RELOC_X86_64_TLSDESC
, R_X86_64_TLSDESC
, },
262 { BFD_RELOC_X86_64_IRELATIVE
, R_X86_64_IRELATIVE
, },
263 { BFD_RELOC_X86_64_PC32_BND
, R_X86_64_PC32_BND
, },
264 { BFD_RELOC_X86_64_PLT32_BND
, R_X86_64_PLT32_BND
, },
265 { BFD_RELOC_X86_64_GOTPCRELX
, R_X86_64_GOTPCRELX
, },
266 { BFD_RELOC_X86_64_REX_GOTPCRELX
, R_X86_64_REX_GOTPCRELX
, },
267 { BFD_RELOC_VTABLE_INHERIT
, R_X86_64_GNU_VTINHERIT
, },
268 { BFD_RELOC_VTABLE_ENTRY
, R_X86_64_GNU_VTENTRY
, },
271 static reloc_howto_type
*
272 elf_x86_64_rtype_to_howto (bfd
*abfd
, unsigned r_type
)
276 if (r_type
== (unsigned int) R_X86_64_32
)
281 i
= ARRAY_SIZE (x86_64_elf_howto_table
) - 1;
283 else if (r_type
< (unsigned int) R_X86_64_GNU_VTINHERIT
284 || r_type
>= (unsigned int) R_X86_64_max
)
286 if (r_type
>= (unsigned int) R_X86_64_standard
)
288 (*_bfd_error_handler
) (_("%B: invalid relocation type %d"),
290 r_type
= R_X86_64_NONE
;
295 i
= r_type
- (unsigned int) R_X86_64_vt_offset
;
296 BFD_ASSERT (x86_64_elf_howto_table
[i
].type
== r_type
);
297 return &x86_64_elf_howto_table
[i
];
300 /* Given a BFD reloc type, return a HOWTO structure. */
301 static reloc_howto_type
*
302 elf_x86_64_reloc_type_lookup (bfd
*abfd
,
303 bfd_reloc_code_real_type code
)
307 for (i
= 0; i
< sizeof (x86_64_reloc_map
) / sizeof (struct elf_reloc_map
);
310 if (x86_64_reloc_map
[i
].bfd_reloc_val
== code
)
311 return elf_x86_64_rtype_to_howto (abfd
,
312 x86_64_reloc_map
[i
].elf_reloc_val
);
317 static reloc_howto_type
*
318 elf_x86_64_reloc_name_lookup (bfd
*abfd
,
323 if (!ABI_64_P (abfd
) && strcasecmp (r_name
, "R_X86_64_32") == 0)
325 /* Get x32 R_X86_64_32. */
326 reloc_howto_type
*reloc
327 = &x86_64_elf_howto_table
[ARRAY_SIZE (x86_64_elf_howto_table
) - 1];
328 BFD_ASSERT (reloc
->type
== (unsigned int) R_X86_64_32
);
332 for (i
= 0; i
< ARRAY_SIZE (x86_64_elf_howto_table
); i
++)
333 if (x86_64_elf_howto_table
[i
].name
!= NULL
334 && strcasecmp (x86_64_elf_howto_table
[i
].name
, r_name
) == 0)
335 return &x86_64_elf_howto_table
[i
];
340 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
343 elf_x86_64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
344 Elf_Internal_Rela
*dst
)
348 r_type
= ELF32_R_TYPE (dst
->r_info
);
349 cache_ptr
->howto
= elf_x86_64_rtype_to_howto (abfd
, r_type
);
350 BFD_ASSERT (r_type
== cache_ptr
->howto
->type
);
353 /* Support for core dump NOTE sections. */
355 elf_x86_64_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
360 switch (note
->descsz
)
365 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
367 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
370 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
378 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
380 elf_tdata (abfd
)->core
->signal
381 = bfd_get_16 (abfd
, note
->descdata
+ 12);
384 elf_tdata (abfd
)->core
->lwpid
385 = bfd_get_32 (abfd
, note
->descdata
+ 32);
394 /* Make a ".reg/999" section. */
395 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
396 size
, note
->descpos
+ offset
);
400 elf_x86_64_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
402 switch (note
->descsz
)
407 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
408 elf_tdata (abfd
)->core
->pid
409 = bfd_get_32 (abfd
, note
->descdata
+ 12);
410 elf_tdata (abfd
)->core
->program
411 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
412 elf_tdata (abfd
)->core
->command
413 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
416 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
417 elf_tdata (abfd
)->core
->pid
418 = bfd_get_32 (abfd
, note
->descdata
+ 24);
419 elf_tdata (abfd
)->core
->program
420 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
421 elf_tdata (abfd
)->core
->command
422 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
425 /* Note that for some reason, a spurious space is tacked
426 onto the end of the args in some (at least one anyway)
427 implementations, so strip it off if it exists. */
430 char *command
= elf_tdata (abfd
)->core
->command
;
431 int n
= strlen (command
);
433 if (0 < n
&& command
[n
- 1] == ' ')
434 command
[n
- 1] = '\0';
442 elf_x86_64_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
,
445 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
447 const char *fname
, *psargs
;
458 va_start (ap
, note_type
);
459 fname
= va_arg (ap
, const char *);
460 psargs
= va_arg (ap
, const char *);
463 if (bed
->s
->elfclass
== ELFCLASS32
)
466 memset (&data
, 0, sizeof (data
));
467 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
468 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
469 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
470 &data
, sizeof (data
));
475 memset (&data
, 0, sizeof (data
));
476 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
477 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
478 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
479 &data
, sizeof (data
));
484 va_start (ap
, note_type
);
485 pid
= va_arg (ap
, long);
486 cursig
= va_arg (ap
, int);
487 gregs
= va_arg (ap
, const void *);
490 if (bed
->s
->elfclass
== ELFCLASS32
)
492 if (bed
->elf_machine_code
== EM_X86_64
)
494 prstatusx32_t prstat
;
495 memset (&prstat
, 0, sizeof (prstat
));
497 prstat
.pr_cursig
= cursig
;
498 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
499 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
500 &prstat
, sizeof (prstat
));
505 memset (&prstat
, 0, sizeof (prstat
));
507 prstat
.pr_cursig
= cursig
;
508 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
509 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
510 &prstat
, sizeof (prstat
));
516 memset (&prstat
, 0, sizeof (prstat
));
518 prstat
.pr_cursig
= cursig
;
519 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
520 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
521 &prstat
, sizeof (prstat
));
528 /* Functions for the x86-64 ELF linker. */
530 /* The name of the dynamic interpreter. This is put in the .interp
533 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
534 #define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
536 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
537 copying dynamic variables from a shared lib into an app's dynbss
538 section, and instead use a dynamic relocation to point into the
540 #define ELIMINATE_COPY_RELOCS 1
542 /* The size in bytes of an entry in the global offset table. */
544 #define GOT_ENTRY_SIZE 8
546 /* The size in bytes of an entry in the procedure linkage table. */
548 #define PLT_ENTRY_SIZE 16
550 /* The first entry in a procedure linkage table looks like this. See the
551 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
553 static const bfd_byte elf_x86_64_plt0_entry
[PLT_ENTRY_SIZE
] =
555 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
556 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
557 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
560 /* Subsequent entries in a procedure linkage table look like this. */
562 static const bfd_byte elf_x86_64_plt_entry
[PLT_ENTRY_SIZE
] =
564 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
565 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
566 0x68, /* pushq immediate */
567 0, 0, 0, 0, /* replaced with index into relocation table. */
568 0xe9, /* jmp relative */
569 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
572 /* The first entry in a procedure linkage table with BND relocations
575 static const bfd_byte elf_x86_64_bnd_plt0_entry
[PLT_ENTRY_SIZE
] =
577 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
578 0xf2, 0xff, 0x25, 16, 0, 0, 0, /* bnd jmpq *GOT+16(%rip) */
579 0x0f, 0x1f, 0 /* nopl (%rax) */
582 /* Subsequent entries for legacy branches in a procedure linkage table
583 with BND relocations look like this. */
585 static const bfd_byte elf_x86_64_legacy_plt_entry
[PLT_ENTRY_SIZE
] =
587 0x68, 0, 0, 0, 0, /* pushq immediate */
588 0xe9, 0, 0, 0, 0, /* jmpq relative */
589 0x66, 0x0f, 0x1f, 0x44, 0, 0 /* nopw (%rax,%rax,1) */
592 /* Subsequent entries for branches with BND prefx in a procedure linkage
593 table with BND relocations look like this. */
595 static const bfd_byte elf_x86_64_bnd_plt_entry
[PLT_ENTRY_SIZE
] =
597 0x68, 0, 0, 0, 0, /* pushq immediate */
598 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
599 0x0f, 0x1f, 0x44, 0, 0 /* nopl 0(%rax,%rax,1) */
602 /* Entries for legacy branches in the second procedure linkage table
605 static const bfd_byte elf_x86_64_legacy_plt2_entry
[8] =
607 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
608 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
609 0x66, 0x90 /* xchg %ax,%ax */
612 /* Entries for branches with BND prefix in the second procedure linkage
613 table look like this. */
615 static const bfd_byte elf_x86_64_bnd_plt2_entry
[8] =
617 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
618 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
622 /* .eh_frame covering the .plt section. */
624 static const bfd_byte elf_x86_64_eh_frame_plt
[] =
626 #define PLT_CIE_LENGTH 20
627 #define PLT_FDE_LENGTH 36
628 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
629 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
630 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
631 0, 0, 0, 0, /* CIE ID */
633 'z', 'R', 0, /* Augmentation string */
634 1, /* Code alignment factor */
635 0x78, /* Data alignment factor */
636 16, /* Return address column */
637 1, /* Augmentation size */
638 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
639 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
640 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
641 DW_CFA_nop
, DW_CFA_nop
,
643 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
644 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
645 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
646 0, 0, 0, 0, /* .plt size goes here */
647 0, /* Augmentation size */
648 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
649 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
650 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
651 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
652 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
653 11, /* Block length */
654 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
655 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
656 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
657 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
658 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
661 /* Architecture-specific backend data for x86-64. */
663 struct elf_x86_64_backend_data
665 /* Templates for the initial PLT entry and for subsequent entries. */
666 const bfd_byte
*plt0_entry
;
667 const bfd_byte
*plt_entry
;
668 unsigned int plt_entry_size
; /* Size of each PLT entry. */
670 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
671 unsigned int plt0_got1_offset
;
672 unsigned int plt0_got2_offset
;
674 /* Offset of the end of the PC-relative instruction containing
676 unsigned int plt0_got2_insn_end
;
678 /* Offsets into plt_entry that are to be replaced with... */
679 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
680 unsigned int plt_reloc_offset
; /* ... offset into relocation table. */
681 unsigned int plt_plt_offset
; /* ... offset to start of .plt. */
683 /* Length of the PC-relative instruction containing plt_got_offset. */
684 unsigned int plt_got_insn_size
;
686 /* Offset of the end of the PC-relative jump to plt0_entry. */
687 unsigned int plt_plt_insn_end
;
689 /* Offset into plt_entry where the initial value of the GOT entry points. */
690 unsigned int plt_lazy_offset
;
692 /* .eh_frame covering the .plt section. */
693 const bfd_byte
*eh_frame_plt
;
694 unsigned int eh_frame_plt_size
;
697 #define get_elf_x86_64_arch_data(bed) \
698 ((const struct elf_x86_64_backend_data *) (bed)->arch_data)
700 #define get_elf_x86_64_backend_data(abfd) \
701 get_elf_x86_64_arch_data (get_elf_backend_data (abfd))
703 #define GET_PLT_ENTRY_SIZE(abfd) \
704 get_elf_x86_64_backend_data (abfd)->plt_entry_size
706 /* These are the standard parameters. */
707 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed
=
709 elf_x86_64_plt0_entry
, /* plt0_entry */
710 elf_x86_64_plt_entry
, /* plt_entry */
711 sizeof (elf_x86_64_plt_entry
), /* plt_entry_size */
712 2, /* plt0_got1_offset */
713 8, /* plt0_got2_offset */
714 12, /* plt0_got2_insn_end */
715 2, /* plt_got_offset */
716 7, /* plt_reloc_offset */
717 12, /* plt_plt_offset */
718 6, /* plt_got_insn_size */
719 PLT_ENTRY_SIZE
, /* plt_plt_insn_end */
720 6, /* plt_lazy_offset */
721 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
722 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
725 static const struct elf_x86_64_backend_data elf_x86_64_bnd_arch_bed
=
727 elf_x86_64_bnd_plt0_entry
, /* plt0_entry */
728 elf_x86_64_bnd_plt_entry
, /* plt_entry */
729 sizeof (elf_x86_64_bnd_plt_entry
), /* plt_entry_size */
730 2, /* plt0_got1_offset */
731 1+8, /* plt0_got2_offset */
732 1+12, /* plt0_got2_insn_end */
733 1+2, /* plt_got_offset */
734 1, /* plt_reloc_offset */
735 7, /* plt_plt_offset */
736 1+6, /* plt_got_insn_size */
737 11, /* plt_plt_insn_end */
738 0, /* plt_lazy_offset */
739 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
740 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
743 #define elf_backend_arch_data &elf_x86_64_arch_bed
745 /* Is a undefined weak symbol which is resolved to 0. Reference to an
746 undefined weak symbol is resolved to 0 when building executable if
748 1. Has non-GOT/non-PLT relocations in text section. Or
749 2. Has no GOT/PLT relocation.
751 #define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, EH) \
752 ((EH)->elf.root.type == bfd_link_hash_undefweak \
753 && bfd_link_executable (INFO) \
754 && (elf_x86_64_hash_table (INFO)->interp == NULL \
755 || !(EH)->has_got_reloc \
756 || (EH)->has_non_got_reloc \
757 || !(INFO)->dynamic_undefined_weak))
759 /* x86-64 ELF linker hash entry. */
761 struct elf_x86_64_link_hash_entry
763 struct elf_link_hash_entry elf
;
765 /* Track dynamic relocs copied for this symbol. */
766 struct elf_dyn_relocs
*dyn_relocs
;
768 #define GOT_UNKNOWN 0
772 #define GOT_TLS_GDESC 4
773 #define GOT_TLS_GD_BOTH_P(type) \
774 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
775 #define GOT_TLS_GD_P(type) \
776 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
777 #define GOT_TLS_GDESC_P(type) \
778 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
779 #define GOT_TLS_GD_ANY_P(type) \
780 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
781 unsigned char tls_type
;
783 /* TRUE if a weak symbol with a real definition needs a copy reloc.
784 When there is a weak symbol with a real definition, the processor
785 independent code will have arranged for us to see the real
786 definition first. We need to copy the needs_copy bit from the
787 real definition and check it when allowing copy reloc in PIE. */
788 unsigned int needs_copy
: 1;
790 /* TRUE if symbol has at least one BND relocation. */
791 unsigned int has_bnd_reloc
: 1;
793 /* TRUE if symbol has GOT or PLT relocations. */
794 unsigned int has_got_reloc
: 1;
796 /* TRUE if symbol has non-GOT/non-PLT relocations in text sections. */
797 unsigned int has_non_got_reloc
: 1;
799 /* Reference count of C/C++ function pointer relocations in read-write
800 section which can be resolved at run-time. */
801 bfd_signed_vma func_pointer_refcount
;
803 /* Information about the GOT PLT entry. Filled when there are both
804 GOT and PLT relocations against the same function. */
805 union gotplt_union plt_got
;
807 /* Information about the second PLT entry. Filled when has_bnd_reloc is
809 union gotplt_union plt_bnd
;
811 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
812 starting at the end of the jump table. */
816 #define elf_x86_64_hash_entry(ent) \
817 ((struct elf_x86_64_link_hash_entry *)(ent))
819 struct elf_x86_64_obj_tdata
821 struct elf_obj_tdata root
;
823 /* tls_type for each local got entry. */
824 char *local_got_tls_type
;
826 /* GOTPLT entries for TLS descriptors. */
827 bfd_vma
*local_tlsdesc_gotent
;
830 #define elf_x86_64_tdata(abfd) \
831 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
833 #define elf_x86_64_local_got_tls_type(abfd) \
834 (elf_x86_64_tdata (abfd)->local_got_tls_type)
836 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
837 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
839 #define is_x86_64_elf(bfd) \
840 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
841 && elf_tdata (bfd) != NULL \
842 && elf_object_id (bfd) == X86_64_ELF_DATA)
845 elf_x86_64_mkobject (bfd
*abfd
)
847 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_x86_64_obj_tdata
),
851 /* x86-64 ELF linker hash table. */
853 struct elf_x86_64_link_hash_table
855 struct elf_link_hash_table elf
;
857 /* Short-cuts to get to dynamic linker sections. */
861 asection
*plt_eh_frame
;
867 bfd_signed_vma refcount
;
871 /* The amount of space used by the jump slots in the GOT. */
872 bfd_vma sgotplt_jump_table_size
;
874 /* Small local sym cache. */
875 struct sym_cache sym_cache
;
877 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
878 bfd_vma (*r_sym
) (bfd_vma
);
879 unsigned int pointer_r_type
;
880 const char *dynamic_interpreter
;
881 int dynamic_interpreter_size
;
883 /* _TLS_MODULE_BASE_ symbol. */
884 struct bfd_link_hash_entry
*tls_module_base
;
886 /* Used by local STT_GNU_IFUNC symbols. */
887 htab_t loc_hash_table
;
888 void * loc_hash_memory
;
890 /* The offset into splt of the PLT entry for the TLS descriptor
891 resolver. Special values are 0, if not necessary (or not found
892 to be necessary yet), and -1 if needed but not determined
895 /* The offset into sgot of the GOT entry used by the PLT entry
899 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
900 bfd_vma next_jump_slot_index
;
901 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
902 bfd_vma next_irelative_index
;
905 /* Get the x86-64 ELF linker hash table from a link_info structure. */
907 #define elf_x86_64_hash_table(p) \
908 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
909 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
911 #define elf_x86_64_compute_jump_table_size(htab) \
912 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
914 /* Create an entry in an x86-64 ELF linker hash table. */
916 static struct bfd_hash_entry
*
917 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
918 struct bfd_hash_table
*table
,
921 /* Allocate the structure if it has not already been allocated by a
925 entry
= (struct bfd_hash_entry
*)
926 bfd_hash_allocate (table
,
927 sizeof (struct elf_x86_64_link_hash_entry
));
932 /* Call the allocation method of the superclass. */
933 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
936 struct elf_x86_64_link_hash_entry
*eh
;
938 eh
= (struct elf_x86_64_link_hash_entry
*) entry
;
939 eh
->dyn_relocs
= NULL
;
940 eh
->tls_type
= GOT_UNKNOWN
;
942 eh
->has_bnd_reloc
= 0;
943 eh
->has_got_reloc
= 0;
944 eh
->has_non_got_reloc
= 0;
945 eh
->func_pointer_refcount
= 0;
946 eh
->plt_bnd
.offset
= (bfd_vma
) -1;
947 eh
->plt_got
.offset
= (bfd_vma
) -1;
948 eh
->tlsdesc_got
= (bfd_vma
) -1;
954 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
955 for local symbol so that we can handle local STT_GNU_IFUNC symbols
956 as global symbol. We reuse indx and dynstr_index for local symbol
957 hash since they aren't used by global symbols in this backend. */
960 elf_x86_64_local_htab_hash (const void *ptr
)
962 struct elf_link_hash_entry
*h
963 = (struct elf_link_hash_entry
*) ptr
;
964 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
967 /* Compare local hash entries. */
970 elf_x86_64_local_htab_eq (const void *ptr1
, const void *ptr2
)
972 struct elf_link_hash_entry
*h1
973 = (struct elf_link_hash_entry
*) ptr1
;
974 struct elf_link_hash_entry
*h2
975 = (struct elf_link_hash_entry
*) ptr2
;
977 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
980 /* Find and/or create a hash entry for local symbol. */
982 static struct elf_link_hash_entry
*
983 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table
*htab
,
984 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
987 struct elf_x86_64_link_hash_entry e
, *ret
;
988 asection
*sec
= abfd
->sections
;
989 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
990 htab
->r_sym (rel
->r_info
));
993 e
.elf
.indx
= sec
->id
;
994 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
995 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
996 create
? INSERT
: NO_INSERT
);
1003 ret
= (struct elf_x86_64_link_hash_entry
*) *slot
;
1007 ret
= (struct elf_x86_64_link_hash_entry
*)
1008 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
1009 sizeof (struct elf_x86_64_link_hash_entry
));
1012 memset (ret
, 0, sizeof (*ret
));
1013 ret
->elf
.indx
= sec
->id
;
1014 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
1015 ret
->elf
.dynindx
= -1;
1016 ret
->func_pointer_refcount
= 0;
1017 ret
->plt_got
.offset
= (bfd_vma
) -1;
1023 /* Destroy an X86-64 ELF linker hash table. */
1026 elf_x86_64_link_hash_table_free (bfd
*obfd
)
1028 struct elf_x86_64_link_hash_table
*htab
1029 = (struct elf_x86_64_link_hash_table
*) obfd
->link
.hash
;
1031 if (htab
->loc_hash_table
)
1032 htab_delete (htab
->loc_hash_table
);
1033 if (htab
->loc_hash_memory
)
1034 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
1035 _bfd_elf_link_hash_table_free (obfd
);
1038 /* Create an X86-64 ELF linker hash table. */
1040 static struct bfd_link_hash_table
*
1041 elf_x86_64_link_hash_table_create (bfd
*abfd
)
1043 struct elf_x86_64_link_hash_table
*ret
;
1044 bfd_size_type amt
= sizeof (struct elf_x86_64_link_hash_table
);
1046 ret
= (struct elf_x86_64_link_hash_table
*) bfd_zmalloc (amt
);
1050 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1051 elf_x86_64_link_hash_newfunc
,
1052 sizeof (struct elf_x86_64_link_hash_entry
),
1059 if (ABI_64_P (abfd
))
1061 ret
->r_info
= elf64_r_info
;
1062 ret
->r_sym
= elf64_r_sym
;
1063 ret
->pointer_r_type
= R_X86_64_64
;
1064 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
1065 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
1069 ret
->r_info
= elf32_r_info
;
1070 ret
->r_sym
= elf32_r_sym
;
1071 ret
->pointer_r_type
= R_X86_64_32
;
1072 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
1073 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
1076 ret
->loc_hash_table
= htab_try_create (1024,
1077 elf_x86_64_local_htab_hash
,
1078 elf_x86_64_local_htab_eq
,
1080 ret
->loc_hash_memory
= objalloc_create ();
1081 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1083 elf_x86_64_link_hash_table_free (abfd
);
1086 ret
->elf
.root
.hash_table_free
= elf_x86_64_link_hash_table_free
;
1088 return &ret
->elf
.root
;
1091 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1092 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1096 elf_x86_64_create_dynamic_sections (bfd
*dynobj
,
1097 struct bfd_link_info
*info
)
1099 struct elf_x86_64_link_hash_table
*htab
;
1101 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1104 htab
= elf_x86_64_hash_table (info
);
1108 htab
->sdynbss
= bfd_get_linker_section (dynobj
, ".dynbss");
1112 if (bfd_link_executable (info
))
1114 /* Always allow copy relocs for building executables. */
1115 asection
*s
= bfd_get_linker_section (dynobj
, ".rela.bss");
1118 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
1119 s
= bfd_make_section_anyway_with_flags (dynobj
,
1121 (bed
->dynamic_sec_flags
1124 || ! bfd_set_section_alignment (dynobj
, s
,
1125 bed
->s
->log_file_align
))
1131 if (!info
->no_ld_generated_unwind_info
1132 && htab
->plt_eh_frame
== NULL
1133 && htab
->elf
.splt
!= NULL
)
1135 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1136 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1137 | SEC_LINKER_CREATED
);
1139 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
1140 if (htab
->plt_eh_frame
== NULL
1141 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 3))
1147 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1150 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
1151 struct elf_link_hash_entry
*dir
,
1152 struct elf_link_hash_entry
*ind
)
1154 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
1156 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
1157 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
1159 if (!edir
->has_bnd_reloc
)
1160 edir
->has_bnd_reloc
= eind
->has_bnd_reloc
;
1162 if (!edir
->has_got_reloc
)
1163 edir
->has_got_reloc
= eind
->has_got_reloc
;
1165 if (!edir
->has_non_got_reloc
)
1166 edir
->has_non_got_reloc
= eind
->has_non_got_reloc
;
1168 if (eind
->dyn_relocs
!= NULL
)
1170 if (edir
->dyn_relocs
!= NULL
)
1172 struct elf_dyn_relocs
**pp
;
1173 struct elf_dyn_relocs
*p
;
1175 /* Add reloc counts against the indirect sym to the direct sym
1176 list. Merge any entries against the same section. */
1177 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1179 struct elf_dyn_relocs
*q
;
1181 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1182 if (q
->sec
== p
->sec
)
1184 q
->pc_count
+= p
->pc_count
;
1185 q
->count
+= p
->count
;
1192 *pp
= edir
->dyn_relocs
;
1195 edir
->dyn_relocs
= eind
->dyn_relocs
;
1196 eind
->dyn_relocs
= NULL
;
1199 if (ind
->root
.type
== bfd_link_hash_indirect
1200 && dir
->got
.refcount
<= 0)
1202 edir
->tls_type
= eind
->tls_type
;
1203 eind
->tls_type
= GOT_UNKNOWN
;
1206 if (ELIMINATE_COPY_RELOCS
1207 && ind
->root
.type
!= bfd_link_hash_indirect
1208 && dir
->dynamic_adjusted
)
1210 /* If called to transfer flags for a weakdef during processing
1211 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1212 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1213 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1214 dir
->ref_regular
|= ind
->ref_regular
;
1215 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1216 dir
->needs_plt
|= ind
->needs_plt
;
1217 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1221 if (eind
->func_pointer_refcount
> 0)
1223 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1224 eind
->func_pointer_refcount
= 0;
1227 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1232 elf64_x86_64_elf_object_p (bfd
*abfd
)
1234 /* Set the right machine number for an x86-64 elf64 file. */
1235 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
1240 elf32_x86_64_elf_object_p (bfd
*abfd
)
1242 /* Set the right machine number for an x86-64 elf32 file. */
1243 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
1247 /* Return TRUE if the TLS access code sequence support transition
1251 elf_x86_64_check_tls_transition (bfd
*abfd
,
1252 struct bfd_link_info
*info
,
1255 Elf_Internal_Shdr
*symtab_hdr
,
1256 struct elf_link_hash_entry
**sym_hashes
,
1257 unsigned int r_type
,
1258 const Elf_Internal_Rela
*rel
,
1259 const Elf_Internal_Rela
*relend
)
1262 unsigned long r_symndx
;
1263 bfd_boolean largepic
= FALSE
;
1264 struct elf_link_hash_entry
*h
;
1266 struct elf_x86_64_link_hash_table
*htab
;
1268 /* Get the section contents. */
1269 if (contents
== NULL
)
1271 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1272 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1275 /* FIXME: How to better handle error condition? */
1276 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1279 /* Cache the section contents for elf_link_input_bfd. */
1280 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1284 htab
= elf_x86_64_hash_table (info
);
1285 offset
= rel
->r_offset
;
1288 case R_X86_64_TLSGD
:
1289 case R_X86_64_TLSLD
:
1290 if ((rel
+ 1) >= relend
)
1293 if (r_type
== R_X86_64_TLSGD
)
1295 /* Check transition from GD access model. For 64bit, only
1296 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1297 .word 0x6666; rex64; call __tls_get_addr
1298 can transit to different access model. For 32bit, only
1299 leaq foo@tlsgd(%rip), %rdi
1300 .word 0x6666; rex64; call __tls_get_addr
1301 can transit to different access model. For largepic
1303 leaq foo@tlsgd(%rip), %rdi
1304 movabsq $__tls_get_addr@pltoff, %rax
1308 static const unsigned char call
[] = { 0x66, 0x66, 0x48, 0xe8 };
1309 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1311 if ((offset
+ 12) > sec
->size
)
1314 if (memcmp (contents
+ offset
+ 4, call
, 4) != 0)
1316 if (!ABI_64_P (abfd
)
1317 || (offset
+ 19) > sec
->size
1319 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0
1320 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1321 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1326 else if (ABI_64_P (abfd
))
1329 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1335 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1341 /* Check transition from LD access model. Only
1342 leaq foo@tlsld(%rip), %rdi;
1344 can transit to different access model. For largepic
1346 leaq foo@tlsld(%rip), %rdi
1347 movabsq $__tls_get_addr@pltoff, %rax
1351 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1353 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1356 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0)
1359 if (0xe8 != *(contents
+ offset
+ 4))
1361 if (!ABI_64_P (abfd
)
1362 || (offset
+ 19) > sec
->size
1363 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1364 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1371 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1372 if (r_symndx
< symtab_hdr
->sh_info
)
1375 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1376 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1377 may be versioned. */
1379 && h
->root
.root
.string
!= NULL
1381 ? ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLTOFF64
1382 : (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1383 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
))
1384 && (strncmp (h
->root
.root
.string
,
1385 "__tls_get_addr", 14) == 0));
1387 case R_X86_64_GOTTPOFF
:
1388 /* Check transition from IE access model:
1389 mov foo@gottpoff(%rip), %reg
1390 add foo@gottpoff(%rip), %reg
1393 /* Check REX prefix first. */
1394 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1396 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1397 if (val
!= 0x48 && val
!= 0x4c)
1399 /* X32 may have 0x44 REX prefix or no REX prefix. */
1400 if (ABI_64_P (abfd
))
1406 /* X32 may not have any REX prefix. */
1407 if (ABI_64_P (abfd
))
1409 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1413 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1414 if (val
!= 0x8b && val
!= 0x03)
1417 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1418 return (val
& 0xc7) == 5;
1420 case R_X86_64_GOTPC32_TLSDESC
:
1421 /* Check transition from GDesc access model:
1422 leaq x@tlsdesc(%rip), %rax
1424 Make sure it's a leaq adding rip to a 32-bit offset
1425 into any register, although it's probably almost always
1428 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1431 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1432 if ((val
& 0xfb) != 0x48)
1435 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1438 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1439 return (val
& 0xc7) == 0x05;
1441 case R_X86_64_TLSDESC_CALL
:
1442 /* Check transition from GDesc access model:
1443 call *x@tlsdesc(%rax)
1445 if (offset
+ 2 <= sec
->size
)
1447 /* Make sure that it's a call *x@tlsdesc(%rax). */
1448 static const unsigned char call
[] = { 0xff, 0x10 };
1449 return memcmp (contents
+ offset
, call
, 2) == 0;
1459 /* Return TRUE if the TLS access transition is OK or no transition
1460 will be performed. Update R_TYPE if there is a transition. */
1463 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1464 asection
*sec
, bfd_byte
*contents
,
1465 Elf_Internal_Shdr
*symtab_hdr
,
1466 struct elf_link_hash_entry
**sym_hashes
,
1467 unsigned int *r_type
, int tls_type
,
1468 const Elf_Internal_Rela
*rel
,
1469 const Elf_Internal_Rela
*relend
,
1470 struct elf_link_hash_entry
*h
,
1471 unsigned long r_symndx
)
1473 unsigned int from_type
= *r_type
;
1474 unsigned int to_type
= from_type
;
1475 bfd_boolean check
= TRUE
;
1477 /* Skip TLS transition for functions. */
1479 && (h
->type
== STT_FUNC
1480 || h
->type
== STT_GNU_IFUNC
))
1485 case R_X86_64_TLSGD
:
1486 case R_X86_64_GOTPC32_TLSDESC
:
1487 case R_X86_64_TLSDESC_CALL
:
1488 case R_X86_64_GOTTPOFF
:
1489 if (bfd_link_executable (info
))
1492 to_type
= R_X86_64_TPOFF32
;
1494 to_type
= R_X86_64_GOTTPOFF
;
1497 /* When we are called from elf_x86_64_relocate_section,
1498 CONTENTS isn't NULL and there may be additional transitions
1499 based on TLS_TYPE. */
1500 if (contents
!= NULL
)
1502 unsigned int new_to_type
= to_type
;
1504 if (bfd_link_executable (info
)
1507 && tls_type
== GOT_TLS_IE
)
1508 new_to_type
= R_X86_64_TPOFF32
;
1510 if (to_type
== R_X86_64_TLSGD
1511 || to_type
== R_X86_64_GOTPC32_TLSDESC
1512 || to_type
== R_X86_64_TLSDESC_CALL
)
1514 if (tls_type
== GOT_TLS_IE
)
1515 new_to_type
= R_X86_64_GOTTPOFF
;
1518 /* We checked the transition before when we were called from
1519 elf_x86_64_check_relocs. We only want to check the new
1520 transition which hasn't been checked before. */
1521 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1522 to_type
= new_to_type
;
1527 case R_X86_64_TLSLD
:
1528 if (bfd_link_executable (info
))
1529 to_type
= R_X86_64_TPOFF32
;
1536 /* Return TRUE if there is no transition. */
1537 if (from_type
== to_type
)
1540 /* Check if the transition can be performed. */
1542 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1543 symtab_hdr
, sym_hashes
,
1544 from_type
, rel
, relend
))
1546 reloc_howto_type
*from
, *to
;
1549 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1550 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1553 name
= h
->root
.root
.string
;
1556 struct elf_x86_64_link_hash_table
*htab
;
1558 htab
= elf_x86_64_hash_table (info
);
1563 Elf_Internal_Sym
*isym
;
1565 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1567 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1571 (*_bfd_error_handler
)
1572 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1573 "in section `%A' failed"),
1574 abfd
, sec
, from
->name
, to
->name
, name
,
1575 (unsigned long) rel
->r_offset
);
1576 bfd_set_error (bfd_error_bad_value
);
1584 /* Rename some of the generic section flags to better document how they
1586 #define need_convert_load sec_flg0
1588 /* Look through the relocs for a section during the first phase, and
1589 calculate needed space in the global offset table, procedure
1590 linkage table, and dynamic reloc sections. */
1593 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1595 const Elf_Internal_Rela
*relocs
)
1597 struct elf_x86_64_link_hash_table
*htab
;
1598 Elf_Internal_Shdr
*symtab_hdr
;
1599 struct elf_link_hash_entry
**sym_hashes
;
1600 const Elf_Internal_Rela
*rel
;
1601 const Elf_Internal_Rela
*rel_end
;
1603 bfd_boolean use_plt_got
;
1605 if (bfd_link_relocatable (info
))
1608 BFD_ASSERT (is_x86_64_elf (abfd
));
1610 htab
= elf_x86_64_hash_table (info
);
1614 use_plt_got
= get_elf_x86_64_backend_data (abfd
) == &elf_x86_64_arch_bed
;
1616 symtab_hdr
= &elf_symtab_hdr (abfd
);
1617 sym_hashes
= elf_sym_hashes (abfd
);
1621 rel_end
= relocs
+ sec
->reloc_count
;
1622 for (rel
= relocs
; rel
< rel_end
; rel
++)
1624 unsigned int r_type
;
1625 unsigned long r_symndx
;
1626 struct elf_link_hash_entry
*h
;
1627 struct elf_x86_64_link_hash_entry
*eh
;
1628 Elf_Internal_Sym
*isym
;
1630 bfd_boolean size_reloc
;
1632 r_symndx
= htab
->r_sym (rel
->r_info
);
1633 r_type
= ELF32_R_TYPE (rel
->r_info
);
1635 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1637 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1642 if (r_symndx
< symtab_hdr
->sh_info
)
1644 /* A local symbol. */
1645 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1650 /* Check relocation against local STT_GNU_IFUNC symbol. */
1651 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1653 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
1658 /* Fake a STT_GNU_IFUNC symbol. */
1659 h
->type
= STT_GNU_IFUNC
;
1662 h
->forced_local
= 1;
1663 h
->root
.type
= bfd_link_hash_defined
;
1671 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1672 while (h
->root
.type
== bfd_link_hash_indirect
1673 || h
->root
.type
== bfd_link_hash_warning
)
1674 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1677 /* Check invalid x32 relocations. */
1678 if (!ABI_64_P (abfd
))
1684 case R_X86_64_DTPOFF64
:
1685 case R_X86_64_TPOFF64
:
1687 case R_X86_64_GOTOFF64
:
1688 case R_X86_64_GOT64
:
1689 case R_X86_64_GOTPCREL64
:
1690 case R_X86_64_GOTPC64
:
1691 case R_X86_64_GOTPLT64
:
1692 case R_X86_64_PLTOFF64
:
1695 name
= h
->root
.root
.string
;
1697 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1699 (*_bfd_error_handler
)
1700 (_("%B: relocation %s against symbol `%s' isn't "
1701 "supported in x32 mode"), abfd
,
1702 x86_64_elf_howto_table
[r_type
].name
, name
);
1703 bfd_set_error (bfd_error_bad_value
);
1711 /* Create the ifunc sections for static executables. If we
1712 never see an indirect function symbol nor we are building
1713 a static executable, those sections will be empty and
1714 won't appear in output. */
1720 case R_X86_64_PC32_BND
:
1721 case R_X86_64_PLT32_BND
:
1723 case R_X86_64_PLT32
:
1726 /* MPX PLT is supported only if elf_x86_64_arch_bed
1727 is used in 64-bit mode. */
1730 && (get_elf_x86_64_backend_data (abfd
)
1731 == &elf_x86_64_arch_bed
))
1733 elf_x86_64_hash_entry (h
)->has_bnd_reloc
= 1;
1735 /* Create the second PLT for Intel MPX support. */
1736 if (htab
->plt_bnd
== NULL
)
1738 unsigned int plt_bnd_align
;
1739 const struct elf_backend_data
*bed
;
1741 bed
= get_elf_backend_data (info
->output_bfd
);
1742 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry
) == 8
1743 && (sizeof (elf_x86_64_bnd_plt2_entry
)
1744 == sizeof (elf_x86_64_legacy_plt2_entry
)));
1747 if (htab
->elf
.dynobj
== NULL
)
1748 htab
->elf
.dynobj
= abfd
;
1750 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
1752 (bed
->dynamic_sec_flags
1757 if (htab
->plt_bnd
== NULL
1758 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
1767 case R_X86_64_GOTPCREL
:
1768 case R_X86_64_GOTPCRELX
:
1769 case R_X86_64_REX_GOTPCRELX
:
1770 case R_X86_64_GOTPCREL64
:
1771 if (htab
->elf
.dynobj
== NULL
)
1772 htab
->elf
.dynobj
= abfd
;
1773 if (!_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
, info
))
1778 /* It is referenced by a non-shared object. */
1780 h
->root
.non_ir_ref
= 1;
1782 if (h
->type
== STT_GNU_IFUNC
)
1783 elf_tdata (info
->output_bfd
)->has_gnu_symbols
1784 |= elf_gnu_symbol_ifunc
;
1787 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
1788 symtab_hdr
, sym_hashes
,
1789 &r_type
, GOT_UNKNOWN
,
1790 rel
, rel_end
, h
, r_symndx
))
1793 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
1796 case R_X86_64_TLSLD
:
1797 htab
->tls_ld_got
.refcount
+= 1;
1800 case R_X86_64_TPOFF32
:
1801 if (!bfd_link_executable (info
) && ABI_64_P (abfd
))
1804 name
= h
->root
.root
.string
;
1806 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1808 (*_bfd_error_handler
)
1809 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1811 x86_64_elf_howto_table
[r_type
].name
, name
);
1812 bfd_set_error (bfd_error_bad_value
);
1816 eh
->has_got_reloc
= 1;
1819 case R_X86_64_GOTTPOFF
:
1820 if (!bfd_link_executable (info
))
1821 info
->flags
|= DF_STATIC_TLS
;
1824 case R_X86_64_GOT32
:
1825 case R_X86_64_GOTPCREL
:
1826 case R_X86_64_GOTPCRELX
:
1827 case R_X86_64_REX_GOTPCRELX
:
1828 case R_X86_64_TLSGD
:
1829 case R_X86_64_GOT64
:
1830 case R_X86_64_GOTPCREL64
:
1831 case R_X86_64_GOTPLT64
:
1832 case R_X86_64_GOTPC32_TLSDESC
:
1833 case R_X86_64_TLSDESC_CALL
:
1834 /* This symbol requires a global offset table entry. */
1836 int tls_type
, old_tls_type
;
1840 default: tls_type
= GOT_NORMAL
; break;
1841 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
1842 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
1843 case R_X86_64_GOTPC32_TLSDESC
:
1844 case R_X86_64_TLSDESC_CALL
:
1845 tls_type
= GOT_TLS_GDESC
; break;
1850 h
->got
.refcount
+= 1;
1851 old_tls_type
= eh
->tls_type
;
1855 bfd_signed_vma
*local_got_refcounts
;
1857 /* This is a global offset table entry for a local symbol. */
1858 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1859 if (local_got_refcounts
== NULL
)
1863 size
= symtab_hdr
->sh_info
;
1864 size
*= sizeof (bfd_signed_vma
)
1865 + sizeof (bfd_vma
) + sizeof (char);
1866 local_got_refcounts
= ((bfd_signed_vma
*)
1867 bfd_zalloc (abfd
, size
));
1868 if (local_got_refcounts
== NULL
)
1870 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1871 elf_x86_64_local_tlsdesc_gotent (abfd
)
1872 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1873 elf_x86_64_local_got_tls_type (abfd
)
1874 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1876 local_got_refcounts
[r_symndx
] += 1;
1878 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
1881 /* If a TLS symbol is accessed using IE at least once,
1882 there is no point to use dynamic model for it. */
1883 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1884 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1885 || tls_type
!= GOT_TLS_IE
))
1887 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
1888 tls_type
= old_tls_type
;
1889 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1890 && GOT_TLS_GD_ANY_P (tls_type
))
1891 tls_type
|= old_tls_type
;
1895 name
= h
->root
.root
.string
;
1897 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
1899 (*_bfd_error_handler
)
1900 (_("%B: '%s' accessed both as normal and thread local symbol"),
1902 bfd_set_error (bfd_error_bad_value
);
1907 if (old_tls_type
!= tls_type
)
1910 eh
->tls_type
= tls_type
;
1912 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1917 case R_X86_64_GOTOFF64
:
1918 case R_X86_64_GOTPC32
:
1919 case R_X86_64_GOTPC64
:
1922 eh
->has_got_reloc
= 1;
1923 if (htab
->elf
.sgot
== NULL
)
1925 if (htab
->elf
.dynobj
== NULL
)
1926 htab
->elf
.dynobj
= abfd
;
1927 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
1933 case R_X86_64_PLT32
:
1934 case R_X86_64_PLT32_BND
:
1935 /* This symbol requires a procedure linkage table entry. We
1936 actually build the entry in adjust_dynamic_symbol,
1937 because this might be a case of linking PIC code which is
1938 never referenced by a dynamic object, in which case we
1939 don't need to generate a procedure linkage table entry
1942 /* If this is a local symbol, we resolve it directly without
1943 creating a procedure linkage table entry. */
1947 eh
->has_got_reloc
= 1;
1949 h
->plt
.refcount
+= 1;
1952 case R_X86_64_PLTOFF64
:
1953 /* This tries to form the 'address' of a function relative
1954 to GOT. For global symbols we need a PLT entry. */
1958 h
->plt
.refcount
+= 1;
1962 case R_X86_64_SIZE32
:
1963 case R_X86_64_SIZE64
:
1968 if (!ABI_64_P (abfd
))
1973 /* Let's help debug shared library creation. These relocs
1974 cannot be used in shared libs. Don't error out for
1975 sections we don't care about, such as debug sections or
1976 non-constant sections, or when relocation overflow check
1978 if (!info
->no_reloc_overflow_check
1979 && bfd_link_pic (info
)
1980 && (sec
->flags
& SEC_ALLOC
) != 0
1981 && (sec
->flags
& SEC_READONLY
) != 0)
1984 name
= h
->root
.root
.string
;
1986 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1987 (*_bfd_error_handler
)
1988 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1989 abfd
, x86_64_elf_howto_table
[r_type
].name
, name
);
1990 bfd_set_error (bfd_error_bad_value
);
1998 case R_X86_64_PC32_BND
:
2002 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2003 eh
->has_non_got_reloc
= 1;
2004 /* STT_GNU_IFUNC symbol must go through PLT even if it is
2005 locally defined and undefined symbol may turn out to be
2006 a STT_GNU_IFUNC symbol later. */
2008 && (bfd_link_executable (info
)
2009 || ((h
->type
== STT_GNU_IFUNC
2010 || h
->root
.type
== bfd_link_hash_undefweak
2011 || h
->root
.type
== bfd_link_hash_undefined
)
2012 && SYMBOLIC_BIND (info
, h
))))
2014 /* If this reloc is in a read-only section, we might
2015 need a copy reloc. We can't check reliably at this
2016 stage whether the section is read-only, as input
2017 sections have not yet been mapped to output sections.
2018 Tentatively set the flag for now, and correct in
2019 adjust_dynamic_symbol. */
2022 /* We may need a .plt entry if the function this reloc
2023 refers to is in a shared lib. */
2024 h
->plt
.refcount
+= 1;
2025 if (r_type
== R_X86_64_PC32
)
2027 /* Since something like ".long foo - ." may be used
2028 as pointer, make sure that PLT is used if foo is
2029 a function defined in a shared library. */
2030 if ((sec
->flags
& SEC_CODE
) == 0)
2031 h
->pointer_equality_needed
= 1;
2033 else if (r_type
!= R_X86_64_PC32_BND
2034 && r_type
!= R_X86_64_PC64
)
2036 h
->pointer_equality_needed
= 1;
2037 /* At run-time, R_X86_64_64 can be resolved for both
2038 x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2039 can only be resolved for x32. */
2040 if ((sec
->flags
& SEC_READONLY
) == 0
2041 && (r_type
== R_X86_64_64
2042 || (!ABI_64_P (abfd
)
2043 && (r_type
== R_X86_64_32
2044 || r_type
== R_X86_64_32S
))))
2045 eh
->func_pointer_refcount
+= 1;
2051 /* If we are creating a shared library, and this is a reloc
2052 against a global symbol, or a non PC relative reloc
2053 against a local symbol, then we need to copy the reloc
2054 into the shared library. However, if we are linking with
2055 -Bsymbolic, we do not need to copy a reloc against a
2056 global symbol which is defined in an object we are
2057 including in the link (i.e., DEF_REGULAR is set). At
2058 this point we have not seen all the input files, so it is
2059 possible that DEF_REGULAR is not set now but will be set
2060 later (it is never cleared). In case of a weak definition,
2061 DEF_REGULAR may be cleared later by a strong definition in
2062 a shared library. We account for that possibility below by
2063 storing information in the relocs_copied field of the hash
2064 table entry. A similar situation occurs when creating
2065 shared libraries and symbol visibility changes render the
2068 If on the other hand, we are creating an executable, we
2069 may need to keep relocations for symbols satisfied by a
2070 dynamic library if we manage to avoid copy relocs for the
2072 if ((bfd_link_pic (info
)
2073 && (sec
->flags
& SEC_ALLOC
) != 0
2074 && (! IS_X86_64_PCREL_TYPE (r_type
)
2076 && (! SYMBOLIC_BIND (info
, h
)
2077 || h
->root
.type
== bfd_link_hash_defweak
2078 || !h
->def_regular
))))
2079 || (ELIMINATE_COPY_RELOCS
2080 && !bfd_link_pic (info
)
2081 && (sec
->flags
& SEC_ALLOC
) != 0
2083 && (h
->root
.type
== bfd_link_hash_defweak
2084 || !h
->def_regular
)))
2086 struct elf_dyn_relocs
*p
;
2087 struct elf_dyn_relocs
**head
;
2089 /* We must copy these reloc types into the output file.
2090 Create a reloc section in dynobj and make room for
2094 if (htab
->elf
.dynobj
== NULL
)
2095 htab
->elf
.dynobj
= abfd
;
2097 sreloc
= _bfd_elf_make_dynamic_reloc_section
2098 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
2099 abfd
, /*rela?*/ TRUE
);
2105 /* If this is a global symbol, we count the number of
2106 relocations we need for this symbol. */
2108 head
= &eh
->dyn_relocs
;
2111 /* Track dynamic relocs needed for local syms too.
2112 We really need local syms available to do this
2117 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2122 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2126 /* Beware of type punned pointers vs strict aliasing
2128 vpp
= &(elf_section_data (s
)->local_dynrel
);
2129 head
= (struct elf_dyn_relocs
**)vpp
;
2133 if (p
== NULL
|| p
->sec
!= sec
)
2135 bfd_size_type amt
= sizeof *p
;
2137 p
= ((struct elf_dyn_relocs
*)
2138 bfd_alloc (htab
->elf
.dynobj
, amt
));
2149 /* Count size relocation as PC-relative relocation. */
2150 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
2155 /* This relocation describes the C++ object vtable hierarchy.
2156 Reconstruct it for later use during GC. */
2157 case R_X86_64_GNU_VTINHERIT
:
2158 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2162 /* This relocation describes which C++ vtable entries are actually
2163 used. Record for later use during GC. */
2164 case R_X86_64_GNU_VTENTRY
:
2165 BFD_ASSERT (h
!= NULL
);
2167 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2177 && h
->plt
.refcount
> 0
2178 && (((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2179 || h
->got
.refcount
> 0)
2180 && htab
->plt_got
== NULL
)
2182 /* Create the GOT procedure linkage table. */
2183 unsigned int plt_got_align
;
2184 const struct elf_backend_data
*bed
;
2186 bed
= get_elf_backend_data (info
->output_bfd
);
2187 BFD_ASSERT (sizeof (elf_x86_64_legacy_plt2_entry
) == 8
2188 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2189 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2192 if (htab
->elf
.dynobj
== NULL
)
2193 htab
->elf
.dynobj
= abfd
;
2195 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2197 (bed
->dynamic_sec_flags
2202 if (htab
->plt_got
== NULL
2203 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2209 if ((r_type
== R_X86_64_GOTPCREL
2210 || r_type
== R_X86_64_GOTPCRELX
2211 || r_type
== R_X86_64_REX_GOTPCRELX
)
2212 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2213 sec
->need_convert_load
= 1;
2219 /* Return the section that should be marked against GC for a given
2223 elf_x86_64_gc_mark_hook (asection
*sec
,
2224 struct bfd_link_info
*info
,
2225 Elf_Internal_Rela
*rel
,
2226 struct elf_link_hash_entry
*h
,
2227 Elf_Internal_Sym
*sym
)
2230 switch (ELF32_R_TYPE (rel
->r_info
))
2232 case R_X86_64_GNU_VTINHERIT
:
2233 case R_X86_64_GNU_VTENTRY
:
2237 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2240 /* Update the got entry reference counts for the section being removed. */
2243 elf_x86_64_gc_sweep_hook (bfd
*abfd
, struct bfd_link_info
*info
,
2245 const Elf_Internal_Rela
*relocs
)
2247 struct elf_x86_64_link_hash_table
*htab
;
2248 Elf_Internal_Shdr
*symtab_hdr
;
2249 struct elf_link_hash_entry
**sym_hashes
;
2250 bfd_signed_vma
*local_got_refcounts
;
2251 const Elf_Internal_Rela
*rel
, *relend
;
2253 if (bfd_link_relocatable (info
))
2256 htab
= elf_x86_64_hash_table (info
);
2260 elf_section_data (sec
)->local_dynrel
= NULL
;
2262 symtab_hdr
= &elf_symtab_hdr (abfd
);
2263 sym_hashes
= elf_sym_hashes (abfd
);
2264 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2266 htab
= elf_x86_64_hash_table (info
);
2267 relend
= relocs
+ sec
->reloc_count
;
2268 for (rel
= relocs
; rel
< relend
; rel
++)
2270 unsigned long r_symndx
;
2271 unsigned int r_type
;
2272 struct elf_link_hash_entry
*h
= NULL
;
2273 bfd_boolean pointer_reloc
;
2275 r_symndx
= htab
->r_sym (rel
->r_info
);
2276 if (r_symndx
>= symtab_hdr
->sh_info
)
2278 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2279 while (h
->root
.type
== bfd_link_hash_indirect
2280 || h
->root
.type
== bfd_link_hash_warning
)
2281 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2285 /* A local symbol. */
2286 Elf_Internal_Sym
*isym
;
2288 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2291 /* Check relocation against local STT_GNU_IFUNC symbol. */
2293 && ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
2295 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
, FALSE
);
2303 struct elf_x86_64_link_hash_entry
*eh
;
2304 struct elf_dyn_relocs
**pp
;
2305 struct elf_dyn_relocs
*p
;
2307 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2309 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
2312 /* Everything must go for SEC. */
2318 r_type
= ELF32_R_TYPE (rel
->r_info
);
2319 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
2320 symtab_hdr
, sym_hashes
,
2321 &r_type
, GOT_UNKNOWN
,
2322 rel
, relend
, h
, r_symndx
))
2325 pointer_reloc
= FALSE
;
2328 case R_X86_64_TLSLD
:
2329 if (htab
->tls_ld_got
.refcount
> 0)
2330 htab
->tls_ld_got
.refcount
-= 1;
2333 case R_X86_64_TLSGD
:
2334 case R_X86_64_GOTPC32_TLSDESC
:
2335 case R_X86_64_TLSDESC_CALL
:
2336 case R_X86_64_GOTTPOFF
:
2337 case R_X86_64_GOT32
:
2338 case R_X86_64_GOTPCREL
:
2339 case R_X86_64_GOTPCRELX
:
2340 case R_X86_64_REX_GOTPCRELX
:
2341 case R_X86_64_GOT64
:
2342 case R_X86_64_GOTPCREL64
:
2343 case R_X86_64_GOTPLT64
:
2346 if (h
->got
.refcount
> 0)
2347 h
->got
.refcount
-= 1;
2348 if (h
->type
== STT_GNU_IFUNC
)
2350 if (h
->plt
.refcount
> 0)
2351 h
->plt
.refcount
-= 1;
2354 else if (local_got_refcounts
!= NULL
)
2356 if (local_got_refcounts
[r_symndx
] > 0)
2357 local_got_refcounts
[r_symndx
] -= 1;
2363 pointer_reloc
= !ABI_64_P (abfd
);
2367 pointer_reloc
= TRUE
;
2373 case R_X86_64_PC32_BND
:
2375 case R_X86_64_SIZE32
:
2376 case R_X86_64_SIZE64
:
2378 if (bfd_link_pic (info
)
2379 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2383 case R_X86_64_PLT32
:
2384 case R_X86_64_PLT32_BND
:
2385 case R_X86_64_PLTOFF64
:
2388 if (h
->plt
.refcount
> 0)
2389 h
->plt
.refcount
-= 1;
2390 if (pointer_reloc
&& (sec
->flags
& SEC_READONLY
) == 0)
2392 struct elf_x86_64_link_hash_entry
*eh
2393 = (struct elf_x86_64_link_hash_entry
*) h
;
2394 if (eh
->func_pointer_refcount
> 0)
2395 eh
->func_pointer_refcount
-= 1;
2408 /* Remove undefined weak symbol from the dynamic symbol table if it
2409 is resolved to 0. */
2412 elf_x86_64_fixup_symbol (struct bfd_link_info
*info
,
2413 struct elf_link_hash_entry
*h
)
2415 if (h
->dynindx
!= -1
2416 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2417 elf_x86_64_hash_entry (h
)))
2420 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2426 /* Adjust a symbol defined by a dynamic object and referenced by a
2427 regular object. The current definition is in some section of the
2428 dynamic object, but we're not including those sections. We have to
2429 change the definition to something the rest of the link can
2433 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2434 struct elf_link_hash_entry
*h
)
2436 struct elf_x86_64_link_hash_table
*htab
;
2438 struct elf_x86_64_link_hash_entry
*eh
;
2439 struct elf_dyn_relocs
*p
;
2441 /* STT_GNU_IFUNC symbol must go through PLT. */
2442 if (h
->type
== STT_GNU_IFUNC
)
2444 /* All local STT_GNU_IFUNC references must be treate as local
2445 calls via local PLT. */
2447 && SYMBOL_CALLS_LOCAL (info
, h
))
2449 bfd_size_type pc_count
= 0, count
= 0;
2450 struct elf_dyn_relocs
**pp
;
2452 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2453 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2455 pc_count
+= p
->pc_count
;
2456 p
->count
-= p
->pc_count
;
2465 if (pc_count
|| count
)
2469 if (h
->plt
.refcount
<= 0)
2470 h
->plt
.refcount
= 1;
2472 h
->plt
.refcount
+= 1;
2476 if (h
->plt
.refcount
<= 0)
2478 h
->plt
.offset
= (bfd_vma
) -1;
2484 /* If this is a function, put it in the procedure linkage table. We
2485 will fill in the contents of the procedure linkage table later,
2486 when we know the address of the .got section. */
2487 if (h
->type
== STT_FUNC
2490 if (h
->plt
.refcount
<= 0
2491 || SYMBOL_CALLS_LOCAL (info
, h
)
2492 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2493 && h
->root
.type
== bfd_link_hash_undefweak
))
2495 /* This case can occur if we saw a PLT32 reloc in an input
2496 file, but the symbol was never referred to by a dynamic
2497 object, or if all references were garbage collected. In
2498 such a case, we don't actually need to build a procedure
2499 linkage table, and we can just do a PC32 reloc instead. */
2500 h
->plt
.offset
= (bfd_vma
) -1;
2507 /* It's possible that we incorrectly decided a .plt reloc was
2508 needed for an R_X86_64_PC32 reloc to a non-function sym in
2509 check_relocs. We can't decide accurately between function and
2510 non-function syms in check-relocs; Objects loaded later in
2511 the link may change h->type. So fix it now. */
2512 h
->plt
.offset
= (bfd_vma
) -1;
2514 /* If this is a weak symbol, and there is a real definition, the
2515 processor independent code will have arranged for us to see the
2516 real definition first, and we can just use the same value. */
2517 if (h
->u
.weakdef
!= NULL
)
2519 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2520 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2521 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2522 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2523 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2525 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2526 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2527 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
2532 /* This is a reference to a symbol defined by a dynamic object which
2533 is not a function. */
2535 /* If we are creating a shared library, we must presume that the
2536 only references to the symbol are via the global offset table.
2537 For such cases we need not do anything here; the relocations will
2538 be handled correctly by relocate_section. */
2539 if (!bfd_link_executable (info
))
2542 /* If there are no references to this symbol that do not use the
2543 GOT, we don't need to generate a copy reloc. */
2544 if (!h
->non_got_ref
)
2547 /* If -z nocopyreloc was given, we won't generate them either. */
2548 if (info
->nocopyreloc
)
2554 if (ELIMINATE_COPY_RELOCS
)
2556 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2557 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2559 s
= p
->sec
->output_section
;
2560 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2564 /* If we didn't find any dynamic relocs in read-only sections, then
2565 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2573 /* We must allocate the symbol in our .dynbss section, which will
2574 become part of the .bss section of the executable. There will be
2575 an entry for this symbol in the .dynsym section. The dynamic
2576 object will contain position independent code, so all references
2577 from the dynamic object to this symbol will go through the global
2578 offset table. The dynamic linker will use the .dynsym entry to
2579 determine the address it must put in the global offset table, so
2580 both the dynamic object and the regular object will refer to the
2581 same memory location for the variable. */
2583 htab
= elf_x86_64_hash_table (info
);
2587 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2588 to copy the initial value out of the dynamic object and into the
2589 runtime process image. */
2590 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2592 const struct elf_backend_data
*bed
;
2593 bed
= get_elf_backend_data (info
->output_bfd
);
2594 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
2600 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2603 /* Allocate space in .plt, .got and associated reloc sections for
2607 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2609 struct bfd_link_info
*info
;
2610 struct elf_x86_64_link_hash_table
*htab
;
2611 struct elf_x86_64_link_hash_entry
*eh
;
2612 struct elf_dyn_relocs
*p
;
2613 const struct elf_backend_data
*bed
;
2614 unsigned int plt_entry_size
;
2615 bfd_boolean resolved_to_zero
;
2617 if (h
->root
.type
== bfd_link_hash_indirect
)
2620 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2622 info
= (struct bfd_link_info
*) inf
;
2623 htab
= elf_x86_64_hash_table (info
);
2626 bed
= get_elf_backend_data (info
->output_bfd
);
2627 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2629 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, eh
);
2631 /* We can't use the GOT PLT if pointer equality is needed since
2632 finish_dynamic_symbol won't clear symbol value and the dynamic
2633 linker won't update the GOT slot. We will get into an infinite
2634 loop at run-time. */
2635 if (htab
->plt_got
!= NULL
2636 && h
->type
!= STT_GNU_IFUNC
2637 && !h
->pointer_equality_needed
2638 && h
->plt
.refcount
> 0
2639 && h
->got
.refcount
> 0)
2641 /* Don't use the regular PLT if there are both GOT and GOTPLT
2643 h
->plt
.offset
= (bfd_vma
) -1;
2645 /* Use the GOT PLT. */
2646 eh
->plt_got
.refcount
= 1;
2649 /* Clear the reference count of function pointer relocations if
2650 symbol isn't a normal function. */
2651 if (h
->type
!= STT_FUNC
)
2652 eh
->func_pointer_refcount
= 0;
2654 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2655 here if it is defined and referenced in a non-shared object. */
2656 if (h
->type
== STT_GNU_IFUNC
2659 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
2665 asection
*s
= htab
->plt_bnd
;
2666 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
2668 /* Use the .plt.bnd section if it is created. */
2669 eh
->plt_bnd
.offset
= s
->size
;
2671 /* Make room for this entry in the .plt.bnd section. */
2672 s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2680 /* Don't create the PLT entry if there are only function pointer
2681 relocations which can be resolved at run-time. */
2682 else if (htab
->elf
.dynamic_sections_created
2683 && (h
->plt
.refcount
> eh
->func_pointer_refcount
2684 || eh
->plt_got
.refcount
> 0))
2686 bfd_boolean use_plt_got
;
2688 /* Clear the reference count of function pointer relocations
2690 eh
->func_pointer_refcount
= 0;
2692 if ((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2694 /* Don't use the regular PLT for DF_BIND_NOW. */
2695 h
->plt
.offset
= (bfd_vma
) -1;
2697 /* Use the GOT PLT. */
2698 h
->got
.refcount
= 1;
2699 eh
->plt_got
.refcount
= 1;
2702 use_plt_got
= eh
->plt_got
.refcount
> 0;
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 (bfd_link_pic (info
)
2715 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2717 asection
*s
= htab
->elf
.splt
;
2718 asection
*bnd_s
= htab
->plt_bnd
;
2719 asection
*got_s
= htab
->plt_got
;
2721 /* If this is the first .plt entry, make room for the special
2722 first entry. The .plt section is used by prelink to undo
2723 prelinking for dynamic relocations. */
2725 s
->size
= plt_entry_size
;
2728 eh
->plt_got
.offset
= got_s
->size
;
2731 h
->plt
.offset
= s
->size
;
2733 eh
->plt_bnd
.offset
= bnd_s
->size
;
2736 /* If this symbol is not defined in a regular file, and we are
2737 not generating a shared library, then set the symbol to this
2738 location in the .plt. This is required to make function
2739 pointers compare as equal between the normal executable and
2740 the shared library. */
2741 if (! bfd_link_pic (info
)
2746 /* We need to make a call to the entry of the GOT PLT
2747 instead of regular PLT entry. */
2748 h
->root
.u
.def
.section
= got_s
;
2749 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
2755 /* We need to make a call to the entry of the second
2756 PLT instead of regular PLT entry. */
2757 h
->root
.u
.def
.section
= bnd_s
;
2758 h
->root
.u
.def
.value
= eh
->plt_bnd
.offset
;
2762 h
->root
.u
.def
.section
= s
;
2763 h
->root
.u
.def
.value
= h
->plt
.offset
;
2768 /* Make room for this entry. */
2770 got_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2773 s
->size
+= plt_entry_size
;
2775 bnd_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2777 /* We also need to make an entry in the .got.plt section,
2778 which will be placed in the .got section by the linker
2780 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
2782 /* There should be no PLT relocation against resolved
2783 undefined weak symbol in executable. */
2784 if (!resolved_to_zero
)
2786 /* We also need to make an entry in the .rela.plt
2788 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2789 htab
->elf
.srelplt
->reloc_count
++;
2795 eh
->plt_got
.offset
= (bfd_vma
) -1;
2796 h
->plt
.offset
= (bfd_vma
) -1;
2802 eh
->plt_got
.offset
= (bfd_vma
) -1;
2803 h
->plt
.offset
= (bfd_vma
) -1;
2807 eh
->tlsdesc_got
= (bfd_vma
) -1;
2809 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2810 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2811 if (h
->got
.refcount
> 0
2812 && bfd_link_executable (info
)
2814 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
2816 h
->got
.offset
= (bfd_vma
) -1;
2818 else if (h
->got
.refcount
> 0)
2822 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
2824 /* Make sure this symbol is output as a dynamic symbol.
2825 Undefined weak syms won't yet be marked as dynamic. */
2826 if (h
->dynindx
== -1
2828 && !resolved_to_zero
)
2830 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2834 if (GOT_TLS_GDESC_P (tls_type
))
2836 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2837 - elf_x86_64_compute_jump_table_size (htab
);
2838 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2839 h
->got
.offset
= (bfd_vma
) -2;
2841 if (! GOT_TLS_GDESC_P (tls_type
)
2842 || GOT_TLS_GD_P (tls_type
))
2845 h
->got
.offset
= s
->size
;
2846 s
->size
+= GOT_ENTRY_SIZE
;
2847 if (GOT_TLS_GD_P (tls_type
))
2848 s
->size
+= GOT_ENTRY_SIZE
;
2850 dyn
= htab
->elf
.dynamic_sections_created
;
2851 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2852 and two if global. R_X86_64_GOTTPOFF needs one dynamic
2853 relocation. No dynamic relocation against resolved undefined
2854 weak symbol in executable. */
2855 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2856 || tls_type
== GOT_TLS_IE
)
2857 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2858 else if (GOT_TLS_GD_P (tls_type
))
2859 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
2860 else if (! GOT_TLS_GDESC_P (tls_type
)
2861 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2862 && !resolved_to_zero
)
2863 || h
->root
.type
!= bfd_link_hash_undefweak
)
2864 && (bfd_link_pic (info
)
2865 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2866 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2867 if (GOT_TLS_GDESC_P (tls_type
))
2869 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2870 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2874 h
->got
.offset
= (bfd_vma
) -1;
2876 if (eh
->dyn_relocs
== NULL
)
2879 /* In the shared -Bsymbolic case, discard space allocated for
2880 dynamic pc-relative relocs against symbols which turn out to be
2881 defined in regular objects. For the normal shared case, discard
2882 space for pc-relative relocs that have become local due to symbol
2883 visibility changes. */
2885 if (bfd_link_pic (info
))
2887 /* Relocs that use pc_count are those that appear on a call
2888 insn, or certain REL relocs that can generated via assembly.
2889 We want calls to protected symbols to resolve directly to the
2890 function rather than going via the plt. If people want
2891 function pointer comparisons to work as expected then they
2892 should avoid writing weird assembly. */
2893 if (SYMBOL_CALLS_LOCAL (info
, h
))
2895 struct elf_dyn_relocs
**pp
;
2897 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2899 p
->count
-= p
->pc_count
;
2908 /* Also discard relocs on undefined weak syms with non-default
2909 visibility or in PIE. */
2910 if (eh
->dyn_relocs
!= NULL
)
2912 if (h
->root
.type
== bfd_link_hash_undefweak
)
2914 /* Undefined weak symbol is never bound locally in shared
2916 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2917 || resolved_to_zero
)
2918 eh
->dyn_relocs
= NULL
;
2919 else if (h
->dynindx
== -1
2920 && ! h
->forced_local
2921 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2924 /* For PIE, discard space for pc-relative relocs against
2925 symbols which turn out to need copy relocs. */
2926 else if (bfd_link_executable (info
)
2927 && (h
->needs_copy
|| eh
->needs_copy
)
2931 struct elf_dyn_relocs
**pp
;
2933 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2935 if (p
->pc_count
!= 0)
2943 else if (ELIMINATE_COPY_RELOCS
)
2945 /* For the non-shared case, discard space for relocs against
2946 symbols which turn out to need copy relocs or are not
2947 dynamic. Keep dynamic relocations for run-time function
2948 pointer initialization. */
2950 if ((!h
->non_got_ref
2951 || eh
->func_pointer_refcount
> 0
2952 || (h
->root
.type
== bfd_link_hash_undefweak
2953 && !resolved_to_zero
))
2956 || (htab
->elf
.dynamic_sections_created
2957 && (h
->root
.type
== bfd_link_hash_undefweak
2958 || h
->root
.type
== bfd_link_hash_undefined
))))
2960 /* Make sure this symbol is output as a dynamic symbol.
2961 Undefined weak syms won't yet be marked as dynamic. */
2962 if (h
->dynindx
== -1
2963 && ! h
->forced_local
2964 && ! resolved_to_zero
2965 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2968 /* If that succeeded, we know we'll be keeping all the
2970 if (h
->dynindx
!= -1)
2974 eh
->dyn_relocs
= NULL
;
2975 eh
->func_pointer_refcount
= 0;
2980 /* Finally, allocate space. */
2981 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2985 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2987 BFD_ASSERT (sreloc
!= NULL
);
2989 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2995 /* Allocate space in .plt, .got and associated reloc sections for
2996 local dynamic relocs. */
2999 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
3001 struct elf_link_hash_entry
*h
3002 = (struct elf_link_hash_entry
*) *slot
;
3004 if (h
->type
!= STT_GNU_IFUNC
3008 || h
->root
.type
!= bfd_link_hash_defined
)
3011 return elf_x86_64_allocate_dynrelocs (h
, inf
);
3014 /* Find any dynamic relocs that apply to read-only sections. */
3017 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
3020 struct elf_x86_64_link_hash_entry
*eh
;
3021 struct elf_dyn_relocs
*p
;
3023 /* Skip local IFUNC symbols. */
3024 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
3027 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3028 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3030 asection
*s
= p
->sec
->output_section
;
3032 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
3034 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3036 info
->flags
|= DF_TEXTREL
;
3038 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3039 || info
->error_textrel
)
3040 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
3041 p
->sec
->owner
, h
->root
.root
.string
,
3044 /* Not an error, just cut short the traversal. */
3051 /* With the local symbol, foo, we convert
3052 mov foo@GOTPCREL(%rip), %reg
3056 call/jmp *foo@GOTPCREL(%rip)
3058 nop call foo/jmp foo nop
3059 When PIC is false, convert
3060 test %reg, foo@GOTPCREL(%rip)
3064 binop foo@GOTPCREL(%rip), %reg
3067 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
3071 elf_x86_64_convert_load (bfd
*abfd
, asection
*sec
,
3072 struct bfd_link_info
*link_info
)
3074 Elf_Internal_Shdr
*symtab_hdr
;
3075 Elf_Internal_Rela
*internal_relocs
;
3076 Elf_Internal_Rela
*irel
, *irelend
;
3078 struct elf_x86_64_link_hash_table
*htab
;
3079 bfd_boolean changed_contents
;
3080 bfd_boolean changed_relocs
;
3081 bfd_signed_vma
*local_got_refcounts
;
3082 bfd_vma maxpagesize
;
3084 bfd_boolean require_reloc_pc32
;
3086 /* Don't even try to convert non-ELF outputs. */
3087 if (!is_elf_hash_table (link_info
->hash
))
3090 /* Nothing to do if there is no need or no output. */
3091 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
3092 || sec
->need_convert_load
== 0
3093 || bfd_is_abs_section (sec
->output_section
))
3096 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3098 /* Load the relocations for this section. */
3099 internal_relocs
= (_bfd_elf_link_read_relocs
3100 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
3101 link_info
->keep_memory
));
3102 if (internal_relocs
== NULL
)
3105 htab
= elf_x86_64_hash_table (link_info
);
3106 changed_contents
= FALSE
;
3107 changed_relocs
= FALSE
;
3108 local_got_refcounts
= elf_local_got_refcounts (abfd
);
3109 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
3111 /* Get the section contents. */
3112 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
3113 contents
= elf_section_data (sec
)->this_hdr
.contents
;
3116 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
3120 is_pic
= bfd_link_pic (link_info
);
3122 /* TRUE if we can convert only to R_X86_64_PC32. Enable it for
3125 = link_info
->disable_target_specific_optimizations
> 1;
3127 irelend
= internal_relocs
+ sec
->reloc_count
;
3128 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3130 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
3131 unsigned int r_symndx
= htab
->r_sym (irel
->r_info
);
3133 struct elf_link_hash_entry
*h
;
3137 bfd_signed_vma raddend
;
3138 unsigned int opcode
;
3141 bfd_boolean to_reloc_pc32
;
3143 relocx
= (r_type
== R_X86_64_GOTPCRELX
3144 || r_type
== R_X86_64_REX_GOTPCRELX
);
3145 if (!relocx
&& r_type
!= R_X86_64_GOTPCREL
)
3148 roff
= irel
->r_offset
;
3149 if (roff
< (r_type
== R_X86_64_REX_GOTPCRELX
? 3 : 2))
3152 raddend
= irel
->r_addend
;
3153 /* Addend for 32-bit PC-relative relocation must be -4. */
3157 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
3159 /* Convert mov to lea since it has been done for a while. */
3162 /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
3163 for call, jmp or one of adc, add, and, cmp, or, sbb, sub,
3164 test, xor instructions. */
3169 /* We convert only to R_X86_64_PC32:
3171 2. R_X86_64_GOTPCREL since we can't modify REX byte.
3172 3. require_reloc_pc32 is true.
3175 to_reloc_pc32
= (opcode
== 0xff
3177 || require_reloc_pc32
3180 /* Get the symbol referred to by the reloc. */
3181 if (r_symndx
< symtab_hdr
->sh_info
)
3183 Elf_Internal_Sym
*isym
;
3185 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
3188 symtype
= ELF_ST_TYPE (isym
->st_info
);
3190 /* STT_GNU_IFUNC must keep GOTPCREL relocations and skip
3191 relocation against undefined symbols. */
3192 if (symtype
== STT_GNU_IFUNC
|| isym
->st_shndx
== SHN_UNDEF
)
3195 if (isym
->st_shndx
== SHN_ABS
)
3196 tsec
= bfd_abs_section_ptr
;
3197 else if (isym
->st_shndx
== SHN_COMMON
)
3198 tsec
= bfd_com_section_ptr
;
3199 else if (isym
->st_shndx
== SHN_X86_64_LCOMMON
)
3200 tsec
= &_bfd_elf_large_com_section
;
3202 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
3205 toff
= isym
->st_value
;
3209 indx
= r_symndx
- symtab_hdr
->sh_info
;
3210 h
= elf_sym_hashes (abfd
)[indx
];
3211 BFD_ASSERT (h
!= NULL
);
3213 while (h
->root
.type
== bfd_link_hash_indirect
3214 || h
->root
.type
== bfd_link_hash_warning
)
3215 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3217 /* STT_GNU_IFUNC must keep GOTPCREL relocations. We also
3218 avoid optimizing GOTPCREL relocations againt _DYNAMIC
3219 since ld.so may use its link-time address. */
3220 if (h
->type
== STT_GNU_IFUNC
)
3223 /* Undefined weak symbol is only bound locally in executable
3224 and its reference is resolved as 0 without relocation
3225 overflow. We can only perform this optimization for
3226 GOTPCRELX relocations since we need to modify REX byte.
3227 It is OK convert mov with R_X86_64_GOTPCREL to
3229 if ((relocx
|| opcode
== 0x8b)
3230 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
,
3231 elf_x86_64_hash_entry (h
)))
3235 /* Skip for branch instructions since R_X86_64_PC32
3237 if (require_reloc_pc32
)
3242 /* For non-branch instructions, we can convert to
3243 R_X86_64_32/R_X86_64_32S since we know if there
3245 to_reloc_pc32
= FALSE
;
3248 /* Since we don't know the current PC when PIC is true,
3249 we can't convert to R_X86_64_PC32. */
3250 if (to_reloc_pc32
&& is_pic
)
3255 else if ((h
->def_regular
3256 || h
->root
.type
== bfd_link_hash_defined
3257 || h
->root
.type
== bfd_link_hash_defweak
)
3258 && h
!= htab
->elf
.hdynamic
3259 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
3261 /* bfd_link_hash_new or bfd_link_hash_undefined is
3262 set by an assignment in a linker script in
3263 bfd_elf_record_link_assignment. */
3265 && (h
->root
.type
== bfd_link_hash_new
3266 || h
->root
.type
== bfd_link_hash_undefined
))
3268 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */
3269 if (require_reloc_pc32
)
3273 tsec
= h
->root
.u
.def
.section
;
3274 toff
= h
->root
.u
.def
.value
;
3281 /* We can only estimate relocation overflow for R_X86_64_PC32. */
3285 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
3287 /* At this stage in linking, no SEC_MERGE symbol has been
3288 adjusted, so all references to such symbols need to be
3289 passed through _bfd_merged_section_offset. (Later, in
3290 relocate_section, all SEC_MERGE symbols *except* for
3291 section symbols have been adjusted.)
3293 gas may reduce relocations against symbols in SEC_MERGE
3294 sections to a relocation against the section symbol when
3295 the original addend was zero. When the reloc is against
3296 a section symbol we should include the addend in the
3297 offset passed to _bfd_merged_section_offset, since the
3298 location of interest is the original symbol. On the
3299 other hand, an access to "sym+addend" where "sym" is not
3300 a section symbol should not include the addend; Such an
3301 access is presumed to be an offset from "sym"; The
3302 location of interest is just "sym". */
3303 if (symtype
== STT_SECTION
)
3306 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
3307 elf_section_data (tsec
)->sec_info
,
3310 if (symtype
!= STT_SECTION
)
3316 /* Don't convert if R_X86_64_PC32 relocation overflows. */
3317 if (tsec
->output_section
== sec
->output_section
)
3319 if ((toff
- roff
+ 0x80000000) > 0xffffffff)
3324 bfd_signed_vma distance
;
3326 /* At this point, we don't know the load addresses of TSEC
3327 section nor SEC section. We estimate the distrance between
3328 SEC and TSEC. We store the estimated distances in the
3329 compressed_size field of the output section, which is only
3330 used to decompress the compressed input section. */
3331 if (sec
->output_section
->compressed_size
== 0)
3334 bfd_size_type size
= 0;
3335 for (asect
= link_info
->output_bfd
->sections
;
3337 asect
= asect
->next
)
3340 for (i
= asect
->map_head
.s
;
3344 size
= align_power (size
, i
->alignment_power
);
3347 asect
->compressed_size
= size
;
3351 /* Don't convert GOTPCREL relocations if TSEC isn't placed
3353 distance
= (tsec
->output_section
->compressed_size
3354 - sec
->output_section
->compressed_size
);
3358 /* Take PT_GNU_RELRO segment into account by adding
3360 if ((toff
+ distance
+ maxpagesize
- roff
+ 0x80000000)
3368 /* We have "call/jmp *foo@GOTPCREL(%rip)". */
3373 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
3375 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
3378 /* Convert to "jmp foo nop". */
3381 nop_offset
= irel
->r_offset
+ 3;
3382 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
3383 irel
->r_offset
-= 1;
3384 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
3388 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
3391 nop
= link_info
->call_nop_byte
;
3392 if (link_info
->call_nop_as_suffix
)
3394 nop_offset
= irel
->r_offset
+ 3;
3395 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
3396 irel
->r_offset
-= 1;
3397 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
3400 nop_offset
= irel
->r_offset
- 2;
3402 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
3403 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
3404 r_type
= R_X86_64_PC32
;
3409 unsigned int rex_mask
= REX_R
;
3411 if (r_type
== R_X86_64_REX_GOTPCRELX
)
3412 rex
= bfd_get_8 (abfd
, contents
+ roff
- 3);
3420 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
3421 "lea foo(%rip), %reg". */
3423 r_type
= R_X86_64_PC32
;
3427 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
3428 "mov $foo, %reg". */
3430 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
3431 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
3432 if ((rex
& REX_W
) != 0
3433 && ABI_64_P (link_info
->output_bfd
))
3435 /* Keep the REX_W bit in REX byte for LP64. */
3436 r_type
= R_X86_64_32S
;
3437 goto rewrite_modrm_rex
;
3441 /* If the REX_W bit in REX byte isn't needed,
3442 use R_X86_64_32 and clear the W bit to avoid
3443 sign-extend imm32 to imm64. */
3444 r_type
= R_X86_64_32
;
3445 /* Clear the W bit in REX byte. */
3447 goto rewrite_modrm_rex
;
3453 /* R_X86_64_PC32 isn't supported. */
3457 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
3460 /* Convert "test %reg, foo@GOTPCREL(%rip)" to
3461 "test $foo, %reg". */
3462 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
3467 /* Convert "binop foo@GOTPCREL(%rip), %reg" to
3468 "binop $foo, %reg". */
3469 modrm
= 0xc0 | (modrm
& 0x38) >> 3 | (opcode
& 0x3c);
3473 /* Use R_X86_64_32 with 32-bit operand to avoid relocation
3474 overflow when sign-extending imm32 to imm64. */
3475 r_type
= (rex
& REX_W
) != 0 ? R_X86_64_32S
: R_X86_64_32
;
3478 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
3482 /* Move the R bit to the B bit in REX byte. */
3483 rex
= (rex
& ~rex_mask
) | (rex
& REX_R
) >> 2;
3484 bfd_put_8 (abfd
, rex
, contents
+ roff
- 3);
3487 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */
3491 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
3494 irel
->r_info
= htab
->r_info (r_symndx
, r_type
);
3495 changed_contents
= TRUE
;
3496 changed_relocs
= TRUE
;
3500 if (h
->got
.refcount
> 0)
3501 h
->got
.refcount
-= 1;
3505 if (local_got_refcounts
!= NULL
3506 && local_got_refcounts
[r_symndx
] > 0)
3507 local_got_refcounts
[r_symndx
] -= 1;
3511 if (contents
!= NULL
3512 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3514 if (!changed_contents
&& !link_info
->keep_memory
)
3518 /* Cache the section contents for elf_link_input_bfd. */
3519 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3523 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3525 if (!changed_relocs
)
3526 free (internal_relocs
);
3528 elf_section_data (sec
)->relocs
= internal_relocs
;
3534 if (contents
!= NULL
3535 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3537 if (internal_relocs
!= NULL
3538 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3539 free (internal_relocs
);
3543 /* Set the sizes of the dynamic sections. */
3546 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
3547 struct bfd_link_info
*info
)
3549 struct elf_x86_64_link_hash_table
*htab
;
3554 const struct elf_backend_data
*bed
;
3556 htab
= elf_x86_64_hash_table (info
);
3559 bed
= get_elf_backend_data (output_bfd
);
3561 dynobj
= htab
->elf
.dynobj
;
3565 if (htab
->elf
.dynamic_sections_created
)
3567 /* Set the contents of the .interp section to the interpreter. */
3568 if (bfd_link_executable (info
) && !info
->nointerp
)
3570 s
= bfd_get_linker_section (dynobj
, ".interp");
3573 s
->size
= htab
->dynamic_interpreter_size
;
3574 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
3579 /* Set up .got offsets for local syms, and space for local dynamic
3581 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3583 bfd_signed_vma
*local_got
;
3584 bfd_signed_vma
*end_local_got
;
3585 char *local_tls_type
;
3586 bfd_vma
*local_tlsdesc_gotent
;
3587 bfd_size_type locsymcount
;
3588 Elf_Internal_Shdr
*symtab_hdr
;
3591 if (! is_x86_64_elf (ibfd
))
3594 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3596 struct elf_dyn_relocs
*p
;
3598 if (!elf_x86_64_convert_load (ibfd
, s
, info
))
3601 for (p
= (struct elf_dyn_relocs
*)
3602 (elf_section_data (s
)->local_dynrel
);
3606 if (!bfd_is_abs_section (p
->sec
)
3607 && bfd_is_abs_section (p
->sec
->output_section
))
3609 /* Input section has been discarded, either because
3610 it is a copy of a linkonce section or due to
3611 linker script /DISCARD/, so we'll be discarding
3614 else if (p
->count
!= 0)
3616 srel
= elf_section_data (p
->sec
)->sreloc
;
3617 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3618 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3619 && (info
->flags
& DF_TEXTREL
) == 0)
3621 info
->flags
|= DF_TEXTREL
;
3622 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3623 || info
->error_textrel
)
3624 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3625 p
->sec
->owner
, p
->sec
);
3631 local_got
= elf_local_got_refcounts (ibfd
);
3635 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3636 locsymcount
= symtab_hdr
->sh_info
;
3637 end_local_got
= local_got
+ locsymcount
;
3638 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
3639 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
3641 srel
= htab
->elf
.srelgot
;
3642 for (; local_got
< end_local_got
;
3643 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3645 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3648 if (GOT_TLS_GDESC_P (*local_tls_type
))
3650 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3651 - elf_x86_64_compute_jump_table_size (htab
);
3652 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3653 *local_got
= (bfd_vma
) -2;
3655 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3656 || GOT_TLS_GD_P (*local_tls_type
))
3658 *local_got
= s
->size
;
3659 s
->size
+= GOT_ENTRY_SIZE
;
3660 if (GOT_TLS_GD_P (*local_tls_type
))
3661 s
->size
+= GOT_ENTRY_SIZE
;
3663 if (bfd_link_pic (info
)
3664 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3665 || *local_tls_type
== GOT_TLS_IE
)
3667 if (GOT_TLS_GDESC_P (*local_tls_type
))
3669 htab
->elf
.srelplt
->size
3670 += bed
->s
->sizeof_rela
;
3671 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3673 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3674 || GOT_TLS_GD_P (*local_tls_type
))
3675 srel
->size
+= bed
->s
->sizeof_rela
;
3679 *local_got
= (bfd_vma
) -1;
3683 if (htab
->tls_ld_got
.refcount
> 0)
3685 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3687 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
3688 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
3689 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3692 htab
->tls_ld_got
.offset
= -1;
3694 /* Allocate global sym .plt and .got entries, and space for global
3695 sym dynamic relocs. */
3696 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
3699 /* Allocate .plt and .got entries, and space for local symbols. */
3700 htab_traverse (htab
->loc_hash_table
,
3701 elf_x86_64_allocate_local_dynrelocs
,
3704 /* For every jump slot reserved in the sgotplt, reloc_count is
3705 incremented. However, when we reserve space for TLS descriptors,
3706 it's not incremented, so in order to compute the space reserved
3707 for them, it suffices to multiply the reloc count by the jump
3710 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3711 so that R_X86_64_IRELATIVE entries come last. */
3712 if (htab
->elf
.srelplt
)
3714 htab
->sgotplt_jump_table_size
3715 = elf_x86_64_compute_jump_table_size (htab
);
3716 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3718 else if (htab
->elf
.irelplt
)
3719 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3721 if (htab
->tlsdesc_plt
)
3723 /* If we're not using lazy TLS relocations, don't generate the
3724 PLT and GOT entries they require. */
3725 if ((info
->flags
& DF_BIND_NOW
))
3726 htab
->tlsdesc_plt
= 0;
3729 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
3730 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
3731 /* Reserve room for the initial entry.
3732 FIXME: we could probably do away with it in this case. */
3733 if (htab
->elf
.splt
->size
== 0)
3734 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3735 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
3736 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3740 if (htab
->elf
.sgotplt
)
3742 /* Don't allocate .got.plt section if there are no GOT nor PLT
3743 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3744 if ((htab
->elf
.hgot
== NULL
3745 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3746 && (htab
->elf
.sgotplt
->size
3747 == get_elf_backend_data (output_bfd
)->got_header_size
)
3748 && (htab
->elf
.splt
== NULL
3749 || htab
->elf
.splt
->size
== 0)
3750 && (htab
->elf
.sgot
== NULL
3751 || htab
->elf
.sgot
->size
== 0)
3752 && (htab
->elf
.iplt
== NULL
3753 || htab
->elf
.iplt
->size
== 0)
3754 && (htab
->elf
.igotplt
== NULL
3755 || htab
->elf
.igotplt
->size
== 0))
3756 htab
->elf
.sgotplt
->size
= 0;
3759 if (htab
->plt_eh_frame
!= NULL
3760 && htab
->elf
.splt
!= NULL
3761 && htab
->elf
.splt
->size
!= 0
3762 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3763 && _bfd_elf_eh_frame_present (info
))
3765 const struct elf_x86_64_backend_data
*arch_data
3766 = get_elf_x86_64_arch_data (bed
);
3767 htab
->plt_eh_frame
->size
= arch_data
->eh_frame_plt_size
;
3770 /* We now have determined the sizes of the various dynamic sections.
3771 Allocate memory for them. */
3773 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3775 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3778 if (s
== htab
->elf
.splt
3779 || s
== htab
->elf
.sgot
3780 || s
== htab
->elf
.sgotplt
3781 || s
== htab
->elf
.iplt
3782 || s
== htab
->elf
.igotplt
3783 || s
== htab
->plt_bnd
3784 || s
== htab
->plt_got
3785 || s
== htab
->plt_eh_frame
3786 || s
== htab
->sdynbss
)
3788 /* Strip this section if we don't need it; see the
3791 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3793 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
3796 /* We use the reloc_count field as a counter if we need
3797 to copy relocs into the output file. */
3798 if (s
!= htab
->elf
.srelplt
)
3803 /* It's not one of our sections, so don't allocate space. */
3809 /* If we don't need this section, strip it from the
3810 output file. This is mostly to handle .rela.bss and
3811 .rela.plt. We must create both sections in
3812 create_dynamic_sections, because they must be created
3813 before the linker maps input sections to output
3814 sections. The linker does that before
3815 adjust_dynamic_symbol is called, and it is that
3816 function which decides whether anything needs to go
3817 into these sections. */
3819 s
->flags
|= SEC_EXCLUDE
;
3823 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3826 /* Allocate memory for the section contents. We use bfd_zalloc
3827 here in case unused entries are not reclaimed before the
3828 section's contents are written out. This should not happen,
3829 but this way if it does, we get a R_X86_64_NONE reloc instead
3831 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3832 if (s
->contents
== NULL
)
3836 if (htab
->plt_eh_frame
!= NULL
3837 && htab
->plt_eh_frame
->contents
!= NULL
)
3839 const struct elf_x86_64_backend_data
*arch_data
3840 = get_elf_x86_64_arch_data (bed
);
3842 memcpy (htab
->plt_eh_frame
->contents
,
3843 arch_data
->eh_frame_plt
, htab
->plt_eh_frame
->size
);
3844 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3845 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3848 if (htab
->elf
.dynamic_sections_created
)
3850 /* Add some entries to the .dynamic section. We fill in the
3851 values later, in elf_x86_64_finish_dynamic_sections, but we
3852 must add the entries now so that we get the correct size for
3853 the .dynamic section. The DT_DEBUG entry is filled in by the
3854 dynamic linker and used by the debugger. */
3855 #define add_dynamic_entry(TAG, VAL) \
3856 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3858 if (bfd_link_executable (info
))
3860 if (!add_dynamic_entry (DT_DEBUG
, 0))
3864 if (htab
->elf
.splt
->size
!= 0)
3866 /* DT_PLTGOT is used by prelink even if there is no PLT
3868 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3871 if (htab
->elf
.srelplt
->size
!= 0)
3873 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3874 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3875 || !add_dynamic_entry (DT_JMPREL
, 0))
3879 if (htab
->tlsdesc_plt
3880 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3881 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3887 if (!add_dynamic_entry (DT_RELA
, 0)
3888 || !add_dynamic_entry (DT_RELASZ
, 0)
3889 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3892 /* If any dynamic relocs apply to a read-only section,
3893 then we need a DT_TEXTREL entry. */
3894 if ((info
->flags
& DF_TEXTREL
) == 0)
3895 elf_link_hash_traverse (&htab
->elf
,
3896 elf_x86_64_readonly_dynrelocs
,
3899 if ((info
->flags
& DF_TEXTREL
) != 0)
3901 if ((elf_tdata (output_bfd
)->has_gnu_symbols
3902 & elf_gnu_symbol_ifunc
) == elf_gnu_symbol_ifunc
)
3904 info
->callbacks
->einfo
3905 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3906 bfd_set_error (bfd_error_bad_value
);
3910 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3915 #undef add_dynamic_entry
3921 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3922 struct bfd_link_info
*info
)
3924 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3928 struct elf_link_hash_entry
*tlsbase
;
3930 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3931 "_TLS_MODULE_BASE_",
3932 FALSE
, FALSE
, FALSE
);
3934 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3936 struct elf_x86_64_link_hash_table
*htab
;
3937 struct bfd_link_hash_entry
*bh
= NULL
;
3938 const struct elf_backend_data
*bed
3939 = get_elf_backend_data (output_bfd
);
3941 htab
= elf_x86_64_hash_table (info
);
3945 if (!(_bfd_generic_link_add_one_symbol
3946 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3947 tls_sec
, 0, NULL
, FALSE
,
3948 bed
->collect
, &bh
)))
3951 htab
->tls_module_base
= bh
;
3953 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3954 tlsbase
->def_regular
= 1;
3955 tlsbase
->other
= STV_HIDDEN
;
3956 tlsbase
->root
.linker_def
= 1;
3957 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3964 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3965 executables. Rather than setting it to the beginning of the TLS
3966 section, we have to set it to the end. This function may be called
3967 multiple times, it is idempotent. */
3970 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
3972 struct elf_x86_64_link_hash_table
*htab
;
3973 struct bfd_link_hash_entry
*base
;
3975 if (!bfd_link_executable (info
))
3978 htab
= elf_x86_64_hash_table (info
);
3982 base
= htab
->tls_module_base
;
3986 base
->u
.def
.value
= htab
->elf
.tls_size
;
3989 /* Return the base VMA address which should be subtracted from real addresses
3990 when resolving @dtpoff relocation.
3991 This is PT_TLS segment p_vaddr. */
3994 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
3996 /* If tls_sec is NULL, we should have signalled an error already. */
3997 if (elf_hash_table (info
)->tls_sec
== NULL
)
3999 return elf_hash_table (info
)->tls_sec
->vma
;
4002 /* Return the relocation value for @tpoff relocation
4003 if STT_TLS virtual address is ADDRESS. */
4006 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
4008 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
4009 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
4010 bfd_vma static_tls_size
;
4012 /* If tls_segment is NULL, we should have signalled an error already. */
4013 if (htab
->tls_sec
== NULL
)
4016 /* Consider special static TLS alignment requirements. */
4017 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
4018 return address
- static_tls_size
- htab
->tls_sec
->vma
;
4021 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
4025 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
4027 /* Opcode Instruction
4030 0x0f 0x8x conditional jump */
4032 && (contents
[offset
- 1] == 0xe8
4033 || contents
[offset
- 1] == 0xe9))
4035 && contents
[offset
- 2] == 0x0f
4036 && (contents
[offset
- 1] & 0xf0) == 0x80));
4040 elf_x86_64_need_pic (bfd
*input_bfd
, struct elf_link_hash_entry
*h
,
4041 reloc_howto_type
*howto
)
4045 const char *pic
= "";
4047 switch (ELF_ST_VISIBILITY (h
->other
))
4050 v
= _("hidden symbol");
4053 v
= _("internal symbol");
4056 v
= _("protected symbol");
4060 pic
= _("; recompile with -fPIC");
4065 fmt
= _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
4067 fmt
= _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
4069 (*_bfd_error_handler
) (fmt
, input_bfd
, howto
->name
,
4070 v
, h
->root
.root
.string
, pic
);
4071 bfd_set_error (bfd_error_bad_value
);
4075 /* Relocate an x86_64 ELF section. */
4078 elf_x86_64_relocate_section (bfd
*output_bfd
,
4079 struct bfd_link_info
*info
,
4081 asection
*input_section
,
4083 Elf_Internal_Rela
*relocs
,
4084 Elf_Internal_Sym
*local_syms
,
4085 asection
**local_sections
)
4087 struct elf_x86_64_link_hash_table
*htab
;
4088 Elf_Internal_Shdr
*symtab_hdr
;
4089 struct elf_link_hash_entry
**sym_hashes
;
4090 bfd_vma
*local_got_offsets
;
4091 bfd_vma
*local_tlsdesc_gotents
;
4092 Elf_Internal_Rela
*rel
;
4093 Elf_Internal_Rela
*wrel
;
4094 Elf_Internal_Rela
*relend
;
4095 const unsigned int plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
4097 BFD_ASSERT (is_x86_64_elf (input_bfd
));
4099 htab
= elf_x86_64_hash_table (info
);
4102 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
4103 sym_hashes
= elf_sym_hashes (input_bfd
);
4104 local_got_offsets
= elf_local_got_offsets (input_bfd
);
4105 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
4107 elf_x86_64_set_tls_module_base (info
);
4109 rel
= wrel
= relocs
;
4110 relend
= relocs
+ input_section
->reloc_count
;
4111 for (; rel
< relend
; wrel
++, rel
++)
4113 unsigned int r_type
;
4114 reloc_howto_type
*howto
;
4115 unsigned long r_symndx
;
4116 struct elf_link_hash_entry
*h
;
4117 struct elf_x86_64_link_hash_entry
*eh
;
4118 Elf_Internal_Sym
*sym
;
4120 bfd_vma off
, offplt
, plt_offset
;
4122 bfd_boolean unresolved_reloc
;
4123 bfd_reloc_status_type r
;
4125 asection
*base_got
, *resolved_plt
;
4127 bfd_boolean resolved_to_zero
;
4129 r_type
= ELF32_R_TYPE (rel
->r_info
);
4130 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
4131 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
4138 if (r_type
>= (int) R_X86_64_standard
)
4140 (*_bfd_error_handler
)
4141 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
4142 input_bfd
, input_section
, r_type
);
4143 bfd_set_error (bfd_error_bad_value
);
4147 if (r_type
!= (int) R_X86_64_32
4148 || ABI_64_P (output_bfd
))
4149 howto
= x86_64_elf_howto_table
+ r_type
;
4151 howto
= (x86_64_elf_howto_table
4152 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
4153 r_symndx
= htab
->r_sym (rel
->r_info
);
4157 unresolved_reloc
= FALSE
;
4158 if (r_symndx
< symtab_hdr
->sh_info
)
4160 sym
= local_syms
+ r_symndx
;
4161 sec
= local_sections
[r_symndx
];
4163 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
4165 st_size
= sym
->st_size
;
4167 /* Relocate against local STT_GNU_IFUNC symbol. */
4168 if (!bfd_link_relocatable (info
)
4169 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
4171 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
4176 /* Set STT_GNU_IFUNC symbol value. */
4177 h
->root
.u
.def
.value
= sym
->st_value
;
4178 h
->root
.u
.def
.section
= sec
;
4183 bfd_boolean warned ATTRIBUTE_UNUSED
;
4184 bfd_boolean ignored ATTRIBUTE_UNUSED
;
4186 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
4187 r_symndx
, symtab_hdr
, sym_hashes
,
4189 unresolved_reloc
, warned
, ignored
);
4193 if (sec
!= NULL
&& discarded_section (sec
))
4195 _bfd_clear_contents (howto
, input_bfd
, input_section
,
4196 contents
+ rel
->r_offset
);
4197 wrel
->r_offset
= rel
->r_offset
;
4201 /* For ld -r, remove relocations in debug sections against
4202 sections defined in discarded sections. Not done for
4203 eh_frame editing code expects to be present. */
4204 if (bfd_link_relocatable (info
)
4205 && (input_section
->flags
& SEC_DEBUGGING
))
4211 if (bfd_link_relocatable (info
))
4218 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
4220 if (r_type
== R_X86_64_64
)
4222 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
4223 zero-extend it to 64bit if addend is zero. */
4224 r_type
= R_X86_64_32
;
4225 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4227 else if (r_type
== R_X86_64_SIZE64
)
4229 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
4230 zero-extend it to 64bit if addend is zero. */
4231 r_type
= R_X86_64_SIZE32
;
4232 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4236 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
4238 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
4239 it here if it is defined in a non-shared object. */
4241 && h
->type
== STT_GNU_IFUNC
4247 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4249 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4250 sections because such sections are not SEC_ALLOC and
4251 thus ld.so will not process them. */
4252 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
4256 else if (h
->plt
.offset
== (bfd_vma
) -1)
4259 /* STT_GNU_IFUNC symbol must go through PLT. */
4260 if (htab
->elf
.splt
!= NULL
)
4262 if (htab
->plt_bnd
!= NULL
)
4264 resolved_plt
= htab
->plt_bnd
;
4265 plt_offset
= eh
->plt_bnd
.offset
;
4269 resolved_plt
= htab
->elf
.splt
;
4270 plt_offset
= h
->plt
.offset
;
4275 resolved_plt
= htab
->elf
.iplt
;
4276 plt_offset
= h
->plt
.offset
;
4279 relocation
= (resolved_plt
->output_section
->vma
4280 + resolved_plt
->output_offset
+ plt_offset
);
4285 if (h
->root
.root
.string
)
4286 name
= h
->root
.root
.string
;
4288 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4290 (*_bfd_error_handler
)
4291 (_("%B: relocation %s against STT_GNU_IFUNC "
4292 "symbol `%s' isn't handled by %s"), input_bfd
,
4293 howto
->name
, name
, __FUNCTION__
);
4294 bfd_set_error (bfd_error_bad_value
);
4298 if (bfd_link_pic (info
))
4303 if (ABI_64_P (output_bfd
))
4307 if (rel
->r_addend
!= 0)
4309 if (h
->root
.root
.string
)
4310 name
= h
->root
.root
.string
;
4312 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4314 (*_bfd_error_handler
)
4315 (_("%B: relocation %s against STT_GNU_IFUNC "
4316 "symbol `%s' has non-zero addend: %d"),
4317 input_bfd
, howto
->name
, name
, rel
->r_addend
);
4318 bfd_set_error (bfd_error_bad_value
);
4322 /* Generate dynamic relcoation only when there is a
4323 non-GOT reference in a shared object. */
4324 if (bfd_link_pic (info
) && h
->non_got_ref
)
4326 Elf_Internal_Rela outrel
;
4329 /* Need a dynamic relocation to get the real function
4331 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
4335 if (outrel
.r_offset
== (bfd_vma
) -1
4336 || outrel
.r_offset
== (bfd_vma
) -2)
4339 outrel
.r_offset
+= (input_section
->output_section
->vma
4340 + input_section
->output_offset
);
4342 if (h
->dynindx
== -1
4344 || bfd_link_executable (info
))
4346 /* This symbol is resolved locally. */
4347 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4348 outrel
.r_addend
= (h
->root
.u
.def
.value
4349 + h
->root
.u
.def
.section
->output_section
->vma
4350 + h
->root
.u
.def
.section
->output_offset
);
4354 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4355 outrel
.r_addend
= 0;
4358 sreloc
= htab
->elf
.irelifunc
;
4359 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4361 /* If this reloc is against an external symbol, we
4362 do not want to fiddle with the addend. Otherwise,
4363 we need to include the symbol value so that it
4364 becomes an addend for the dynamic reloc. For an
4365 internal symbol, we have updated addend. */
4370 case R_X86_64_PC32_BND
:
4372 case R_X86_64_PLT32
:
4373 case R_X86_64_PLT32_BND
:
4376 case R_X86_64_GOTPCREL
:
4377 case R_X86_64_GOTPCRELX
:
4378 case R_X86_64_REX_GOTPCRELX
:
4379 case R_X86_64_GOTPCREL64
:
4380 base_got
= htab
->elf
.sgot
;
4381 off
= h
->got
.offset
;
4383 if (base_got
== NULL
)
4386 if (off
== (bfd_vma
) -1)
4388 /* We can't use h->got.offset here to save state, or
4389 even just remember the offset, as finish_dynamic_symbol
4390 would use that as offset into .got. */
4392 if (htab
->elf
.splt
!= NULL
)
4394 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4395 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4396 base_got
= htab
->elf
.sgotplt
;
4400 plt_index
= h
->plt
.offset
/ plt_entry_size
;
4401 off
= plt_index
* GOT_ENTRY_SIZE
;
4402 base_got
= htab
->elf
.igotplt
;
4405 if (h
->dynindx
== -1
4409 /* This references the local defitionion. We must
4410 initialize this entry in the global offset table.
4411 Since the offset must always be a multiple of 8,
4412 we use the least significant bit to record
4413 whether we have initialized it already.
4415 When doing a dynamic link, we create a .rela.got
4416 relocation entry to initialize the value. This
4417 is done in the finish_dynamic_symbol routine. */
4422 bfd_put_64 (output_bfd
, relocation
,
4423 base_got
->contents
+ off
);
4424 /* Note that this is harmless for the GOTPLT64
4425 case, as -1 | 1 still is -1. */
4431 relocation
= (base_got
->output_section
->vma
4432 + base_got
->output_offset
+ off
);
4438 resolved_to_zero
= (eh
!= NULL
4439 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, eh
));
4441 /* When generating a shared object, the relocations handled here are
4442 copied into the output file to be resolved at run time. */
4445 case R_X86_64_GOT32
:
4446 case R_X86_64_GOT64
:
4447 /* Relocation is to the entry for this symbol in the global
4449 case R_X86_64_GOTPCREL
:
4450 case R_X86_64_GOTPCRELX
:
4451 case R_X86_64_REX_GOTPCRELX
:
4452 case R_X86_64_GOTPCREL64
:
4453 /* Use global offset table entry as symbol value. */
4454 case R_X86_64_GOTPLT64
:
4455 /* This is obsolete and treated the the same as GOT64. */
4456 base_got
= htab
->elf
.sgot
;
4458 if (htab
->elf
.sgot
== NULL
)
4465 off
= h
->got
.offset
;
4467 && h
->plt
.offset
!= (bfd_vma
)-1
4468 && off
== (bfd_vma
)-1)
4470 /* We can't use h->got.offset here to save
4471 state, or even just remember the offset, as
4472 finish_dynamic_symbol would use that as offset into
4474 bfd_vma plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4475 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4476 base_got
= htab
->elf
.sgotplt
;
4479 dyn
= htab
->elf
.dynamic_sections_created
;
4481 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
4482 || (bfd_link_pic (info
)
4483 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4484 || (ELF_ST_VISIBILITY (h
->other
)
4485 && h
->root
.type
== bfd_link_hash_undefweak
))
4487 /* This is actually a static link, or it is a -Bsymbolic
4488 link and the symbol is defined locally, or the symbol
4489 was forced to be local because of a version file. We
4490 must initialize this entry in the global offset table.
4491 Since the offset must always be a multiple of 8, we
4492 use the least significant bit to record whether we
4493 have initialized it already.
4495 When doing a dynamic link, we create a .rela.got
4496 relocation entry to initialize the value. This is
4497 done in the finish_dynamic_symbol routine. */
4502 bfd_put_64 (output_bfd
, relocation
,
4503 base_got
->contents
+ off
);
4504 /* Note that this is harmless for the GOTPLT64 case,
4505 as -1 | 1 still is -1. */
4510 unresolved_reloc
= FALSE
;
4514 if (local_got_offsets
== NULL
)
4517 off
= local_got_offsets
[r_symndx
];
4519 /* The offset must always be a multiple of 8. We use
4520 the least significant bit to record whether we have
4521 already generated the necessary reloc. */
4526 bfd_put_64 (output_bfd
, relocation
,
4527 base_got
->contents
+ off
);
4529 if (bfd_link_pic (info
))
4532 Elf_Internal_Rela outrel
;
4534 /* We need to generate a R_X86_64_RELATIVE reloc
4535 for the dynamic linker. */
4536 s
= htab
->elf
.srelgot
;
4540 outrel
.r_offset
= (base_got
->output_section
->vma
4541 + base_got
->output_offset
4543 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4544 outrel
.r_addend
= relocation
;
4545 elf_append_rela (output_bfd
, s
, &outrel
);
4548 local_got_offsets
[r_symndx
] |= 1;
4552 if (off
>= (bfd_vma
) -2)
4555 relocation
= base_got
->output_section
->vma
4556 + base_got
->output_offset
+ off
;
4557 if (r_type
!= R_X86_64_GOTPCREL
4558 && r_type
!= R_X86_64_GOTPCRELX
4559 && r_type
!= R_X86_64_REX_GOTPCRELX
4560 && r_type
!= R_X86_64_GOTPCREL64
)
4561 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4562 - htab
->elf
.sgotplt
->output_offset
;
4566 case R_X86_64_GOTOFF64
:
4567 /* Relocation is relative to the start of the global offset
4570 /* Check to make sure it isn't a protected function or data
4571 symbol for shared library since it may not be local when
4572 used as function address or with copy relocation. We also
4573 need to make sure that a symbol is referenced locally. */
4574 if (bfd_link_pic (info
) && h
)
4576 if (!h
->def_regular
)
4580 switch (ELF_ST_VISIBILITY (h
->other
))
4583 v
= _("hidden symbol");
4586 v
= _("internal symbol");
4589 v
= _("protected symbol");
4596 (*_bfd_error_handler
)
4597 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s `%s' can not be used when making a shared object"),
4598 input_bfd
, v
, h
->root
.root
.string
);
4599 bfd_set_error (bfd_error_bad_value
);
4602 else if (!bfd_link_executable (info
)
4603 && !SYMBOL_REFERENCES_LOCAL (info
, h
)
4604 && (h
->type
== STT_FUNC
4605 || h
->type
== STT_OBJECT
)
4606 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4608 (*_bfd_error_handler
)
4609 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s `%s' can not be used when making a shared object"),
4611 h
->type
== STT_FUNC
? "function" : "data",
4612 h
->root
.root
.string
);
4613 bfd_set_error (bfd_error_bad_value
);
4618 /* Note that sgot is not involved in this
4619 calculation. We always want the start of .got.plt. If we
4620 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4621 permitted by the ABI, we might have to change this
4623 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4624 + htab
->elf
.sgotplt
->output_offset
;
4627 case R_X86_64_GOTPC32
:
4628 case R_X86_64_GOTPC64
:
4629 /* Use global offset table as symbol value. */
4630 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4631 + htab
->elf
.sgotplt
->output_offset
;
4632 unresolved_reloc
= FALSE
;
4635 case R_X86_64_PLTOFF64
:
4636 /* Relocation is PLT entry relative to GOT. For local
4637 symbols it's the symbol itself relative to GOT. */
4639 /* See PLT32 handling. */
4640 && h
->plt
.offset
!= (bfd_vma
) -1
4641 && htab
->elf
.splt
!= NULL
)
4643 if (htab
->plt_bnd
!= NULL
)
4645 resolved_plt
= htab
->plt_bnd
;
4646 plt_offset
= eh
->plt_bnd
.offset
;
4650 resolved_plt
= htab
->elf
.splt
;
4651 plt_offset
= h
->plt
.offset
;
4654 relocation
= (resolved_plt
->output_section
->vma
4655 + resolved_plt
->output_offset
4657 unresolved_reloc
= FALSE
;
4660 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4661 + htab
->elf
.sgotplt
->output_offset
;
4664 case R_X86_64_PLT32
:
4665 case R_X86_64_PLT32_BND
:
4666 /* Relocation is to the entry for this symbol in the
4667 procedure linkage table. */
4669 /* Resolve a PLT32 reloc against a local symbol directly,
4670 without using the procedure linkage table. */
4674 if ((h
->plt
.offset
== (bfd_vma
) -1
4675 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4676 || htab
->elf
.splt
== NULL
)
4678 /* We didn't make a PLT entry for this symbol. This
4679 happens when statically linking PIC code, or when
4680 using -Bsymbolic. */
4684 if (h
->plt
.offset
!= (bfd_vma
) -1)
4686 if (htab
->plt_bnd
!= NULL
)
4688 resolved_plt
= htab
->plt_bnd
;
4689 plt_offset
= eh
->plt_bnd
.offset
;
4693 resolved_plt
= htab
->elf
.splt
;
4694 plt_offset
= h
->plt
.offset
;
4699 /* Use the GOT PLT. */
4700 resolved_plt
= htab
->plt_got
;
4701 plt_offset
= eh
->plt_got
.offset
;
4704 relocation
= (resolved_plt
->output_section
->vma
4705 + resolved_plt
->output_offset
4707 unresolved_reloc
= FALSE
;
4710 case R_X86_64_SIZE32
:
4711 case R_X86_64_SIZE64
:
4712 /* Set to symbol size. */
4713 relocation
= st_size
;
4719 case R_X86_64_PC32_BND
:
4720 /* Don't complain about -fPIC if the symbol is undefined when
4721 building executable unless it is unresolved weak symbol. */
4722 if ((input_section
->flags
& SEC_ALLOC
) != 0
4723 && (input_section
->flags
& SEC_READONLY
) != 0
4725 && ((bfd_link_executable (info
)
4726 && h
->root
.type
== bfd_link_hash_undefweak
4727 && !resolved_to_zero
)
4728 || (bfd_link_pic (info
)
4729 && !(bfd_link_pie (info
)
4730 && h
->root
.type
== bfd_link_hash_undefined
))))
4732 bfd_boolean fail
= FALSE
;
4734 = ((r_type
== R_X86_64_PC32
4735 || r_type
== R_X86_64_PC32_BND
)
4736 && is_32bit_relative_branch (contents
, rel
->r_offset
));
4738 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
4740 /* Symbol is referenced locally. Make sure it is
4741 defined locally or for a branch. */
4742 fail
= !h
->def_regular
&& !branch
;
4744 else if (!(bfd_link_pie (info
)
4745 && (h
->needs_copy
|| eh
->needs_copy
)))
4747 /* Symbol doesn't need copy reloc and isn't referenced
4748 locally. We only allow branch to symbol with
4749 non-default visibility. */
4751 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
4755 return elf_x86_64_need_pic (input_bfd
, h
, howto
);
4764 /* FIXME: The ABI says the linker should make sure the value is
4765 the same when it's zeroextended to 64 bit. */
4768 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4771 /* Don't copy a pc-relative relocation into the output file
4772 if the symbol needs copy reloc or the symbol is undefined
4773 when building executable. Copy dynamic function pointer
4774 relocations. Don't generate dynamic relocations against
4775 resolved undefined weak symbols in PIE. */
4776 if ((bfd_link_pic (info
)
4777 && !(bfd_link_pie (info
)
4781 || h
->root
.type
== bfd_link_hash_undefined
)
4782 && IS_X86_64_PCREL_TYPE (r_type
))
4784 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4785 && !resolved_to_zero
)
4786 || h
->root
.type
!= bfd_link_hash_undefweak
))
4787 && ((! IS_X86_64_PCREL_TYPE (r_type
)
4788 && r_type
!= R_X86_64_SIZE32
4789 && r_type
!= R_X86_64_SIZE64
)
4790 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
4791 || (ELIMINATE_COPY_RELOCS
4792 && !bfd_link_pic (info
)
4796 || eh
->func_pointer_refcount
> 0
4797 || (h
->root
.type
== bfd_link_hash_undefweak
4798 && !resolved_to_zero
))
4799 && ((h
->def_dynamic
&& !h
->def_regular
)
4800 /* Undefined weak symbol is bound locally when
4802 || h
->root
.type
== bfd_link_hash_undefined
)))
4804 Elf_Internal_Rela outrel
;
4805 bfd_boolean skip
, relocate
;
4808 /* When generating a shared object, these relocations
4809 are copied into the output file to be resolved at run
4815 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4817 if (outrel
.r_offset
== (bfd_vma
) -1)
4819 else if (outrel
.r_offset
== (bfd_vma
) -2)
4820 skip
= TRUE
, relocate
= TRUE
;
4822 outrel
.r_offset
+= (input_section
->output_section
->vma
4823 + input_section
->output_offset
);
4826 memset (&outrel
, 0, sizeof outrel
);
4828 /* h->dynindx may be -1 if this symbol was marked to
4832 && (IS_X86_64_PCREL_TYPE (r_type
)
4833 || ! bfd_link_pic (info
)
4834 || ! SYMBOLIC_BIND (info
, h
)
4835 || ! h
->def_regular
))
4837 if ((r_type
!= R_X86_64_PC64
&& r_type
!= R_X86_64_64
)
4838 && bfd_link_executable (info
)
4839 && h
->root
.type
== bfd_link_hash_undefweak
4840 && !resolved_to_zero
)
4841 return elf_x86_64_need_pic (input_bfd
, h
, howto
);
4842 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4843 outrel
.r_addend
= rel
->r_addend
;
4847 /* This symbol is local, or marked to become local.
4848 When relocation overflow check is disabled, we
4849 convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */
4850 if (r_type
== htab
->pointer_r_type
4851 || (r_type
== R_X86_64_32
4852 && info
->no_reloc_overflow_check
))
4855 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4856 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4858 else if (r_type
== R_X86_64_64
4859 && !ABI_64_P (output_bfd
))
4862 outrel
.r_info
= htab
->r_info (0,
4863 R_X86_64_RELATIVE64
);
4864 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4865 /* Check addend overflow. */
4866 if ((outrel
.r_addend
& 0x80000000)
4867 != (rel
->r_addend
& 0x80000000))
4870 int addend
= rel
->r_addend
;
4871 if (h
&& h
->root
.root
.string
)
4872 name
= h
->root
.root
.string
;
4874 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4877 (*_bfd_error_handler
)
4878 (_("%B: addend -0x%x in relocation %s against "
4879 "symbol `%s' at 0x%lx in section `%A' is "
4881 input_bfd
, input_section
, addend
,
4883 (unsigned long) rel
->r_offset
);
4885 (*_bfd_error_handler
)
4886 (_("%B: addend 0x%x in relocation %s against "
4887 "symbol `%s' at 0x%lx in section `%A' is "
4889 input_bfd
, input_section
, addend
,
4891 (unsigned long) rel
->r_offset
);
4892 bfd_set_error (bfd_error_bad_value
);
4900 if (bfd_is_abs_section (sec
))
4902 else if (sec
== NULL
|| sec
->owner
== NULL
)
4904 bfd_set_error (bfd_error_bad_value
);
4911 /* We are turning this relocation into one
4912 against a section symbol. It would be
4913 proper to subtract the symbol's value,
4914 osec->vma, from the emitted reloc addend,
4915 but ld.so expects buggy relocs. */
4916 osec
= sec
->output_section
;
4917 sindx
= elf_section_data (osec
)->dynindx
;
4920 asection
*oi
= htab
->elf
.text_index_section
;
4921 sindx
= elf_section_data (oi
)->dynindx
;
4923 BFD_ASSERT (sindx
!= 0);
4926 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
4927 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4931 sreloc
= elf_section_data (input_section
)->sreloc
;
4933 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4935 r
= bfd_reloc_notsupported
;
4936 goto check_relocation_error
;
4939 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4941 /* If this reloc is against an external symbol, we do
4942 not want to fiddle with the addend. Otherwise, we
4943 need to include the symbol value so that it becomes
4944 an addend for the dynamic reloc. */
4951 case R_X86_64_TLSGD
:
4952 case R_X86_64_GOTPC32_TLSDESC
:
4953 case R_X86_64_TLSDESC_CALL
:
4954 case R_X86_64_GOTTPOFF
:
4955 tls_type
= GOT_UNKNOWN
;
4956 if (h
== NULL
&& local_got_offsets
)
4957 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
4959 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
4961 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4962 input_section
, contents
,
4963 symtab_hdr
, sym_hashes
,
4964 &r_type
, tls_type
, rel
,
4965 relend
, h
, r_symndx
))
4968 if (r_type
== R_X86_64_TPOFF32
)
4970 bfd_vma roff
= rel
->r_offset
;
4972 BFD_ASSERT (! unresolved_reloc
);
4974 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4976 /* GD->LE transition. For 64bit, change
4977 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4978 .word 0x6666; rex64; call __tls_get_addr
4981 leaq foo@tpoff(%rax), %rax
4983 leaq foo@tlsgd(%rip), %rdi
4984 .word 0x6666; rex64; call __tls_get_addr
4987 leaq foo@tpoff(%rax), %rax
4988 For largepic, change:
4989 leaq foo@tlsgd(%rip), %rdi
4990 movabsq $__tls_get_addr@pltoff, %rax
4995 leaq foo@tpoff(%rax), %rax
4996 nopw 0x0(%rax,%rax,1) */
4998 if (ABI_64_P (output_bfd
)
4999 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
5001 memcpy (contents
+ roff
- 3,
5002 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
5003 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5006 else if (ABI_64_P (output_bfd
))
5007 memcpy (contents
+ roff
- 4,
5008 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5011 memcpy (contents
+ roff
- 3,
5012 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5014 bfd_put_32 (output_bfd
,
5015 elf_x86_64_tpoff (info
, relocation
),
5016 contents
+ roff
+ 8 + largepic
);
5017 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5022 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5024 /* GDesc -> LE transition.
5025 It's originally something like:
5026 leaq x@tlsdesc(%rip), %rax
5029 movl $x@tpoff, %rax. */
5031 unsigned int val
, type
;
5033 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5034 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5035 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
5036 contents
+ roff
- 3);
5037 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
5038 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
5039 contents
+ roff
- 1);
5040 bfd_put_32 (output_bfd
,
5041 elf_x86_64_tpoff (info
, relocation
),
5045 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5047 /* GDesc -> LE transition.
5052 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5053 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5056 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
5058 /* IE->LE transition:
5059 For 64bit, originally it can be one of:
5060 movq foo@gottpoff(%rip), %reg
5061 addq foo@gottpoff(%rip), %reg
5064 leaq foo(%reg), %reg
5066 For 32bit, originally it can be one of:
5067 movq foo@gottpoff(%rip), %reg
5068 addl foo@gottpoff(%rip), %reg
5071 leal foo(%reg), %reg
5074 unsigned int val
, type
, reg
;
5077 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5080 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
5081 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5087 bfd_put_8 (output_bfd
, 0x49,
5088 contents
+ roff
- 3);
5089 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5090 bfd_put_8 (output_bfd
, 0x41,
5091 contents
+ roff
- 3);
5092 bfd_put_8 (output_bfd
, 0xc7,
5093 contents
+ roff
- 2);
5094 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5095 contents
+ roff
- 1);
5099 /* addq/addl -> addq/addl - addressing with %rsp/%r12
5102 bfd_put_8 (output_bfd
, 0x49,
5103 contents
+ roff
- 3);
5104 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5105 bfd_put_8 (output_bfd
, 0x41,
5106 contents
+ roff
- 3);
5107 bfd_put_8 (output_bfd
, 0x81,
5108 contents
+ roff
- 2);
5109 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5110 contents
+ roff
- 1);
5114 /* addq/addl -> leaq/leal */
5116 bfd_put_8 (output_bfd
, 0x4d,
5117 contents
+ roff
- 3);
5118 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5119 bfd_put_8 (output_bfd
, 0x45,
5120 contents
+ roff
- 3);
5121 bfd_put_8 (output_bfd
, 0x8d,
5122 contents
+ roff
- 2);
5123 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
5124 contents
+ roff
- 1);
5126 bfd_put_32 (output_bfd
,
5127 elf_x86_64_tpoff (info
, relocation
),
5135 if (htab
->elf
.sgot
== NULL
)
5140 off
= h
->got
.offset
;
5141 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
5145 if (local_got_offsets
== NULL
)
5148 off
= local_got_offsets
[r_symndx
];
5149 offplt
= local_tlsdesc_gotents
[r_symndx
];
5156 Elf_Internal_Rela outrel
;
5160 if (htab
->elf
.srelgot
== NULL
)
5163 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
5165 if (GOT_TLS_GDESC_P (tls_type
))
5167 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
5168 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
5169 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
5170 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5171 + htab
->elf
.sgotplt
->output_offset
5173 + htab
->sgotplt_jump_table_size
);
5174 sreloc
= htab
->elf
.srelplt
;
5176 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5178 outrel
.r_addend
= 0;
5179 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5182 sreloc
= htab
->elf
.srelgot
;
5184 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5185 + htab
->elf
.sgot
->output_offset
+ off
);
5187 if (GOT_TLS_GD_P (tls_type
))
5188 dr_type
= R_X86_64_DTPMOD64
;
5189 else if (GOT_TLS_GDESC_P (tls_type
))
5192 dr_type
= R_X86_64_TPOFF64
;
5194 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
5195 outrel
.r_addend
= 0;
5196 if ((dr_type
== R_X86_64_TPOFF64
5197 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
5198 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5199 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
5201 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5203 if (GOT_TLS_GD_P (tls_type
))
5207 BFD_ASSERT (! unresolved_reloc
);
5208 bfd_put_64 (output_bfd
,
5209 relocation
- elf_x86_64_dtpoff_base (info
),
5210 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5214 bfd_put_64 (output_bfd
, 0,
5215 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5216 outrel
.r_info
= htab
->r_info (indx
,
5218 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
5219 elf_append_rela (output_bfd
, sreloc
,
5228 local_got_offsets
[r_symndx
] |= 1;
5231 if (off
>= (bfd_vma
) -2
5232 && ! GOT_TLS_GDESC_P (tls_type
))
5234 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
5236 if (r_type
== R_X86_64_GOTPC32_TLSDESC
5237 || r_type
== R_X86_64_TLSDESC_CALL
)
5238 relocation
= htab
->elf
.sgotplt
->output_section
->vma
5239 + htab
->elf
.sgotplt
->output_offset
5240 + offplt
+ htab
->sgotplt_jump_table_size
;
5242 relocation
= htab
->elf
.sgot
->output_section
->vma
5243 + htab
->elf
.sgot
->output_offset
+ off
;
5244 unresolved_reloc
= FALSE
;
5248 bfd_vma roff
= rel
->r_offset
;
5250 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5252 /* GD->IE transition. For 64bit, change
5253 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5254 .word 0x6666; rex64; call __tls_get_addr@plt
5257 addq foo@gottpoff(%rip), %rax
5259 leaq foo@tlsgd(%rip), %rdi
5260 .word 0x6666; rex64; call __tls_get_addr@plt
5263 addq foo@gottpoff(%rip), %rax
5264 For largepic, change:
5265 leaq foo@tlsgd(%rip), %rdi
5266 movabsq $__tls_get_addr@pltoff, %rax
5271 addq foo@gottpoff(%rax), %rax
5272 nopw 0x0(%rax,%rax,1) */
5274 if (ABI_64_P (output_bfd
)
5275 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
5277 memcpy (contents
+ roff
- 3,
5278 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
5279 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5282 else if (ABI_64_P (output_bfd
))
5283 memcpy (contents
+ roff
- 4,
5284 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5287 memcpy (contents
+ roff
- 3,
5288 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5291 relocation
= (htab
->elf
.sgot
->output_section
->vma
5292 + htab
->elf
.sgot
->output_offset
+ off
5295 - input_section
->output_section
->vma
5296 - input_section
->output_offset
5298 bfd_put_32 (output_bfd
, relocation
,
5299 contents
+ roff
+ 8 + largepic
);
5300 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5305 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5307 /* GDesc -> IE transition.
5308 It's originally something like:
5309 leaq x@tlsdesc(%rip), %rax
5312 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
5314 /* Now modify the instruction as appropriate. To
5315 turn a leaq into a movq in the form we use it, it
5316 suffices to change the second byte from 0x8d to
5318 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
5320 bfd_put_32 (output_bfd
,
5321 htab
->elf
.sgot
->output_section
->vma
5322 + htab
->elf
.sgot
->output_offset
+ off
5324 - input_section
->output_section
->vma
5325 - input_section
->output_offset
5330 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5332 /* GDesc -> IE transition.
5339 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5340 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5348 case R_X86_64_TLSLD
:
5349 if (! elf_x86_64_tls_transition (info
, input_bfd
,
5350 input_section
, contents
,
5351 symtab_hdr
, sym_hashes
,
5352 &r_type
, GOT_UNKNOWN
,
5353 rel
, relend
, h
, r_symndx
))
5356 if (r_type
!= R_X86_64_TLSLD
)
5358 /* LD->LE transition:
5359 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
5360 For 64bit, we change it into:
5361 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
5362 For 32bit, we change it into:
5363 nopl 0x0(%rax); movl %fs:0, %eax.
5364 For largepic, change:
5365 leaq foo@tlsgd(%rip), %rdi
5366 movabsq $__tls_get_addr@pltoff, %rax
5370 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
5373 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
5374 if (ABI_64_P (output_bfd
)
5375 && contents
[rel
->r_offset
+ 5] == (bfd_byte
) '\xb8')
5376 memcpy (contents
+ rel
->r_offset
- 3,
5377 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
5378 "\x64\x48\x8b\x04\x25\0\0\0", 22);
5379 else if (ABI_64_P (output_bfd
))
5380 memcpy (contents
+ rel
->r_offset
- 3,
5381 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
5383 memcpy (contents
+ rel
->r_offset
- 3,
5384 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
5385 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5391 if (htab
->elf
.sgot
== NULL
)
5394 off
= htab
->tls_ld_got
.offset
;
5399 Elf_Internal_Rela outrel
;
5401 if (htab
->elf
.srelgot
== NULL
)
5404 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5405 + htab
->elf
.sgot
->output_offset
+ off
);
5407 bfd_put_64 (output_bfd
, 0,
5408 htab
->elf
.sgot
->contents
+ off
);
5409 bfd_put_64 (output_bfd
, 0,
5410 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5411 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
5412 outrel
.r_addend
= 0;
5413 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
5415 htab
->tls_ld_got
.offset
|= 1;
5417 relocation
= htab
->elf
.sgot
->output_section
->vma
5418 + htab
->elf
.sgot
->output_offset
+ off
;
5419 unresolved_reloc
= FALSE
;
5422 case R_X86_64_DTPOFF32
:
5423 if (!bfd_link_executable (info
)
5424 || (input_section
->flags
& SEC_CODE
) == 0)
5425 relocation
-= elf_x86_64_dtpoff_base (info
);
5427 relocation
= elf_x86_64_tpoff (info
, relocation
);
5430 case R_X86_64_TPOFF32
:
5431 case R_X86_64_TPOFF64
:
5432 BFD_ASSERT (bfd_link_executable (info
));
5433 relocation
= elf_x86_64_tpoff (info
, relocation
);
5436 case R_X86_64_DTPOFF64
:
5437 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
5438 relocation
-= elf_x86_64_dtpoff_base (info
);
5445 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5446 because such sections are not SEC_ALLOC and thus ld.so will
5447 not process them. */
5448 if (unresolved_reloc
5449 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
5451 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5452 rel
->r_offset
) != (bfd_vma
) -1)
5454 (*_bfd_error_handler
)
5455 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5458 (long) rel
->r_offset
,
5460 h
->root
.root
.string
);
5465 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5466 contents
, rel
->r_offset
,
5467 relocation
, rel
->r_addend
);
5469 check_relocation_error
:
5470 if (r
!= bfd_reloc_ok
)
5475 name
= h
->root
.root
.string
;
5478 name
= bfd_elf_string_from_elf_section (input_bfd
,
5479 symtab_hdr
->sh_link
,
5484 name
= bfd_section_name (input_bfd
, sec
);
5487 if (r
== bfd_reloc_overflow
)
5489 if (! ((*info
->callbacks
->reloc_overflow
)
5490 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5491 (bfd_vma
) 0, input_bfd
, input_section
,
5497 (*_bfd_error_handler
)
5498 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5499 input_bfd
, input_section
,
5500 (long) rel
->r_offset
, name
, (int) r
);
5511 Elf_Internal_Shdr
*rel_hdr
;
5512 size_t deleted
= rel
- wrel
;
5514 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
5515 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5516 if (rel_hdr
->sh_size
== 0)
5518 /* It is too late to remove an empty reloc section. Leave
5520 ??? What is wrong with an empty section??? */
5521 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
5524 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5525 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5526 input_section
->reloc_count
-= deleted
;
5532 /* Finish up dynamic symbol handling. We set the contents of various
5533 dynamic sections here. */
5536 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
5537 struct bfd_link_info
*info
,
5538 struct elf_link_hash_entry
*h
,
5539 Elf_Internal_Sym
*sym
)
5541 struct elf_x86_64_link_hash_table
*htab
;
5542 const struct elf_x86_64_backend_data
*abed
;
5543 bfd_boolean use_plt_bnd
;
5544 struct elf_x86_64_link_hash_entry
*eh
;
5545 bfd_boolean local_undefweak
;
5547 htab
= elf_x86_64_hash_table (info
);
5551 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5552 section only if there is .plt section. */
5553 use_plt_bnd
= htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
;
5555 ? &elf_x86_64_bnd_arch_bed
5556 : get_elf_x86_64_backend_data (output_bfd
));
5558 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
5560 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5561 resolved undefined weak symbols in executable so that their
5562 references have value 0 at run-time. */
5563 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, eh
);
5565 if (h
->plt
.offset
!= (bfd_vma
) -1)
5568 bfd_vma got_offset
, plt_offset
, plt_plt_offset
, plt_got_offset
;
5569 bfd_vma plt_plt_insn_end
, plt_got_insn_size
;
5570 Elf_Internal_Rela rela
;
5572 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
5573 const struct elf_backend_data
*bed
;
5574 bfd_vma plt_got_pcrel_offset
;
5576 /* When building a static executable, use .iplt, .igot.plt and
5577 .rela.iplt sections for STT_GNU_IFUNC symbols. */
5578 if (htab
->elf
.splt
!= NULL
)
5580 plt
= htab
->elf
.splt
;
5581 gotplt
= htab
->elf
.sgotplt
;
5582 relplt
= htab
->elf
.srelplt
;
5586 plt
= htab
->elf
.iplt
;
5587 gotplt
= htab
->elf
.igotplt
;
5588 relplt
= htab
->elf
.irelplt
;
5591 /* This symbol has an entry in the procedure linkage table. Set
5593 if ((h
->dynindx
== -1
5595 && !((h
->forced_local
|| bfd_link_executable (info
))
5597 && h
->type
== STT_GNU_IFUNC
))
5603 /* Get the index in the procedure linkage table which
5604 corresponds to this symbol. This is the index of this symbol
5605 in all the symbols for which we are making plt entries. The
5606 first entry in the procedure linkage table is reserved.
5608 Get the offset into the .got table of the entry that
5609 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
5610 bytes. The first three are reserved for the dynamic linker.
5612 For static executables, we don't reserve anything. */
5614 if (plt
== htab
->elf
.splt
)
5616 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
5617 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
5621 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
5622 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
5625 plt_plt_insn_end
= abed
->plt_plt_insn_end
;
5626 plt_plt_offset
= abed
->plt_plt_offset
;
5627 plt_got_insn_size
= abed
->plt_got_insn_size
;
5628 plt_got_offset
= abed
->plt_got_offset
;
5631 /* Use the second PLT with BND relocations. */
5632 const bfd_byte
*plt_entry
, *plt2_entry
;
5634 if (eh
->has_bnd_reloc
)
5636 plt_entry
= elf_x86_64_bnd_plt_entry
;
5637 plt2_entry
= elf_x86_64_bnd_plt2_entry
;
5641 plt_entry
= elf_x86_64_legacy_plt_entry
;
5642 plt2_entry
= elf_x86_64_legacy_plt2_entry
;
5644 /* Subtract 1 since there is no BND prefix. */
5645 plt_plt_insn_end
-= 1;
5646 plt_plt_offset
-= 1;
5647 plt_got_insn_size
-= 1;
5648 plt_got_offset
-= 1;
5651 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry
)
5652 == sizeof (elf_x86_64_legacy_plt_entry
));
5654 /* Fill in the entry in the procedure linkage table. */
5655 memcpy (plt
->contents
+ h
->plt
.offset
,
5656 plt_entry
, sizeof (elf_x86_64_legacy_plt_entry
));
5657 /* Fill in the entry in the second PLT. */
5658 memcpy (htab
->plt_bnd
->contents
+ eh
->plt_bnd
.offset
,
5659 plt2_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5661 resolved_plt
= htab
->plt_bnd
;
5662 plt_offset
= eh
->plt_bnd
.offset
;
5666 /* Fill in the entry in the procedure linkage table. */
5667 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
5668 abed
->plt_entry_size
);
5671 plt_offset
= h
->plt
.offset
;
5674 /* Insert the relocation positions of the plt section. */
5676 /* Put offset the PC-relative instruction referring to the GOT entry,
5677 subtracting the size of that instruction. */
5678 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
5679 + gotplt
->output_offset
5681 - resolved_plt
->output_section
->vma
5682 - resolved_plt
->output_offset
5684 - plt_got_insn_size
);
5686 /* Check PC-relative offset overflow in PLT entry. */
5687 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
5688 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5689 output_bfd
, h
->root
.root
.string
);
5691 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
5692 resolved_plt
->contents
+ plt_offset
+ plt_got_offset
);
5694 /* Fill in the entry in the global offset table, initially this
5695 points to the second part of the PLT entry. Leave the entry
5696 as zero for undefined weak symbol in PIE. No PLT relocation
5697 against undefined weak symbol in PIE. */
5698 if (!local_undefweak
)
5700 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5701 + plt
->output_offset
5703 + abed
->plt_lazy_offset
),
5704 gotplt
->contents
+ got_offset
);
5706 /* Fill in the entry in the .rela.plt section. */
5707 rela
.r_offset
= (gotplt
->output_section
->vma
5708 + gotplt
->output_offset
5710 if (h
->dynindx
== -1
5711 || ((bfd_link_executable (info
)
5712 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5714 && h
->type
== STT_GNU_IFUNC
))
5716 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5717 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
5718 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
5719 rela
.r_addend
= (h
->root
.u
.def
.value
5720 + h
->root
.u
.def
.section
->output_section
->vma
5721 + h
->root
.u
.def
.section
->output_offset
);
5722 /* R_X86_64_IRELATIVE comes last. */
5723 plt_index
= htab
->next_irelative_index
--;
5727 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
5729 plt_index
= htab
->next_jump_slot_index
++;
5732 /* Don't fill PLT entry for static executables. */
5733 if (plt
== htab
->elf
.splt
)
5735 bfd_vma plt0_offset
= h
->plt
.offset
+ plt_plt_insn_end
;
5737 /* Put relocation index. */
5738 bfd_put_32 (output_bfd
, plt_index
,
5739 (plt
->contents
+ h
->plt
.offset
5740 + abed
->plt_reloc_offset
));
5742 /* Put offset for jmp .PLT0 and check for overflow. We don't
5743 check relocation index for overflow since branch displacement
5744 will overflow first. */
5745 if (plt0_offset
> 0x80000000)
5746 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5747 output_bfd
, h
->root
.root
.string
);
5748 bfd_put_32 (output_bfd
, - plt0_offset
,
5749 plt
->contents
+ h
->plt
.offset
+ plt_plt_offset
);
5752 bed
= get_elf_backend_data (output_bfd
);
5753 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
5754 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
5757 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5759 bfd_vma got_offset
, plt_offset
, plt_got_offset
, plt_got_insn_size
;
5760 asection
*plt
, *got
;
5761 bfd_boolean got_after_plt
;
5762 int32_t got_pcrel_offset
;
5763 const bfd_byte
*got_plt_entry
;
5765 /* Set the entry in the GOT procedure linkage table. */
5766 plt
= htab
->plt_got
;
5767 got
= htab
->elf
.sgot
;
5768 got_offset
= h
->got
.offset
;
5770 if (got_offset
== (bfd_vma
) -1
5771 || h
->type
== STT_GNU_IFUNC
5776 /* Use the second PLT entry template for the GOT PLT since they
5777 are the identical. */
5778 plt_got_insn_size
= elf_x86_64_bnd_arch_bed
.plt_got_insn_size
;
5779 plt_got_offset
= elf_x86_64_bnd_arch_bed
.plt_got_offset
;
5780 if (eh
->has_bnd_reloc
)
5781 got_plt_entry
= elf_x86_64_bnd_plt2_entry
;
5784 got_plt_entry
= elf_x86_64_legacy_plt2_entry
;
5786 /* Subtract 1 since there is no BND prefix. */
5787 plt_got_insn_size
-= 1;
5788 plt_got_offset
-= 1;
5791 /* Fill in the entry in the GOT procedure linkage table. */
5792 plt_offset
= eh
->plt_got
.offset
;
5793 memcpy (plt
->contents
+ plt_offset
,
5794 got_plt_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5796 /* Put offset the PC-relative instruction referring to the GOT
5797 entry, subtracting the size of that instruction. */
5798 got_pcrel_offset
= (got
->output_section
->vma
5799 + got
->output_offset
5801 - plt
->output_section
->vma
5802 - plt
->output_offset
5804 - plt_got_insn_size
);
5806 /* Check PC-relative offset overflow in GOT PLT entry. */
5807 got_after_plt
= got
->output_section
->vma
> plt
->output_section
->vma
;
5808 if ((got_after_plt
&& got_pcrel_offset
< 0)
5809 || (!got_after_plt
&& got_pcrel_offset
> 0))
5810 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
5811 output_bfd
, h
->root
.root
.string
);
5813 bfd_put_32 (output_bfd
, got_pcrel_offset
,
5814 plt
->contents
+ plt_offset
+ plt_got_offset
);
5817 if (!local_undefweak
5819 && (h
->plt
.offset
!= (bfd_vma
) -1
5820 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5822 /* Mark the symbol as undefined, rather than as defined in
5823 the .plt section. Leave the value if there were any
5824 relocations where pointer equality matters (this is a clue
5825 for the dynamic linker, to make function pointer
5826 comparisons work between an application and shared
5827 library), otherwise set it to zero. If a function is only
5828 called from a binary, there is no need to slow down
5829 shared libraries because of that. */
5830 sym
->st_shndx
= SHN_UNDEF
;
5831 if (!h
->pointer_equality_needed
)
5835 /* Don't generate dynamic GOT relocation against undefined weak
5836 symbol in executable. */
5837 if (h
->got
.offset
!= (bfd_vma
) -1
5838 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
5839 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
5840 && !local_undefweak
)
5842 Elf_Internal_Rela rela
;
5844 /* This symbol has an entry in the global offset table. Set it
5846 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5849 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5850 + htab
->elf
.sgot
->output_offset
5851 + (h
->got
.offset
&~ (bfd_vma
) 1));
5853 /* If this is a static link, or it is a -Bsymbolic link and the
5854 symbol is defined locally or was forced to be local because
5855 of a version file, we just want to emit a RELATIVE reloc.
5856 The entry in the global offset table will already have been
5857 initialized in the relocate_section function. */
5859 && h
->type
== STT_GNU_IFUNC
)
5861 if (bfd_link_pic (info
))
5863 /* Generate R_X86_64_GLOB_DAT. */
5870 if (!h
->pointer_equality_needed
)
5873 /* For non-shared object, we can't use .got.plt, which
5874 contains the real function addres if we need pointer
5875 equality. We load the GOT entry with the PLT entry. */
5876 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5877 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5878 + plt
->output_offset
5880 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5884 else if (bfd_link_pic (info
)
5885 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5887 if (!h
->def_regular
)
5889 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5890 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
5891 rela
.r_addend
= (h
->root
.u
.def
.value
5892 + h
->root
.u
.def
.section
->output_section
->vma
5893 + h
->root
.u
.def
.section
->output_offset
);
5897 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5899 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5900 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5901 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
5905 elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &rela
);
5910 Elf_Internal_Rela rela
;
5912 /* This symbol needs a copy reloc. Set it up. */
5914 if (h
->dynindx
== -1
5915 || (h
->root
.type
!= bfd_link_hash_defined
5916 && h
->root
.type
!= bfd_link_hash_defweak
)
5917 || htab
->srelbss
== NULL
)
5920 rela
.r_offset
= (h
->root
.u
.def
.value
5921 + h
->root
.u
.def
.section
->output_section
->vma
5922 + h
->root
.u
.def
.section
->output_offset
);
5923 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
5925 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
5931 /* Finish up local dynamic symbol handling. We set the contents of
5932 various dynamic sections here. */
5935 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
5937 struct elf_link_hash_entry
*h
5938 = (struct elf_link_hash_entry
*) *slot
;
5939 struct bfd_link_info
*info
5940 = (struct bfd_link_info
*) inf
;
5942 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5946 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5947 here since undefined weak symbol may not be dynamic and may not be
5948 called for elf_x86_64_finish_dynamic_symbol. */
5951 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
5954 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
5955 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5957 if (h
->root
.type
!= bfd_link_hash_undefweak
5958 || h
->dynindx
!= -1)
5961 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5965 /* Used to decide how to sort relocs in an optimal manner for the
5966 dynamic linker, before writing them out. */
5968 static enum elf_reloc_type_class
5969 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info
,
5970 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5971 const Elf_Internal_Rela
*rela
)
5973 bfd
*abfd
= info
->output_bfd
;
5974 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5975 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
5977 if (htab
->elf
.dynsym
!= NULL
5978 && htab
->elf
.dynsym
->contents
!= NULL
)
5980 /* Check relocation against STT_GNU_IFUNC symbol if there are
5982 unsigned long r_symndx
= htab
->r_sym (rela
->r_info
);
5983 Elf_Internal_Sym sym
;
5984 if (!bed
->s
->swap_symbol_in (abfd
,
5985 (htab
->elf
.dynsym
->contents
5986 + r_symndx
* bed
->s
->sizeof_sym
),
5990 if (ELF_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
5991 return reloc_class_ifunc
;
5994 switch ((int) ELF32_R_TYPE (rela
->r_info
))
5996 case R_X86_64_RELATIVE
:
5997 case R_X86_64_RELATIVE64
:
5998 return reloc_class_relative
;
5999 case R_X86_64_JUMP_SLOT
:
6000 return reloc_class_plt
;
6002 return reloc_class_copy
;
6004 return reloc_class_normal
;
6008 /* Finish up the dynamic sections. */
6011 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
6012 struct bfd_link_info
*info
)
6014 struct elf_x86_64_link_hash_table
*htab
;
6017 const struct elf_x86_64_backend_data
*abed
;
6019 htab
= elf_x86_64_hash_table (info
);
6023 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
6024 section only if there is .plt section. */
6025 abed
= (htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
6026 ? &elf_x86_64_bnd_arch_bed
6027 : get_elf_x86_64_backend_data (output_bfd
));
6029 dynobj
= htab
->elf
.dynobj
;
6030 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
6032 if (htab
->elf
.dynamic_sections_created
)
6034 bfd_byte
*dyncon
, *dynconend
;
6035 const struct elf_backend_data
*bed
;
6036 bfd_size_type sizeof_dyn
;
6038 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
6041 bed
= get_elf_backend_data (dynobj
);
6042 sizeof_dyn
= bed
->s
->sizeof_dyn
;
6043 dyncon
= sdyn
->contents
;
6044 dynconend
= sdyn
->contents
+ sdyn
->size
;
6045 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
6047 Elf_Internal_Dyn dyn
;
6050 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
6058 s
= htab
->elf
.sgotplt
;
6059 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
6063 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
6067 s
= htab
->elf
.srelplt
->output_section
;
6068 dyn
.d_un
.d_val
= s
->size
;
6072 /* The procedure linkage table relocs (DT_JMPREL) should
6073 not be included in the overall relocs (DT_RELA).
6074 Therefore, we override the DT_RELASZ entry here to
6075 make it not include the JMPREL relocs. Since the
6076 linker script arranges for .rela.plt to follow all
6077 other relocation sections, we don't have to worry
6078 about changing the DT_RELA entry. */
6079 if (htab
->elf
.srelplt
!= NULL
)
6081 s
= htab
->elf
.srelplt
->output_section
;
6082 dyn
.d_un
.d_val
-= s
->size
;
6086 case DT_TLSDESC_PLT
:
6088 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6089 + htab
->tlsdesc_plt
;
6092 case DT_TLSDESC_GOT
:
6094 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6095 + htab
->tlsdesc_got
;
6099 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
6102 /* Fill in the special first entry in the procedure linkage table. */
6103 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
6105 /* Fill in the first entry in the procedure linkage table. */
6106 memcpy (htab
->elf
.splt
->contents
,
6107 abed
->plt0_entry
, abed
->plt_entry_size
);
6108 /* Add offset for pushq GOT+8(%rip), since the instruction
6109 uses 6 bytes subtract this value. */
6110 bfd_put_32 (output_bfd
,
6111 (htab
->elf
.sgotplt
->output_section
->vma
6112 + htab
->elf
.sgotplt
->output_offset
6114 - htab
->elf
.splt
->output_section
->vma
6115 - htab
->elf
.splt
->output_offset
6117 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
6118 /* Add offset for the PC-relative instruction accessing GOT+16,
6119 subtracting the offset to the end of that instruction. */
6120 bfd_put_32 (output_bfd
,
6121 (htab
->elf
.sgotplt
->output_section
->vma
6122 + htab
->elf
.sgotplt
->output_offset
6124 - htab
->elf
.splt
->output_section
->vma
6125 - htab
->elf
.splt
->output_offset
6126 - abed
->plt0_got2_insn_end
),
6127 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
6129 elf_section_data (htab
->elf
.splt
->output_section
)
6130 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
6132 if (htab
->tlsdesc_plt
)
6134 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6135 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
6137 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
6138 abed
->plt0_entry
, abed
->plt_entry_size
);
6140 /* Add offset for pushq GOT+8(%rip), since the
6141 instruction uses 6 bytes subtract this value. */
6142 bfd_put_32 (output_bfd
,
6143 (htab
->elf
.sgotplt
->output_section
->vma
6144 + htab
->elf
.sgotplt
->output_offset
6146 - htab
->elf
.splt
->output_section
->vma
6147 - htab
->elf
.splt
->output_offset
6150 htab
->elf
.splt
->contents
6151 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
6152 /* Add offset for the PC-relative instruction accessing GOT+TDG,
6153 where TGD stands for htab->tlsdesc_got, subtracting the offset
6154 to the end of that instruction. */
6155 bfd_put_32 (output_bfd
,
6156 (htab
->elf
.sgot
->output_section
->vma
6157 + htab
->elf
.sgot
->output_offset
6159 - htab
->elf
.splt
->output_section
->vma
6160 - htab
->elf
.splt
->output_offset
6162 - abed
->plt0_got2_insn_end
),
6163 htab
->elf
.splt
->contents
6164 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
6169 if (htab
->plt_bnd
!= NULL
)
6170 elf_section_data (htab
->plt_bnd
->output_section
)
6171 ->this_hdr
.sh_entsize
= sizeof (elf_x86_64_bnd_plt2_entry
);
6173 if (htab
->elf
.sgotplt
)
6175 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
6177 (*_bfd_error_handler
)
6178 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
6182 /* Fill in the first three entries in the global offset table. */
6183 if (htab
->elf
.sgotplt
->size
> 0)
6185 /* Set the first entry in the global offset table to the address of
6186 the dynamic section. */
6188 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
6190 bfd_put_64 (output_bfd
,
6191 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
6192 htab
->elf
.sgotplt
->contents
);
6193 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
6194 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
6195 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
6198 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
6202 /* Adjust .eh_frame for .plt section. */
6203 if (htab
->plt_eh_frame
!= NULL
6204 && htab
->plt_eh_frame
->contents
!= NULL
)
6206 if (htab
->elf
.splt
!= NULL
6207 && htab
->elf
.splt
->size
!= 0
6208 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
6209 && htab
->elf
.splt
->output_section
!= NULL
6210 && htab
->plt_eh_frame
->output_section
!= NULL
)
6212 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
6213 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
6214 + htab
->plt_eh_frame
->output_offset
6215 + PLT_FDE_START_OFFSET
;
6216 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6217 htab
->plt_eh_frame
->contents
6218 + PLT_FDE_START_OFFSET
);
6220 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
6222 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6224 htab
->plt_eh_frame
->contents
))
6229 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
6230 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
6233 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
6234 htab_traverse (htab
->loc_hash_table
,
6235 elf_x86_64_finish_local_dynamic_symbol
,
6238 /* Fill PLT entries for undefined weak symbols in PIE. */
6239 if (bfd_link_pie (info
))
6240 bfd_hash_traverse (&info
->hash
->table
,
6241 elf_x86_64_pie_finish_undefweak_symbol
,
6247 /* Return an array of PLT entry symbol values. */
6250 elf_x86_64_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
6253 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
6256 bfd_vma
*plt_sym_val
;
6258 bfd_byte
*plt_contents
;
6259 const struct elf_x86_64_backend_data
*bed
;
6260 Elf_Internal_Shdr
*hdr
;
6263 /* Get the .plt section contents. PLT passed down may point to the
6264 .plt.bnd section. Make sure that PLT always points to the .plt
6266 plt_bnd
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6271 plt
= bfd_get_section_by_name (abfd
, ".plt");
6274 bed
= &elf_x86_64_bnd_arch_bed
;
6277 bed
= get_elf_x86_64_backend_data (abfd
);
6279 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
6280 if (plt_contents
== NULL
)
6282 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
6283 plt_contents
, 0, plt
->size
))
6286 free (plt_contents
);
6290 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
6291 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
6294 hdr
= &elf_section_data (relplt
)->this_hdr
;
6295 count
= relplt
->size
/ hdr
->sh_entsize
;
6297 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
6298 if (plt_sym_val
== NULL
)
6301 for (i
= 0; i
< count
; i
++)
6302 plt_sym_val
[i
] = -1;
6304 plt_offset
= bed
->plt_entry_size
;
6305 p
= relplt
->relocation
;
6306 for (i
= 0; i
< count
; i
++, p
++)
6310 /* Skip unknown relocation. */
6311 if (p
->howto
== NULL
)
6314 if (p
->howto
->type
!= R_X86_64_JUMP_SLOT
6315 && p
->howto
->type
!= R_X86_64_IRELATIVE
)
6318 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
6319 + bed
->plt_reloc_offset
));
6320 if (reloc_index
< count
)
6324 /* This is the index in .plt section. */
6325 long plt_index
= plt_offset
/ bed
->plt_entry_size
;
6326 /* Store VMA + the offset in .plt.bnd section. */
6327 plt_sym_val
[reloc_index
] =
6329 + (plt_index
- 1) * sizeof (elf_x86_64_legacy_plt2_entry
));
6332 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
6334 plt_offset
+= bed
->plt_entry_size
;
6336 /* PR binutils/18437: Skip extra relocations in the .rela.plt
6338 if (plt_offset
>= plt
->size
)
6342 free (plt_contents
);
6347 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
6351 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
6358 /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
6359 as PLT if it exists. */
6360 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6362 plt
= bfd_get_section_by_name (abfd
, ".plt");
6363 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
6364 dynsymcount
, dynsyms
, ret
,
6366 elf_x86_64_get_plt_sym_val
);
6369 /* Handle an x86-64 specific section when reading an object file. This
6370 is called when elfcode.h finds a section with an unknown type. */
6373 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
6374 const char *name
, int shindex
)
6376 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
6379 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
6385 /* Hook called by the linker routine which adds symbols from an object
6386 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
6390 elf_x86_64_add_symbol_hook (bfd
*abfd
,
6391 struct bfd_link_info
*info
,
6392 Elf_Internal_Sym
*sym
,
6393 const char **namep ATTRIBUTE_UNUSED
,
6394 flagword
*flagsp ATTRIBUTE_UNUSED
,
6400 switch (sym
->st_shndx
)
6402 case SHN_X86_64_LCOMMON
:
6403 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
6406 lcomm
= bfd_make_section_with_flags (abfd
,
6410 | SEC_LINKER_CREATED
));
6413 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
6416 *valp
= sym
->st_size
;
6420 if (ELF_ST_BIND (sym
->st_info
) == STB_GNU_UNIQUE
6421 && (abfd
->flags
& DYNAMIC
) == 0
6422 && bfd_get_flavour (info
->output_bfd
) == bfd_target_elf_flavour
)
6423 elf_tdata (info
->output_bfd
)->has_gnu_symbols
6424 |= elf_gnu_symbol_unique
;
6430 /* Given a BFD section, try to locate the corresponding ELF section
6434 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
6435 asection
*sec
, int *index_return
)
6437 if (sec
== &_bfd_elf_large_com_section
)
6439 *index_return
= SHN_X86_64_LCOMMON
;
6445 /* Process a symbol. */
6448 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
6451 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
6453 switch (elfsym
->internal_elf_sym
.st_shndx
)
6455 case SHN_X86_64_LCOMMON
:
6456 asym
->section
= &_bfd_elf_large_com_section
;
6457 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
6458 /* Common symbol doesn't set BSF_GLOBAL. */
6459 asym
->flags
&= ~BSF_GLOBAL
;
6465 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
6467 return (sym
->st_shndx
== SHN_COMMON
6468 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
6472 elf_x86_64_common_section_index (asection
*sec
)
6474 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6477 return SHN_X86_64_LCOMMON
;
6481 elf_x86_64_common_section (asection
*sec
)
6483 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6484 return bfd_com_section_ptr
;
6486 return &_bfd_elf_large_com_section
;
6490 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
6491 const Elf_Internal_Sym
*sym
,
6496 const asection
*oldsec
)
6498 /* A normal common symbol and a large common symbol result in a
6499 normal common symbol. We turn the large common symbol into a
6502 && h
->root
.type
== bfd_link_hash_common
6504 && bfd_is_com_section (*psec
)
6507 if (sym
->st_shndx
== SHN_COMMON
6508 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
6510 h
->root
.u
.c
.p
->section
6511 = bfd_make_section_old_way (oldbfd
, "COMMON");
6512 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
6514 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
6515 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
6516 *psec
= bfd_com_section_ptr
;
6523 elf_x86_64_additional_program_headers (bfd
*abfd
,
6524 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6529 /* Check to see if we need a large readonly segment. */
6530 s
= bfd_get_section_by_name (abfd
, ".lrodata");
6531 if (s
&& (s
->flags
& SEC_LOAD
))
6534 /* Check to see if we need a large data segment. Since .lbss sections
6535 is placed right after the .bss section, there should be no need for
6536 a large data segment just because of .lbss. */
6537 s
= bfd_get_section_by_name (abfd
, ".ldata");
6538 if (s
&& (s
->flags
& SEC_LOAD
))
6544 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6547 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
6549 if (h
->plt
.offset
!= (bfd_vma
) -1
6551 && !h
->pointer_equality_needed
)
6554 return _bfd_elf_hash_symbol (h
);
6557 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
6560 elf_x86_64_relocs_compatible (const bfd_target
*input
,
6561 const bfd_target
*output
)
6563 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
6564 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
6565 && _bfd_elf_relocs_compatible (input
, output
));
6568 static const struct bfd_elf_special_section
6569 elf_x86_64_special_sections
[]=
6571 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6572 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6573 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
6574 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6575 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6576 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6577 { NULL
, 0, 0, 0, 0 }
6580 #define TARGET_LITTLE_SYM x86_64_elf64_vec
6581 #define TARGET_LITTLE_NAME "elf64-x86-64"
6582 #define ELF_ARCH bfd_arch_i386
6583 #define ELF_TARGET_ID X86_64_ELF_DATA
6584 #define ELF_MACHINE_CODE EM_X86_64
6585 #define ELF_MAXPAGESIZE 0x200000
6586 #define ELF_MINPAGESIZE 0x1000
6587 #define ELF_COMMONPAGESIZE 0x1000
6589 #define elf_backend_can_gc_sections 1
6590 #define elf_backend_can_refcount 1
6591 #define elf_backend_want_got_plt 1
6592 #define elf_backend_plt_readonly 1
6593 #define elf_backend_want_plt_sym 0
6594 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
6595 #define elf_backend_rela_normal 1
6596 #define elf_backend_plt_alignment 4
6597 #define elf_backend_extern_protected_data 1
6599 #define elf_info_to_howto elf_x86_64_info_to_howto
6601 #define bfd_elf64_bfd_link_hash_table_create \
6602 elf_x86_64_link_hash_table_create
6603 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
6604 #define bfd_elf64_bfd_reloc_name_lookup \
6605 elf_x86_64_reloc_name_lookup
6607 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
6608 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
6609 #define elf_backend_check_relocs elf_x86_64_check_relocs
6610 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
6611 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
6612 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
6613 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
6614 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
6615 #define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
6616 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
6617 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
6619 #define elf_backend_write_core_note elf_x86_64_write_core_note
6621 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
6622 #define elf_backend_relocate_section elf_x86_64_relocate_section
6623 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
6624 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
6625 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
6626 #define elf_backend_object_p elf64_x86_64_elf_object_p
6627 #define bfd_elf64_mkobject elf_x86_64_mkobject
6628 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
6630 #define elf_backend_section_from_shdr \
6631 elf_x86_64_section_from_shdr
6633 #define elf_backend_section_from_bfd_section \
6634 elf_x86_64_elf_section_from_bfd_section
6635 #define elf_backend_add_symbol_hook \
6636 elf_x86_64_add_symbol_hook
6637 #define elf_backend_symbol_processing \
6638 elf_x86_64_symbol_processing
6639 #define elf_backend_common_section_index \
6640 elf_x86_64_common_section_index
6641 #define elf_backend_common_section \
6642 elf_x86_64_common_section
6643 #define elf_backend_common_definition \
6644 elf_x86_64_common_definition
6645 #define elf_backend_merge_symbol \
6646 elf_x86_64_merge_symbol
6647 #define elf_backend_special_sections \
6648 elf_x86_64_special_sections
6649 #define elf_backend_additional_program_headers \
6650 elf_x86_64_additional_program_headers
6651 #define elf_backend_hash_symbol \
6652 elf_x86_64_hash_symbol
6653 #define elf_backend_omit_section_dynsym \
6654 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6655 #define elf_backend_fixup_symbol \
6656 elf_x86_64_fixup_symbol
6658 #include "elf64-target.h"
6660 /* CloudABI support. */
6662 #undef TARGET_LITTLE_SYM
6663 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
6664 #undef TARGET_LITTLE_NAME
6665 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
6668 #define ELF_OSABI ELFOSABI_CLOUDABI
6671 #define elf64_bed elf64_x86_64_cloudabi_bed
6673 #include "elf64-target.h"
6675 /* FreeBSD support. */
6677 #undef TARGET_LITTLE_SYM
6678 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
6679 #undef TARGET_LITTLE_NAME
6680 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
6683 #define ELF_OSABI ELFOSABI_FREEBSD
6686 #define elf64_bed elf64_x86_64_fbsd_bed
6688 #include "elf64-target.h"
6690 /* Solaris 2 support. */
6692 #undef TARGET_LITTLE_SYM
6693 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
6694 #undef TARGET_LITTLE_NAME
6695 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
6697 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6698 objects won't be recognized. */
6702 #define elf64_bed elf64_x86_64_sol2_bed
6704 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
6706 #undef elf_backend_static_tls_alignment
6707 #define elf_backend_static_tls_alignment 16
6709 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6711 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6713 #undef elf_backend_want_plt_sym
6714 #define elf_backend_want_plt_sym 1
6716 #include "elf64-target.h"
6718 /* Native Client support. */
6721 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
6723 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
6724 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
6728 #undef TARGET_LITTLE_SYM
6729 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
6730 #undef TARGET_LITTLE_NAME
6731 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
6733 #define elf64_bed elf64_x86_64_nacl_bed
6735 #undef ELF_MAXPAGESIZE
6736 #undef ELF_MINPAGESIZE
6737 #undef ELF_COMMONPAGESIZE
6738 #define ELF_MAXPAGESIZE 0x10000
6739 #define ELF_MINPAGESIZE 0x10000
6740 #define ELF_COMMONPAGESIZE 0x10000
6742 /* Restore defaults. */
6744 #undef elf_backend_static_tls_alignment
6745 #undef elf_backend_want_plt_sym
6746 #define elf_backend_want_plt_sym 0
6748 /* NaCl uses substantially different PLT entries for the same effects. */
6750 #undef elf_backend_plt_alignment
6751 #define elf_backend_plt_alignment 5
6752 #define NACL_PLT_ENTRY_SIZE 64
6753 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6755 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
6757 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
6758 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
6759 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6760 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6761 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6763 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
6764 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
6766 /* 32 bytes of nop to pad out to the standard size. */
6767 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6768 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6769 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6770 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6771 0x66, /* excess data32 prefix */
6775 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6777 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
6778 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6779 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6780 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6782 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
6783 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6784 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6786 /* Lazy GOT entries point here (32-byte aligned). */
6787 0x68, /* pushq immediate */
6788 0, 0, 0, 0, /* replaced with index into relocation table. */
6789 0xe9, /* jmp relative */
6790 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
6792 /* 22 bytes of nop to pad out to the standard size. */
6793 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6794 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6795 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
6798 /* .eh_frame covering the .plt section. */
6800 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
6802 #if (PLT_CIE_LENGTH != 20 \
6803 || PLT_FDE_LENGTH != 36 \
6804 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6805 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6806 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
6808 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6809 0, 0, 0, 0, /* CIE ID */
6810 1, /* CIE version */
6811 'z', 'R', 0, /* Augmentation string */
6812 1, /* Code alignment factor */
6813 0x78, /* Data alignment factor */
6814 16, /* Return address column */
6815 1, /* Augmentation size */
6816 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6817 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
6818 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
6819 DW_CFA_nop
, DW_CFA_nop
,
6821 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6822 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
6823 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
6824 0, 0, 0, 0, /* .plt size goes here */
6825 0, /* Augmentation size */
6826 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
6827 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6828 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
6829 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6830 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6831 13, /* Block length */
6832 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
6833 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
6834 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6835 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
6836 DW_CFA_nop
, DW_CFA_nop
6839 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
6841 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
6842 elf_x86_64_nacl_plt_entry
, /* plt_entry */
6843 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6844 2, /* plt0_got1_offset */
6845 9, /* plt0_got2_offset */
6846 13, /* plt0_got2_insn_end */
6847 3, /* plt_got_offset */
6848 33, /* plt_reloc_offset */
6849 38, /* plt_plt_offset */
6850 7, /* plt_got_insn_size */
6851 42, /* plt_plt_insn_end */
6852 32, /* plt_lazy_offset */
6853 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
6854 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
6857 #undef elf_backend_arch_data
6858 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
6860 #undef elf_backend_object_p
6861 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
6862 #undef elf_backend_modify_segment_map
6863 #define elf_backend_modify_segment_map nacl_modify_segment_map
6864 #undef elf_backend_modify_program_headers
6865 #define elf_backend_modify_program_headers nacl_modify_program_headers
6866 #undef elf_backend_final_write_processing
6867 #define elf_backend_final_write_processing nacl_final_write_processing
6869 #include "elf64-target.h"
6871 /* Native Client x32 support. */
6874 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
6876 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
6877 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
6881 #undef TARGET_LITTLE_SYM
6882 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
6883 #undef TARGET_LITTLE_NAME
6884 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
6886 #define elf32_bed elf32_x86_64_nacl_bed
6888 #define bfd_elf32_bfd_link_hash_table_create \
6889 elf_x86_64_link_hash_table_create
6890 #define bfd_elf32_bfd_reloc_type_lookup \
6891 elf_x86_64_reloc_type_lookup
6892 #define bfd_elf32_bfd_reloc_name_lookup \
6893 elf_x86_64_reloc_name_lookup
6894 #define bfd_elf32_mkobject \
6896 #define bfd_elf32_get_synthetic_symtab \
6897 elf_x86_64_get_synthetic_symtab
6899 #undef elf_backend_object_p
6900 #define elf_backend_object_p \
6901 elf32_x86_64_nacl_elf_object_p
6903 #undef elf_backend_bfd_from_remote_memory
6904 #define elf_backend_bfd_from_remote_memory \
6905 _bfd_elf32_bfd_from_remote_memory
6907 #undef elf_backend_size_info
6908 #define elf_backend_size_info \
6909 _bfd_elf32_size_info
6911 #include "elf32-target.h"
6913 /* Restore defaults. */
6914 #undef elf_backend_object_p
6915 #define elf_backend_object_p elf64_x86_64_elf_object_p
6916 #undef elf_backend_bfd_from_remote_memory
6917 #undef elf_backend_size_info
6918 #undef elf_backend_modify_segment_map
6919 #undef elf_backend_modify_program_headers
6920 #undef elf_backend_final_write_processing
6922 /* Intel L1OM support. */
6925 elf64_l1om_elf_object_p (bfd
*abfd
)
6927 /* Set the right machine number for an L1OM elf64 file. */
6928 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
6932 #undef TARGET_LITTLE_SYM
6933 #define TARGET_LITTLE_SYM l1om_elf64_vec
6934 #undef TARGET_LITTLE_NAME
6935 #define TARGET_LITTLE_NAME "elf64-l1om"
6937 #define ELF_ARCH bfd_arch_l1om
6939 #undef ELF_MACHINE_CODE
6940 #define ELF_MACHINE_CODE EM_L1OM
6945 #define elf64_bed elf64_l1om_bed
6947 #undef elf_backend_object_p
6948 #define elf_backend_object_p elf64_l1om_elf_object_p
6950 /* Restore defaults. */
6951 #undef ELF_MAXPAGESIZE
6952 #undef ELF_MINPAGESIZE
6953 #undef ELF_COMMONPAGESIZE
6954 #define ELF_MAXPAGESIZE 0x200000
6955 #define ELF_MINPAGESIZE 0x1000
6956 #define ELF_COMMONPAGESIZE 0x1000
6957 #undef elf_backend_plt_alignment
6958 #define elf_backend_plt_alignment 4
6959 #undef elf_backend_arch_data
6960 #define elf_backend_arch_data &elf_x86_64_arch_bed
6962 #include "elf64-target.h"
6964 /* FreeBSD L1OM support. */
6966 #undef TARGET_LITTLE_SYM
6967 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
6968 #undef TARGET_LITTLE_NAME
6969 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
6972 #define ELF_OSABI ELFOSABI_FREEBSD
6975 #define elf64_bed elf64_l1om_fbsd_bed
6977 #include "elf64-target.h"
6979 /* Intel K1OM support. */
6982 elf64_k1om_elf_object_p (bfd
*abfd
)
6984 /* Set the right machine number for an K1OM elf64 file. */
6985 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
6989 #undef TARGET_LITTLE_SYM
6990 #define TARGET_LITTLE_SYM k1om_elf64_vec
6991 #undef TARGET_LITTLE_NAME
6992 #define TARGET_LITTLE_NAME "elf64-k1om"
6994 #define ELF_ARCH bfd_arch_k1om
6996 #undef ELF_MACHINE_CODE
6997 #define ELF_MACHINE_CODE EM_K1OM
7002 #define elf64_bed elf64_k1om_bed
7004 #undef elf_backend_object_p
7005 #define elf_backend_object_p elf64_k1om_elf_object_p
7007 #undef elf_backend_static_tls_alignment
7009 #undef elf_backend_want_plt_sym
7010 #define elf_backend_want_plt_sym 0
7012 #include "elf64-target.h"
7014 /* FreeBSD K1OM support. */
7016 #undef TARGET_LITTLE_SYM
7017 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
7018 #undef TARGET_LITTLE_NAME
7019 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
7022 #define ELF_OSABI ELFOSABI_FREEBSD
7025 #define elf64_bed elf64_k1om_fbsd_bed
7027 #include "elf64-target.h"
7029 /* 32bit x86-64 support. */
7031 #undef TARGET_LITTLE_SYM
7032 #define TARGET_LITTLE_SYM x86_64_elf32_vec
7033 #undef TARGET_LITTLE_NAME
7034 #define TARGET_LITTLE_NAME "elf32-x86-64"
7038 #define ELF_ARCH bfd_arch_i386
7040 #undef ELF_MACHINE_CODE
7041 #define ELF_MACHINE_CODE EM_X86_64
7045 #undef elf_backend_object_p
7046 #define elf_backend_object_p \
7047 elf32_x86_64_elf_object_p
7049 #undef elf_backend_bfd_from_remote_memory
7050 #define elf_backend_bfd_from_remote_memory \
7051 _bfd_elf32_bfd_from_remote_memory
7053 #undef elf_backend_size_info
7054 #define elf_backend_size_info \
7055 _bfd_elf32_size_info
7057 #include "elf32-target.h"