1 /* X86-64 specific support for ELF
2 Copyright (C) 2000-2016 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka <jh@suse.cz>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
28 #include "bfd_stdint.h"
32 #include "libiberty.h"
34 #include "opcode/i386.h"
35 #include "elf/x86-64.h"
42 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
43 #define MINUS_ONE (~ (bfd_vma) 0)
45 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
46 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
47 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
48 since they are the same. */
50 #define ABI_64_P(abfd) \
51 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
53 /* The relocation "howto" table. Order of fields:
54 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
55 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
56 static reloc_howto_type x86_64_elf_howto_table
[] =
58 HOWTO(R_X86_64_NONE
, 0, 3, 0, FALSE
, 0, complain_overflow_dont
,
59 bfd_elf_generic_reloc
, "R_X86_64_NONE", FALSE
, 0x00000000, 0x00000000,
61 HOWTO(R_X86_64_64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
62 bfd_elf_generic_reloc
, "R_X86_64_64", FALSE
, MINUS_ONE
, MINUS_ONE
,
64 HOWTO(R_X86_64_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
65 bfd_elf_generic_reloc
, "R_X86_64_PC32", FALSE
, 0xffffffff, 0xffffffff,
67 HOWTO(R_X86_64_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
68 bfd_elf_generic_reloc
, "R_X86_64_GOT32", FALSE
, 0xffffffff, 0xffffffff,
70 HOWTO(R_X86_64_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
71 bfd_elf_generic_reloc
, "R_X86_64_PLT32", FALSE
, 0xffffffff, 0xffffffff,
73 HOWTO(R_X86_64_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
74 bfd_elf_generic_reloc
, "R_X86_64_COPY", FALSE
, 0xffffffff, 0xffffffff,
76 HOWTO(R_X86_64_GLOB_DAT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
77 bfd_elf_generic_reloc
, "R_X86_64_GLOB_DAT", FALSE
, MINUS_ONE
,
79 HOWTO(R_X86_64_JUMP_SLOT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
80 bfd_elf_generic_reloc
, "R_X86_64_JUMP_SLOT", FALSE
, MINUS_ONE
,
82 HOWTO(R_X86_64_RELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
83 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE", FALSE
, MINUS_ONE
,
85 HOWTO(R_X86_64_GOTPCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
86 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL", FALSE
, 0xffffffff,
88 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
89 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
91 HOWTO(R_X86_64_32S
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
92 bfd_elf_generic_reloc
, "R_X86_64_32S", FALSE
, 0xffffffff, 0xffffffff,
94 HOWTO(R_X86_64_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
95 bfd_elf_generic_reloc
, "R_X86_64_16", FALSE
, 0xffff, 0xffff, FALSE
),
96 HOWTO(R_X86_64_PC16
,0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
97 bfd_elf_generic_reloc
, "R_X86_64_PC16", FALSE
, 0xffff, 0xffff, TRUE
),
98 HOWTO(R_X86_64_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
99 bfd_elf_generic_reloc
, "R_X86_64_8", FALSE
, 0xff, 0xff, FALSE
),
100 HOWTO(R_X86_64_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
101 bfd_elf_generic_reloc
, "R_X86_64_PC8", FALSE
, 0xff, 0xff, TRUE
),
102 HOWTO(R_X86_64_DTPMOD64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
103 bfd_elf_generic_reloc
, "R_X86_64_DTPMOD64", FALSE
, MINUS_ONE
,
105 HOWTO(R_X86_64_DTPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
106 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF64", FALSE
, MINUS_ONE
,
108 HOWTO(R_X86_64_TPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
109 bfd_elf_generic_reloc
, "R_X86_64_TPOFF64", FALSE
, MINUS_ONE
,
111 HOWTO(R_X86_64_TLSGD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
112 bfd_elf_generic_reloc
, "R_X86_64_TLSGD", FALSE
, 0xffffffff,
114 HOWTO(R_X86_64_TLSLD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
115 bfd_elf_generic_reloc
, "R_X86_64_TLSLD", FALSE
, 0xffffffff,
117 HOWTO(R_X86_64_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
118 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF32", FALSE
, 0xffffffff,
120 HOWTO(R_X86_64_GOTTPOFF
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
121 bfd_elf_generic_reloc
, "R_X86_64_GOTTPOFF", FALSE
, 0xffffffff,
123 HOWTO(R_X86_64_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
124 bfd_elf_generic_reloc
, "R_X86_64_TPOFF32", FALSE
, 0xffffffff,
126 HOWTO(R_X86_64_PC64
, 0, 4, 64, TRUE
, 0, complain_overflow_bitfield
,
127 bfd_elf_generic_reloc
, "R_X86_64_PC64", FALSE
, MINUS_ONE
, MINUS_ONE
,
129 HOWTO(R_X86_64_GOTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
130 bfd_elf_generic_reloc
, "R_X86_64_GOTOFF64",
131 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
132 HOWTO(R_X86_64_GOTPC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
133 bfd_elf_generic_reloc
, "R_X86_64_GOTPC32",
134 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
135 HOWTO(R_X86_64_GOT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
136 bfd_elf_generic_reloc
, "R_X86_64_GOT64", FALSE
, MINUS_ONE
, MINUS_ONE
,
138 HOWTO(R_X86_64_GOTPCREL64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
139 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL64", FALSE
, MINUS_ONE
,
141 HOWTO(R_X86_64_GOTPC64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
142 bfd_elf_generic_reloc
, "R_X86_64_GOTPC64",
143 FALSE
, MINUS_ONE
, MINUS_ONE
, TRUE
),
144 HOWTO(R_X86_64_GOTPLT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
145 bfd_elf_generic_reloc
, "R_X86_64_GOTPLT64", FALSE
, MINUS_ONE
,
147 HOWTO(R_X86_64_PLTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
148 bfd_elf_generic_reloc
, "R_X86_64_PLTOFF64", FALSE
, MINUS_ONE
,
150 HOWTO(R_X86_64_SIZE32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
151 bfd_elf_generic_reloc
, "R_X86_64_SIZE32", FALSE
, 0xffffffff, 0xffffffff,
153 HOWTO(R_X86_64_SIZE64
, 0, 4, 64, FALSE
, 0, complain_overflow_unsigned
,
154 bfd_elf_generic_reloc
, "R_X86_64_SIZE64", FALSE
, MINUS_ONE
, MINUS_ONE
,
156 HOWTO(R_X86_64_GOTPC32_TLSDESC
, 0, 2, 32, TRUE
, 0,
157 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
158 "R_X86_64_GOTPC32_TLSDESC",
159 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
160 HOWTO(R_X86_64_TLSDESC_CALL
, 0, 0, 0, FALSE
, 0,
161 complain_overflow_dont
, bfd_elf_generic_reloc
,
162 "R_X86_64_TLSDESC_CALL",
164 HOWTO(R_X86_64_TLSDESC
, 0, 4, 64, FALSE
, 0,
165 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
167 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
168 HOWTO(R_X86_64_IRELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
169 bfd_elf_generic_reloc
, "R_X86_64_IRELATIVE", FALSE
, MINUS_ONE
,
171 HOWTO(R_X86_64_RELATIVE64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
172 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE64", FALSE
, MINUS_ONE
,
174 HOWTO(R_X86_64_PC32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
175 bfd_elf_generic_reloc
, "R_X86_64_PC32_BND", FALSE
, 0xffffffff, 0xffffffff,
177 HOWTO(R_X86_64_PLT32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
178 bfd_elf_generic_reloc
, "R_X86_64_PLT32_BND", FALSE
, 0xffffffff, 0xffffffff,
180 HOWTO(R_X86_64_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
181 bfd_elf_generic_reloc
, "R_X86_64_GOTPCRELX", FALSE
, 0xffffffff,
183 HOWTO(R_X86_64_REX_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
184 bfd_elf_generic_reloc
, "R_X86_64_REX_GOTPCRELX", FALSE
, 0xffffffff,
187 /* We have a gap in the reloc numbers here.
188 R_X86_64_standard counts the number up to this point, and
189 R_X86_64_vt_offset is the value to subtract from a reloc type of
190 R_X86_64_GNU_VT* to form an index into this table. */
191 #define R_X86_64_standard (R_X86_64_REX_GOTPCRELX + 1)
192 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
194 /* GNU extension to record C++ vtable hierarchy. */
195 HOWTO (R_X86_64_GNU_VTINHERIT
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
196 NULL
, "R_X86_64_GNU_VTINHERIT", FALSE
, 0, 0, FALSE
),
198 /* GNU extension to record C++ vtable member usage. */
199 HOWTO (R_X86_64_GNU_VTENTRY
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
200 _bfd_elf_rel_vtable_reloc_fn
, "R_X86_64_GNU_VTENTRY", FALSE
, 0, 0,
203 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
204 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
205 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
209 #define IS_X86_64_PCREL_TYPE(TYPE) \
210 ( ((TYPE) == R_X86_64_PC8) \
211 || ((TYPE) == R_X86_64_PC16) \
212 || ((TYPE) == R_X86_64_PC32) \
213 || ((TYPE) == R_X86_64_PC32_BND) \
214 || ((TYPE) == R_X86_64_PC64))
216 /* Map BFD relocs to the x86_64 elf relocs. */
219 bfd_reloc_code_real_type bfd_reloc_val
;
220 unsigned char elf_reloc_val
;
223 static const struct elf_reloc_map x86_64_reloc_map
[] =
225 { BFD_RELOC_NONE
, R_X86_64_NONE
, },
226 { BFD_RELOC_64
, R_X86_64_64
, },
227 { BFD_RELOC_32_PCREL
, R_X86_64_PC32
, },
228 { BFD_RELOC_X86_64_GOT32
, R_X86_64_GOT32
,},
229 { BFD_RELOC_X86_64_PLT32
, R_X86_64_PLT32
,},
230 { BFD_RELOC_X86_64_COPY
, R_X86_64_COPY
, },
231 { BFD_RELOC_X86_64_GLOB_DAT
, R_X86_64_GLOB_DAT
, },
232 { BFD_RELOC_X86_64_JUMP_SLOT
, R_X86_64_JUMP_SLOT
, },
233 { BFD_RELOC_X86_64_RELATIVE
, R_X86_64_RELATIVE
, },
234 { BFD_RELOC_X86_64_GOTPCREL
, R_X86_64_GOTPCREL
, },
235 { BFD_RELOC_32
, R_X86_64_32
, },
236 { BFD_RELOC_X86_64_32S
, R_X86_64_32S
, },
237 { BFD_RELOC_16
, R_X86_64_16
, },
238 { BFD_RELOC_16_PCREL
, R_X86_64_PC16
, },
239 { BFD_RELOC_8
, R_X86_64_8
, },
240 { BFD_RELOC_8_PCREL
, R_X86_64_PC8
, },
241 { BFD_RELOC_X86_64_DTPMOD64
, R_X86_64_DTPMOD64
, },
242 { BFD_RELOC_X86_64_DTPOFF64
, R_X86_64_DTPOFF64
, },
243 { BFD_RELOC_X86_64_TPOFF64
, R_X86_64_TPOFF64
, },
244 { BFD_RELOC_X86_64_TLSGD
, R_X86_64_TLSGD
, },
245 { BFD_RELOC_X86_64_TLSLD
, R_X86_64_TLSLD
, },
246 { BFD_RELOC_X86_64_DTPOFF32
, R_X86_64_DTPOFF32
, },
247 { BFD_RELOC_X86_64_GOTTPOFF
, R_X86_64_GOTTPOFF
, },
248 { BFD_RELOC_X86_64_TPOFF32
, R_X86_64_TPOFF32
, },
249 { BFD_RELOC_64_PCREL
, R_X86_64_PC64
, },
250 { BFD_RELOC_X86_64_GOTOFF64
, R_X86_64_GOTOFF64
, },
251 { BFD_RELOC_X86_64_GOTPC32
, R_X86_64_GOTPC32
, },
252 { BFD_RELOC_X86_64_GOT64
, R_X86_64_GOT64
, },
253 { BFD_RELOC_X86_64_GOTPCREL64
,R_X86_64_GOTPCREL64
, },
254 { BFD_RELOC_X86_64_GOTPC64
, R_X86_64_GOTPC64
, },
255 { BFD_RELOC_X86_64_GOTPLT64
, R_X86_64_GOTPLT64
, },
256 { BFD_RELOC_X86_64_PLTOFF64
, R_X86_64_PLTOFF64
, },
257 { BFD_RELOC_SIZE32
, R_X86_64_SIZE32
, },
258 { BFD_RELOC_SIZE64
, R_X86_64_SIZE64
, },
259 { BFD_RELOC_X86_64_GOTPC32_TLSDESC
, R_X86_64_GOTPC32_TLSDESC
, },
260 { BFD_RELOC_X86_64_TLSDESC_CALL
, R_X86_64_TLSDESC_CALL
, },
261 { BFD_RELOC_X86_64_TLSDESC
, R_X86_64_TLSDESC
, },
262 { BFD_RELOC_X86_64_IRELATIVE
, R_X86_64_IRELATIVE
, },
263 { BFD_RELOC_X86_64_PC32_BND
, R_X86_64_PC32_BND
, },
264 { BFD_RELOC_X86_64_PLT32_BND
, R_X86_64_PLT32_BND
, },
265 { BFD_RELOC_X86_64_GOTPCRELX
, R_X86_64_GOTPCRELX
, },
266 { BFD_RELOC_X86_64_REX_GOTPCRELX
, R_X86_64_REX_GOTPCRELX
, },
267 { BFD_RELOC_VTABLE_INHERIT
, R_X86_64_GNU_VTINHERIT
, },
268 { BFD_RELOC_VTABLE_ENTRY
, R_X86_64_GNU_VTENTRY
, },
271 static reloc_howto_type
*
272 elf_x86_64_rtype_to_howto (bfd
*abfd
, unsigned r_type
)
276 if (r_type
== (unsigned int) R_X86_64_32
)
281 i
= ARRAY_SIZE (x86_64_elf_howto_table
) - 1;
283 else if (r_type
< (unsigned int) R_X86_64_GNU_VTINHERIT
284 || r_type
>= (unsigned int) R_X86_64_max
)
286 if (r_type
>= (unsigned int) R_X86_64_standard
)
288 (*_bfd_error_handler
) (_("%B: invalid relocation type %d"),
290 r_type
= R_X86_64_NONE
;
295 i
= r_type
- (unsigned int) R_X86_64_vt_offset
;
296 BFD_ASSERT (x86_64_elf_howto_table
[i
].type
== r_type
);
297 return &x86_64_elf_howto_table
[i
];
300 /* Given a BFD reloc type, return a HOWTO structure. */
301 static reloc_howto_type
*
302 elf_x86_64_reloc_type_lookup (bfd
*abfd
,
303 bfd_reloc_code_real_type code
)
307 for (i
= 0; i
< sizeof (x86_64_reloc_map
) / sizeof (struct elf_reloc_map
);
310 if (x86_64_reloc_map
[i
].bfd_reloc_val
== code
)
311 return elf_x86_64_rtype_to_howto (abfd
,
312 x86_64_reloc_map
[i
].elf_reloc_val
);
317 static reloc_howto_type
*
318 elf_x86_64_reloc_name_lookup (bfd
*abfd
,
323 if (!ABI_64_P (abfd
) && strcasecmp (r_name
, "R_X86_64_32") == 0)
325 /* Get x32 R_X86_64_32. */
326 reloc_howto_type
*reloc
327 = &x86_64_elf_howto_table
[ARRAY_SIZE (x86_64_elf_howto_table
) - 1];
328 BFD_ASSERT (reloc
->type
== (unsigned int) R_X86_64_32
);
332 for (i
= 0; i
< ARRAY_SIZE (x86_64_elf_howto_table
); i
++)
333 if (x86_64_elf_howto_table
[i
].name
!= NULL
334 && strcasecmp (x86_64_elf_howto_table
[i
].name
, r_name
) == 0)
335 return &x86_64_elf_howto_table
[i
];
340 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
343 elf_x86_64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
344 Elf_Internal_Rela
*dst
)
348 r_type
= ELF32_R_TYPE (dst
->r_info
);
349 cache_ptr
->howto
= elf_x86_64_rtype_to_howto (abfd
, r_type
);
350 BFD_ASSERT (r_type
== cache_ptr
->howto
->type
);
353 /* Support for core dump NOTE sections. */
355 elf_x86_64_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
360 switch (note
->descsz
)
365 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
367 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
370 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
378 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
380 elf_tdata (abfd
)->core
->signal
381 = bfd_get_16 (abfd
, note
->descdata
+ 12);
384 elf_tdata (abfd
)->core
->lwpid
385 = bfd_get_32 (abfd
, note
->descdata
+ 32);
394 /* Make a ".reg/999" section. */
395 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
396 size
, note
->descpos
+ offset
);
400 elf_x86_64_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
402 switch (note
->descsz
)
407 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
408 elf_tdata (abfd
)->core
->pid
409 = bfd_get_32 (abfd
, note
->descdata
+ 12);
410 elf_tdata (abfd
)->core
->program
411 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
412 elf_tdata (abfd
)->core
->command
413 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
416 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
417 elf_tdata (abfd
)->core
->pid
418 = bfd_get_32 (abfd
, note
->descdata
+ 24);
419 elf_tdata (abfd
)->core
->program
420 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
421 elf_tdata (abfd
)->core
->command
422 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
425 /* Note that for some reason, a spurious space is tacked
426 onto the end of the args in some (at least one anyway)
427 implementations, so strip it off if it exists. */
430 char *command
= elf_tdata (abfd
)->core
->command
;
431 int n
= strlen (command
);
433 if (0 < n
&& command
[n
- 1] == ' ')
434 command
[n
- 1] = '\0';
442 elf_x86_64_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
,
445 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
447 const char *fname
, *psargs
;
458 va_start (ap
, note_type
);
459 fname
= va_arg (ap
, const char *);
460 psargs
= va_arg (ap
, const char *);
463 if (bed
->s
->elfclass
== ELFCLASS32
)
466 memset (&data
, 0, sizeof (data
));
467 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
468 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
469 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
470 &data
, sizeof (data
));
475 memset (&data
, 0, sizeof (data
));
476 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
477 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
478 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
479 &data
, sizeof (data
));
484 va_start (ap
, note_type
);
485 pid
= va_arg (ap
, long);
486 cursig
= va_arg (ap
, int);
487 gregs
= va_arg (ap
, const void *);
490 if (bed
->s
->elfclass
== ELFCLASS32
)
492 if (bed
->elf_machine_code
== EM_X86_64
)
494 prstatusx32_t prstat
;
495 memset (&prstat
, 0, sizeof (prstat
));
497 prstat
.pr_cursig
= cursig
;
498 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
499 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
500 &prstat
, sizeof (prstat
));
505 memset (&prstat
, 0, sizeof (prstat
));
507 prstat
.pr_cursig
= cursig
;
508 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
509 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
510 &prstat
, sizeof (prstat
));
516 memset (&prstat
, 0, sizeof (prstat
));
518 prstat
.pr_cursig
= cursig
;
519 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
520 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
521 &prstat
, sizeof (prstat
));
528 /* Functions for the x86-64 ELF linker. */
530 /* The name of the dynamic interpreter. This is put in the .interp
533 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
534 #define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
536 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
537 copying dynamic variables from a shared lib into an app's dynbss
538 section, and instead use a dynamic relocation to point into the
540 #define ELIMINATE_COPY_RELOCS 1
542 /* The size in bytes of an entry in the global offset table. */
544 #define GOT_ENTRY_SIZE 8
546 /* The size in bytes of an entry in the procedure linkage table. */
548 #define PLT_ENTRY_SIZE 16
550 /* The first entry in a procedure linkage table looks like this. See the
551 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
553 static const bfd_byte elf_x86_64_plt0_entry
[PLT_ENTRY_SIZE
] =
555 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
556 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
557 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
560 /* Subsequent entries in a procedure linkage table look like this. */
562 static const bfd_byte elf_x86_64_plt_entry
[PLT_ENTRY_SIZE
] =
564 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
565 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
566 0x68, /* pushq immediate */
567 0, 0, 0, 0, /* replaced with index into relocation table. */
568 0xe9, /* jmp relative */
569 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
572 /* The first entry in a procedure linkage table with BND relocations
575 static const bfd_byte elf_x86_64_bnd_plt0_entry
[PLT_ENTRY_SIZE
] =
577 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
578 0xf2, 0xff, 0x25, 16, 0, 0, 0, /* bnd jmpq *GOT+16(%rip) */
579 0x0f, 0x1f, 0 /* nopl (%rax) */
582 /* Subsequent entries for legacy branches in a procedure linkage table
583 with BND relocations look like this. */
585 static const bfd_byte elf_x86_64_legacy_plt_entry
[PLT_ENTRY_SIZE
] =
587 0x68, 0, 0, 0, 0, /* pushq immediate */
588 0xe9, 0, 0, 0, 0, /* jmpq relative */
589 0x66, 0x0f, 0x1f, 0x44, 0, 0 /* nopw (%rax,%rax,1) */
592 /* Subsequent entries for branches with BND prefx in a procedure linkage
593 table with BND relocations look like this. */
595 static const bfd_byte elf_x86_64_bnd_plt_entry
[PLT_ENTRY_SIZE
] =
597 0x68, 0, 0, 0, 0, /* pushq immediate */
598 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
599 0x0f, 0x1f, 0x44, 0, 0 /* nopl 0(%rax,%rax,1) */
602 /* Entries for legacy branches in the second procedure linkage table
605 static const bfd_byte elf_x86_64_legacy_plt2_entry
[8] =
607 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
608 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
609 0x66, 0x90 /* xchg %ax,%ax */
612 /* Entries for branches with BND prefix in the second procedure linkage
613 table look like this. */
615 static const bfd_byte elf_x86_64_bnd_plt2_entry
[8] =
617 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
618 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
622 /* .eh_frame covering the .plt section. */
624 static const bfd_byte elf_x86_64_eh_frame_plt
[] =
626 #define PLT_CIE_LENGTH 20
627 #define PLT_FDE_LENGTH 36
628 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
629 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
630 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
631 0, 0, 0, 0, /* CIE ID */
633 'z', 'R', 0, /* Augmentation string */
634 1, /* Code alignment factor */
635 0x78, /* Data alignment factor */
636 16, /* Return address column */
637 1, /* Augmentation size */
638 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
639 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
640 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
641 DW_CFA_nop
, DW_CFA_nop
,
643 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
644 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
645 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
646 0, 0, 0, 0, /* .plt size goes here */
647 0, /* Augmentation size */
648 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
649 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
650 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
651 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
652 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
653 11, /* Block length */
654 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
655 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
656 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
657 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
658 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
661 /* Architecture-specific backend data for x86-64. */
663 struct elf_x86_64_backend_data
665 /* Templates for the initial PLT entry and for subsequent entries. */
666 const bfd_byte
*plt0_entry
;
667 const bfd_byte
*plt_entry
;
668 unsigned int plt_entry_size
; /* Size of each PLT entry. */
670 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
671 unsigned int plt0_got1_offset
;
672 unsigned int plt0_got2_offset
;
674 /* Offset of the end of the PC-relative instruction containing
676 unsigned int plt0_got2_insn_end
;
678 /* Offsets into plt_entry that are to be replaced with... */
679 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
680 unsigned int plt_reloc_offset
; /* ... offset into relocation table. */
681 unsigned int plt_plt_offset
; /* ... offset to start of .plt. */
683 /* Length of the PC-relative instruction containing plt_got_offset. */
684 unsigned int plt_got_insn_size
;
686 /* Offset of the end of the PC-relative jump to plt0_entry. */
687 unsigned int plt_plt_insn_end
;
689 /* Offset into plt_entry where the initial value of the GOT entry points. */
690 unsigned int plt_lazy_offset
;
692 /* .eh_frame covering the .plt section. */
693 const bfd_byte
*eh_frame_plt
;
694 unsigned int eh_frame_plt_size
;
697 #define get_elf_x86_64_arch_data(bed) \
698 ((const struct elf_x86_64_backend_data *) (bed)->arch_data)
700 #define get_elf_x86_64_backend_data(abfd) \
701 get_elf_x86_64_arch_data (get_elf_backend_data (abfd))
703 #define GET_PLT_ENTRY_SIZE(abfd) \
704 get_elf_x86_64_backend_data (abfd)->plt_entry_size
706 /* These are the standard parameters. */
707 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed
=
709 elf_x86_64_plt0_entry
, /* plt0_entry */
710 elf_x86_64_plt_entry
, /* plt_entry */
711 sizeof (elf_x86_64_plt_entry
), /* plt_entry_size */
712 2, /* plt0_got1_offset */
713 8, /* plt0_got2_offset */
714 12, /* plt0_got2_insn_end */
715 2, /* plt_got_offset */
716 7, /* plt_reloc_offset */
717 12, /* plt_plt_offset */
718 6, /* plt_got_insn_size */
719 PLT_ENTRY_SIZE
, /* plt_plt_insn_end */
720 6, /* plt_lazy_offset */
721 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
722 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
725 static const struct elf_x86_64_backend_data elf_x86_64_bnd_arch_bed
=
727 elf_x86_64_bnd_plt0_entry
, /* plt0_entry */
728 elf_x86_64_bnd_plt_entry
, /* plt_entry */
729 sizeof (elf_x86_64_bnd_plt_entry
), /* plt_entry_size */
730 2, /* plt0_got1_offset */
731 1+8, /* plt0_got2_offset */
732 1+12, /* plt0_got2_insn_end */
733 1+2, /* plt_got_offset */
734 1, /* plt_reloc_offset */
735 7, /* plt_plt_offset */
736 1+6, /* plt_got_insn_size */
737 11, /* plt_plt_insn_end */
738 0, /* plt_lazy_offset */
739 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
740 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
743 #define elf_backend_arch_data &elf_x86_64_arch_bed
745 /* Is a undefined weak symbol which is resolved to 0. Reference to an
746 undefined weak symbol is resolved to 0 when building executable if
748 1. Has non-GOT/non-PLT relocations in text section. Or
749 2. Has no GOT/PLT relocation.
751 #define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, EH) \
752 ((EH)->elf.root.type == bfd_link_hash_undefweak \
753 && bfd_link_executable (INFO) \
754 && (elf_x86_64_hash_table (INFO)->interp == NULL \
755 || !(EH)->has_got_reloc \
756 || (EH)->has_non_got_reloc \
757 || !(INFO)->dynamic_undefined_weak))
759 /* x86-64 ELF linker hash entry. */
761 struct elf_x86_64_link_hash_entry
763 struct elf_link_hash_entry elf
;
765 /* Track dynamic relocs copied for this symbol. */
766 struct elf_dyn_relocs
*dyn_relocs
;
768 #define GOT_UNKNOWN 0
772 #define GOT_TLS_GDESC 4
773 #define GOT_TLS_GD_BOTH_P(type) \
774 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
775 #define GOT_TLS_GD_P(type) \
776 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
777 #define GOT_TLS_GDESC_P(type) \
778 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
779 #define GOT_TLS_GD_ANY_P(type) \
780 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
781 unsigned char tls_type
;
783 /* TRUE if a weak symbol with a real definition needs a copy reloc.
784 When there is a weak symbol with a real definition, the processor
785 independent code will have arranged for us to see the real
786 definition first. We need to copy the needs_copy bit from the
787 real definition and check it when allowing copy reloc in PIE. */
788 unsigned int needs_copy
: 1;
790 /* TRUE if symbol has at least one BND relocation. */
791 unsigned int has_bnd_reloc
: 1;
793 /* TRUE if symbol has GOT or PLT relocations. */
794 unsigned int has_got_reloc
: 1;
796 /* TRUE if symbol has non-GOT/non-PLT relocations in text sections. */
797 unsigned int has_non_got_reloc
: 1;
799 /* Reference count of C/C++ function pointer relocations in read-write
800 section which can be resolved at run-time. */
801 bfd_signed_vma func_pointer_refcount
;
803 /* Information about the GOT PLT entry. Filled when there are both
804 GOT and PLT relocations against the same function. */
805 union gotplt_union plt_got
;
807 /* Information about the second PLT entry. Filled when has_bnd_reloc is
809 union gotplt_union plt_bnd
;
811 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
812 starting at the end of the jump table. */
816 #define elf_x86_64_hash_entry(ent) \
817 ((struct elf_x86_64_link_hash_entry *)(ent))
819 struct elf_x86_64_obj_tdata
821 struct elf_obj_tdata root
;
823 /* tls_type for each local got entry. */
824 char *local_got_tls_type
;
826 /* GOTPLT entries for TLS descriptors. */
827 bfd_vma
*local_tlsdesc_gotent
;
830 #define elf_x86_64_tdata(abfd) \
831 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
833 #define elf_x86_64_local_got_tls_type(abfd) \
834 (elf_x86_64_tdata (abfd)->local_got_tls_type)
836 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
837 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
839 #define is_x86_64_elf(bfd) \
840 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
841 && elf_tdata (bfd) != NULL \
842 && elf_object_id (bfd) == X86_64_ELF_DATA)
845 elf_x86_64_mkobject (bfd
*abfd
)
847 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_x86_64_obj_tdata
),
851 /* x86-64 ELF linker hash table. */
853 struct elf_x86_64_link_hash_table
855 struct elf_link_hash_table elf
;
857 /* Short-cuts to get to dynamic linker sections. */
861 asection
*plt_eh_frame
;
867 bfd_signed_vma refcount
;
871 /* The amount of space used by the jump slots in the GOT. */
872 bfd_vma sgotplt_jump_table_size
;
874 /* Small local sym cache. */
875 struct sym_cache sym_cache
;
877 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
878 bfd_vma (*r_sym
) (bfd_vma
);
879 unsigned int pointer_r_type
;
880 const char *dynamic_interpreter
;
881 int dynamic_interpreter_size
;
883 /* _TLS_MODULE_BASE_ symbol. */
884 struct bfd_link_hash_entry
*tls_module_base
;
886 /* Used by local STT_GNU_IFUNC symbols. */
887 htab_t loc_hash_table
;
888 void * loc_hash_memory
;
890 /* The offset into splt of the PLT entry for the TLS descriptor
891 resolver. Special values are 0, if not necessary (or not found
892 to be necessary yet), and -1 if needed but not determined
895 /* The offset into sgot of the GOT entry used by the PLT entry
899 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
900 bfd_vma next_jump_slot_index
;
901 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
902 bfd_vma next_irelative_index
;
904 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
905 to read-only sections. */
906 bfd_boolean readonly_dynrelocs_against_ifunc
;
909 /* Get the x86-64 ELF linker hash table from a link_info structure. */
911 #define elf_x86_64_hash_table(p) \
912 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
913 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
915 #define elf_x86_64_compute_jump_table_size(htab) \
916 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
918 /* Create an entry in an x86-64 ELF linker hash table. */
920 static struct bfd_hash_entry
*
921 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
922 struct bfd_hash_table
*table
,
925 /* Allocate the structure if it has not already been allocated by a
929 entry
= (struct bfd_hash_entry
*)
930 bfd_hash_allocate (table
,
931 sizeof (struct elf_x86_64_link_hash_entry
));
936 /* Call the allocation method of the superclass. */
937 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
940 struct elf_x86_64_link_hash_entry
*eh
;
942 eh
= (struct elf_x86_64_link_hash_entry
*) entry
;
943 eh
->dyn_relocs
= NULL
;
944 eh
->tls_type
= GOT_UNKNOWN
;
946 eh
->has_bnd_reloc
= 0;
947 eh
->has_got_reloc
= 0;
948 eh
->has_non_got_reloc
= 0;
949 eh
->func_pointer_refcount
= 0;
950 eh
->plt_bnd
.offset
= (bfd_vma
) -1;
951 eh
->plt_got
.offset
= (bfd_vma
) -1;
952 eh
->tlsdesc_got
= (bfd_vma
) -1;
958 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
959 for local symbol so that we can handle local STT_GNU_IFUNC symbols
960 as global symbol. We reuse indx and dynstr_index for local symbol
961 hash since they aren't used by global symbols in this backend. */
964 elf_x86_64_local_htab_hash (const void *ptr
)
966 struct elf_link_hash_entry
*h
967 = (struct elf_link_hash_entry
*) ptr
;
968 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
971 /* Compare local hash entries. */
974 elf_x86_64_local_htab_eq (const void *ptr1
, const void *ptr2
)
976 struct elf_link_hash_entry
*h1
977 = (struct elf_link_hash_entry
*) ptr1
;
978 struct elf_link_hash_entry
*h2
979 = (struct elf_link_hash_entry
*) ptr2
;
981 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
984 /* Find and/or create a hash entry for local symbol. */
986 static struct elf_link_hash_entry
*
987 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table
*htab
,
988 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
991 struct elf_x86_64_link_hash_entry e
, *ret
;
992 asection
*sec
= abfd
->sections
;
993 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
994 htab
->r_sym (rel
->r_info
));
997 e
.elf
.indx
= sec
->id
;
998 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
999 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
1000 create
? INSERT
: NO_INSERT
);
1007 ret
= (struct elf_x86_64_link_hash_entry
*) *slot
;
1011 ret
= (struct elf_x86_64_link_hash_entry
*)
1012 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
1013 sizeof (struct elf_x86_64_link_hash_entry
));
1016 memset (ret
, 0, sizeof (*ret
));
1017 ret
->elf
.indx
= sec
->id
;
1018 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
1019 ret
->elf
.dynindx
= -1;
1020 ret
->func_pointer_refcount
= 0;
1021 ret
->plt_got
.offset
= (bfd_vma
) -1;
1027 /* Destroy an X86-64 ELF linker hash table. */
1030 elf_x86_64_link_hash_table_free (bfd
*obfd
)
1032 struct elf_x86_64_link_hash_table
*htab
1033 = (struct elf_x86_64_link_hash_table
*) obfd
->link
.hash
;
1035 if (htab
->loc_hash_table
)
1036 htab_delete (htab
->loc_hash_table
);
1037 if (htab
->loc_hash_memory
)
1038 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
1039 _bfd_elf_link_hash_table_free (obfd
);
1042 /* Create an X86-64 ELF linker hash table. */
1044 static struct bfd_link_hash_table
*
1045 elf_x86_64_link_hash_table_create (bfd
*abfd
)
1047 struct elf_x86_64_link_hash_table
*ret
;
1048 bfd_size_type amt
= sizeof (struct elf_x86_64_link_hash_table
);
1050 ret
= (struct elf_x86_64_link_hash_table
*) bfd_zmalloc (amt
);
1054 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1055 elf_x86_64_link_hash_newfunc
,
1056 sizeof (struct elf_x86_64_link_hash_entry
),
1063 if (ABI_64_P (abfd
))
1065 ret
->r_info
= elf64_r_info
;
1066 ret
->r_sym
= elf64_r_sym
;
1067 ret
->pointer_r_type
= R_X86_64_64
;
1068 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
1069 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
1073 ret
->r_info
= elf32_r_info
;
1074 ret
->r_sym
= elf32_r_sym
;
1075 ret
->pointer_r_type
= R_X86_64_32
;
1076 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
1077 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
1080 ret
->loc_hash_table
= htab_try_create (1024,
1081 elf_x86_64_local_htab_hash
,
1082 elf_x86_64_local_htab_eq
,
1084 ret
->loc_hash_memory
= objalloc_create ();
1085 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1087 elf_x86_64_link_hash_table_free (abfd
);
1090 ret
->elf
.root
.hash_table_free
= elf_x86_64_link_hash_table_free
;
1092 return &ret
->elf
.root
;
1095 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1096 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1100 elf_x86_64_create_dynamic_sections (bfd
*dynobj
,
1101 struct bfd_link_info
*info
)
1103 struct elf_x86_64_link_hash_table
*htab
;
1105 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1108 htab
= elf_x86_64_hash_table (info
);
1112 htab
->sdynbss
= bfd_get_linker_section (dynobj
, ".dynbss");
1116 if (bfd_link_executable (info
))
1118 /* Always allow copy relocs for building executables. */
1119 asection
*s
= bfd_get_linker_section (dynobj
, ".rela.bss");
1122 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
1123 s
= bfd_make_section_anyway_with_flags (dynobj
,
1125 (bed
->dynamic_sec_flags
1128 || ! bfd_set_section_alignment (dynobj
, s
,
1129 bed
->s
->log_file_align
))
1135 if (!info
->no_ld_generated_unwind_info
1136 && htab
->plt_eh_frame
== NULL
1137 && htab
->elf
.splt
!= NULL
)
1139 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1140 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1141 | SEC_LINKER_CREATED
);
1143 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
1144 if (htab
->plt_eh_frame
== NULL
1145 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 3))
1151 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1154 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
1155 struct elf_link_hash_entry
*dir
,
1156 struct elf_link_hash_entry
*ind
)
1158 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
1160 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
1161 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
1163 if (!edir
->has_bnd_reloc
)
1164 edir
->has_bnd_reloc
= eind
->has_bnd_reloc
;
1166 if (!edir
->has_got_reloc
)
1167 edir
->has_got_reloc
= eind
->has_got_reloc
;
1169 if (!edir
->has_non_got_reloc
)
1170 edir
->has_non_got_reloc
= eind
->has_non_got_reloc
;
1172 if (eind
->dyn_relocs
!= NULL
)
1174 if (edir
->dyn_relocs
!= NULL
)
1176 struct elf_dyn_relocs
**pp
;
1177 struct elf_dyn_relocs
*p
;
1179 /* Add reloc counts against the indirect sym to the direct sym
1180 list. Merge any entries against the same section. */
1181 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1183 struct elf_dyn_relocs
*q
;
1185 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1186 if (q
->sec
== p
->sec
)
1188 q
->pc_count
+= p
->pc_count
;
1189 q
->count
+= p
->count
;
1196 *pp
= edir
->dyn_relocs
;
1199 edir
->dyn_relocs
= eind
->dyn_relocs
;
1200 eind
->dyn_relocs
= NULL
;
1203 if (ind
->root
.type
== bfd_link_hash_indirect
1204 && dir
->got
.refcount
<= 0)
1206 edir
->tls_type
= eind
->tls_type
;
1207 eind
->tls_type
= GOT_UNKNOWN
;
1210 if (ELIMINATE_COPY_RELOCS
1211 && ind
->root
.type
!= bfd_link_hash_indirect
1212 && dir
->dynamic_adjusted
)
1214 /* If called to transfer flags for a weakdef during processing
1215 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1216 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1217 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1218 dir
->ref_regular
|= ind
->ref_regular
;
1219 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1220 dir
->needs_plt
|= ind
->needs_plt
;
1221 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1225 if (eind
->func_pointer_refcount
> 0)
1227 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1228 eind
->func_pointer_refcount
= 0;
1231 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1236 elf64_x86_64_elf_object_p (bfd
*abfd
)
1238 /* Set the right machine number for an x86-64 elf64 file. */
1239 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
1244 elf32_x86_64_elf_object_p (bfd
*abfd
)
1246 /* Set the right machine number for an x86-64 elf32 file. */
1247 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
1251 /* Return TRUE if the TLS access code sequence support transition
1255 elf_x86_64_check_tls_transition (bfd
*abfd
,
1256 struct bfd_link_info
*info
,
1259 Elf_Internal_Shdr
*symtab_hdr
,
1260 struct elf_link_hash_entry
**sym_hashes
,
1261 unsigned int r_type
,
1262 const Elf_Internal_Rela
*rel
,
1263 const Elf_Internal_Rela
*relend
)
1266 unsigned long r_symndx
;
1267 bfd_boolean largepic
= FALSE
;
1268 struct elf_link_hash_entry
*h
;
1270 struct elf_x86_64_link_hash_table
*htab
;
1272 /* Get the section contents. */
1273 if (contents
== NULL
)
1275 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1276 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1279 /* FIXME: How to better handle error condition? */
1280 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1283 /* Cache the section contents for elf_link_input_bfd. */
1284 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1288 htab
= elf_x86_64_hash_table (info
);
1289 offset
= rel
->r_offset
;
1292 case R_X86_64_TLSGD
:
1293 case R_X86_64_TLSLD
:
1294 if ((rel
+ 1) >= relend
)
1297 if (r_type
== R_X86_64_TLSGD
)
1299 /* Check transition from GD access model. For 64bit, only
1300 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1301 .word 0x6666; rex64; call __tls_get_addr
1302 can transit to different access model. For 32bit, only
1303 leaq foo@tlsgd(%rip), %rdi
1304 .word 0x6666; rex64; call __tls_get_addr
1305 can transit to different access model. For largepic
1307 leaq foo@tlsgd(%rip), %rdi
1308 movabsq $__tls_get_addr@pltoff, %rax
1312 static const unsigned char call
[] = { 0x66, 0x66, 0x48, 0xe8 };
1313 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1315 if ((offset
+ 12) > sec
->size
)
1318 if (memcmp (contents
+ offset
+ 4, call
, 4) != 0)
1320 if (!ABI_64_P (abfd
)
1321 || (offset
+ 19) > sec
->size
1323 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0
1324 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1325 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1330 else if (ABI_64_P (abfd
))
1333 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1339 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1345 /* Check transition from LD access model. Only
1346 leaq foo@tlsld(%rip), %rdi;
1348 can transit to different access model. For largepic
1350 leaq foo@tlsld(%rip), %rdi
1351 movabsq $__tls_get_addr@pltoff, %rax
1355 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1357 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1360 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0)
1363 if (0xe8 != *(contents
+ offset
+ 4))
1365 if (!ABI_64_P (abfd
)
1366 || (offset
+ 19) > sec
->size
1367 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1368 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1375 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1376 if (r_symndx
< symtab_hdr
->sh_info
)
1379 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1380 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1381 may be versioned. */
1383 && h
->root
.root
.string
!= NULL
1385 ? ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLTOFF64
1386 : (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1387 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
))
1388 && (strncmp (h
->root
.root
.string
,
1389 "__tls_get_addr", 14) == 0));
1391 case R_X86_64_GOTTPOFF
:
1392 /* Check transition from IE access model:
1393 mov foo@gottpoff(%rip), %reg
1394 add foo@gottpoff(%rip), %reg
1397 /* Check REX prefix first. */
1398 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1400 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1401 if (val
!= 0x48 && val
!= 0x4c)
1403 /* X32 may have 0x44 REX prefix or no REX prefix. */
1404 if (ABI_64_P (abfd
))
1410 /* X32 may not have any REX prefix. */
1411 if (ABI_64_P (abfd
))
1413 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1417 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1418 if (val
!= 0x8b && val
!= 0x03)
1421 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1422 return (val
& 0xc7) == 5;
1424 case R_X86_64_GOTPC32_TLSDESC
:
1425 /* Check transition from GDesc access model:
1426 leaq x@tlsdesc(%rip), %rax
1428 Make sure it's a leaq adding rip to a 32-bit offset
1429 into any register, although it's probably almost always
1432 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1435 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1436 if ((val
& 0xfb) != 0x48)
1439 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1442 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1443 return (val
& 0xc7) == 0x05;
1445 case R_X86_64_TLSDESC_CALL
:
1446 /* Check transition from GDesc access model:
1447 call *x@tlsdesc(%rax)
1449 if (offset
+ 2 <= sec
->size
)
1451 /* Make sure that it's a call *x@tlsdesc(%rax). */
1452 static const unsigned char call
[] = { 0xff, 0x10 };
1453 return memcmp (contents
+ offset
, call
, 2) == 0;
1463 /* Return TRUE if the TLS access transition is OK or no transition
1464 will be performed. Update R_TYPE if there is a transition. */
1467 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1468 asection
*sec
, bfd_byte
*contents
,
1469 Elf_Internal_Shdr
*symtab_hdr
,
1470 struct elf_link_hash_entry
**sym_hashes
,
1471 unsigned int *r_type
, int tls_type
,
1472 const Elf_Internal_Rela
*rel
,
1473 const Elf_Internal_Rela
*relend
,
1474 struct elf_link_hash_entry
*h
,
1475 unsigned long r_symndx
)
1477 unsigned int from_type
= *r_type
;
1478 unsigned int to_type
= from_type
;
1479 bfd_boolean check
= TRUE
;
1481 /* Skip TLS transition for functions. */
1483 && (h
->type
== STT_FUNC
1484 || h
->type
== STT_GNU_IFUNC
))
1489 case R_X86_64_TLSGD
:
1490 case R_X86_64_GOTPC32_TLSDESC
:
1491 case R_X86_64_TLSDESC_CALL
:
1492 case R_X86_64_GOTTPOFF
:
1493 if (bfd_link_executable (info
))
1496 to_type
= R_X86_64_TPOFF32
;
1498 to_type
= R_X86_64_GOTTPOFF
;
1501 /* When we are called from elf_x86_64_relocate_section,
1502 CONTENTS isn't NULL and there may be additional transitions
1503 based on TLS_TYPE. */
1504 if (contents
!= NULL
)
1506 unsigned int new_to_type
= to_type
;
1508 if (bfd_link_executable (info
)
1511 && tls_type
== GOT_TLS_IE
)
1512 new_to_type
= R_X86_64_TPOFF32
;
1514 if (to_type
== R_X86_64_TLSGD
1515 || to_type
== R_X86_64_GOTPC32_TLSDESC
1516 || to_type
== R_X86_64_TLSDESC_CALL
)
1518 if (tls_type
== GOT_TLS_IE
)
1519 new_to_type
= R_X86_64_GOTTPOFF
;
1522 /* We checked the transition before when we were called from
1523 elf_x86_64_check_relocs. We only want to check the new
1524 transition which hasn't been checked before. */
1525 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1526 to_type
= new_to_type
;
1531 case R_X86_64_TLSLD
:
1532 if (bfd_link_executable (info
))
1533 to_type
= R_X86_64_TPOFF32
;
1540 /* Return TRUE if there is no transition. */
1541 if (from_type
== to_type
)
1544 /* Check if the transition can be performed. */
1546 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1547 symtab_hdr
, sym_hashes
,
1548 from_type
, rel
, relend
))
1550 reloc_howto_type
*from
, *to
;
1553 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1554 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1557 name
= h
->root
.root
.string
;
1560 struct elf_x86_64_link_hash_table
*htab
;
1562 htab
= elf_x86_64_hash_table (info
);
1567 Elf_Internal_Sym
*isym
;
1569 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1571 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1575 (*_bfd_error_handler
)
1576 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1577 "in section `%A' failed"),
1578 abfd
, sec
, from
->name
, to
->name
, name
,
1579 (unsigned long) rel
->r_offset
);
1580 bfd_set_error (bfd_error_bad_value
);
1588 /* Rename some of the generic section flags to better document how they
1590 #define need_convert_load sec_flg0
1592 /* Look through the relocs for a section during the first phase, and
1593 calculate needed space in the global offset table, procedure
1594 linkage table, and dynamic reloc sections. */
1597 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1599 const Elf_Internal_Rela
*relocs
)
1601 struct elf_x86_64_link_hash_table
*htab
;
1602 Elf_Internal_Shdr
*symtab_hdr
;
1603 struct elf_link_hash_entry
**sym_hashes
;
1604 const Elf_Internal_Rela
*rel
;
1605 const Elf_Internal_Rela
*rel_end
;
1607 bfd_boolean use_plt_got
;
1609 if (bfd_link_relocatable (info
))
1612 BFD_ASSERT (is_x86_64_elf (abfd
));
1614 htab
= elf_x86_64_hash_table (info
);
1618 use_plt_got
= get_elf_x86_64_backend_data (abfd
) == &elf_x86_64_arch_bed
;
1620 symtab_hdr
= &elf_symtab_hdr (abfd
);
1621 sym_hashes
= elf_sym_hashes (abfd
);
1625 rel_end
= relocs
+ sec
->reloc_count
;
1626 for (rel
= relocs
; rel
< rel_end
; rel
++)
1628 unsigned int r_type
;
1629 unsigned long r_symndx
;
1630 struct elf_link_hash_entry
*h
;
1631 struct elf_x86_64_link_hash_entry
*eh
;
1632 Elf_Internal_Sym
*isym
;
1634 bfd_boolean size_reloc
;
1636 r_symndx
= htab
->r_sym (rel
->r_info
);
1637 r_type
= ELF32_R_TYPE (rel
->r_info
);
1639 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1641 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1646 if (r_symndx
< symtab_hdr
->sh_info
)
1648 /* A local symbol. */
1649 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1654 /* Check relocation against local STT_GNU_IFUNC symbol. */
1655 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1657 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
1662 /* Fake a STT_GNU_IFUNC symbol. */
1663 h
->type
= STT_GNU_IFUNC
;
1666 h
->forced_local
= 1;
1667 h
->root
.type
= bfd_link_hash_defined
;
1675 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1676 while (h
->root
.type
== bfd_link_hash_indirect
1677 || h
->root
.type
== bfd_link_hash_warning
)
1678 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1681 /* Check invalid x32 relocations. */
1682 if (!ABI_64_P (abfd
))
1688 case R_X86_64_DTPOFF64
:
1689 case R_X86_64_TPOFF64
:
1691 case R_X86_64_GOTOFF64
:
1692 case R_X86_64_GOT64
:
1693 case R_X86_64_GOTPCREL64
:
1694 case R_X86_64_GOTPC64
:
1695 case R_X86_64_GOTPLT64
:
1696 case R_X86_64_PLTOFF64
:
1699 name
= h
->root
.root
.string
;
1701 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1703 (*_bfd_error_handler
)
1704 (_("%B: relocation %s against symbol `%s' isn't "
1705 "supported in x32 mode"), abfd
,
1706 x86_64_elf_howto_table
[r_type
].name
, name
);
1707 bfd_set_error (bfd_error_bad_value
);
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 /* Create the ifunc sections for static executables. */
1774 if (h
->type
== STT_GNU_IFUNC
1775 && !_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
,
1781 /* It is referenced by a non-shared object. */
1783 h
->root
.non_ir_ref
= 1;
1785 if (h
->type
== STT_GNU_IFUNC
)
1786 elf_tdata (info
->output_bfd
)->has_gnu_symbols
1787 |= elf_gnu_symbol_ifunc
;
1790 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
1791 symtab_hdr
, sym_hashes
,
1792 &r_type
, GOT_UNKNOWN
,
1793 rel
, rel_end
, h
, r_symndx
))
1796 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
1799 case R_X86_64_TLSLD
:
1800 htab
->tls_ld_got
.refcount
+= 1;
1803 case R_X86_64_TPOFF32
:
1804 if (!bfd_link_executable (info
) && ABI_64_P (abfd
))
1807 name
= h
->root
.root
.string
;
1809 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1811 (*_bfd_error_handler
)
1812 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1814 x86_64_elf_howto_table
[r_type
].name
, name
);
1815 bfd_set_error (bfd_error_bad_value
);
1819 eh
->has_got_reloc
= 1;
1822 case R_X86_64_GOTTPOFF
:
1823 if (!bfd_link_executable (info
))
1824 info
->flags
|= DF_STATIC_TLS
;
1827 case R_X86_64_GOT32
:
1828 case R_X86_64_GOTPCREL
:
1829 case R_X86_64_GOTPCRELX
:
1830 case R_X86_64_REX_GOTPCRELX
:
1831 case R_X86_64_TLSGD
:
1832 case R_X86_64_GOT64
:
1833 case R_X86_64_GOTPCREL64
:
1834 case R_X86_64_GOTPLT64
:
1835 case R_X86_64_GOTPC32_TLSDESC
:
1836 case R_X86_64_TLSDESC_CALL
:
1837 /* This symbol requires a global offset table entry. */
1839 int tls_type
, old_tls_type
;
1843 default: tls_type
= GOT_NORMAL
; break;
1844 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
1845 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
1846 case R_X86_64_GOTPC32_TLSDESC
:
1847 case R_X86_64_TLSDESC_CALL
:
1848 tls_type
= GOT_TLS_GDESC
; break;
1853 h
->got
.refcount
+= 1;
1854 old_tls_type
= eh
->tls_type
;
1858 bfd_signed_vma
*local_got_refcounts
;
1860 /* This is a global offset table entry for a local symbol. */
1861 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1862 if (local_got_refcounts
== NULL
)
1866 size
= symtab_hdr
->sh_info
;
1867 size
*= sizeof (bfd_signed_vma
)
1868 + sizeof (bfd_vma
) + sizeof (char);
1869 local_got_refcounts
= ((bfd_signed_vma
*)
1870 bfd_zalloc (abfd
, size
));
1871 if (local_got_refcounts
== NULL
)
1873 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1874 elf_x86_64_local_tlsdesc_gotent (abfd
)
1875 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1876 elf_x86_64_local_got_tls_type (abfd
)
1877 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1879 local_got_refcounts
[r_symndx
] += 1;
1881 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
1884 /* If a TLS symbol is accessed using IE at least once,
1885 there is no point to use dynamic model for it. */
1886 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1887 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1888 || tls_type
!= GOT_TLS_IE
))
1890 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
1891 tls_type
= old_tls_type
;
1892 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1893 && GOT_TLS_GD_ANY_P (tls_type
))
1894 tls_type
|= old_tls_type
;
1898 name
= h
->root
.root
.string
;
1900 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
1902 (*_bfd_error_handler
)
1903 (_("%B: '%s' accessed both as normal and thread local symbol"),
1905 bfd_set_error (bfd_error_bad_value
);
1910 if (old_tls_type
!= tls_type
)
1913 eh
->tls_type
= tls_type
;
1915 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1920 case R_X86_64_GOTOFF64
:
1921 case R_X86_64_GOTPC32
:
1922 case R_X86_64_GOTPC64
:
1925 eh
->has_got_reloc
= 1;
1926 if (htab
->elf
.sgot
== NULL
)
1928 if (htab
->elf
.dynobj
== NULL
)
1929 htab
->elf
.dynobj
= abfd
;
1930 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
1936 case R_X86_64_PLT32
:
1937 case R_X86_64_PLT32_BND
:
1938 /* This symbol requires a procedure linkage table entry. We
1939 actually build the entry in adjust_dynamic_symbol,
1940 because this might be a case of linking PIC code which is
1941 never referenced by a dynamic object, in which case we
1942 don't need to generate a procedure linkage table entry
1945 /* If this is a local symbol, we resolve it directly without
1946 creating a procedure linkage table entry. */
1950 eh
->has_got_reloc
= 1;
1952 h
->plt
.refcount
+= 1;
1955 case R_X86_64_PLTOFF64
:
1956 /* This tries to form the 'address' of a function relative
1957 to GOT. For global symbols we need a PLT entry. */
1961 h
->plt
.refcount
+= 1;
1965 case R_X86_64_SIZE32
:
1966 case R_X86_64_SIZE64
:
1971 if (!ABI_64_P (abfd
))
1976 /* Let's help debug shared library creation. These relocs
1977 cannot be used in shared libs. Don't error out for
1978 sections we don't care about, such as debug sections or
1979 non-constant sections, or when relocation overflow check
1981 if (!info
->no_reloc_overflow_check
1982 && bfd_link_pic (info
)
1983 && (sec
->flags
& SEC_ALLOC
) != 0
1984 && (sec
->flags
& SEC_READONLY
) != 0)
1987 name
= h
->root
.root
.string
;
1989 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1990 (*_bfd_error_handler
)
1991 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1992 abfd
, x86_64_elf_howto_table
[r_type
].name
, name
);
1993 bfd_set_error (bfd_error_bad_value
);
2001 case R_X86_64_PC32_BND
:
2005 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2006 eh
->has_non_got_reloc
= 1;
2007 /* STT_GNU_IFUNC symbol must go through PLT even if it is
2008 locally defined and undefined symbol may turn out to be
2009 a STT_GNU_IFUNC symbol later. */
2011 && (bfd_link_executable (info
)
2012 || ((h
->type
== STT_GNU_IFUNC
2013 || h
->root
.type
== bfd_link_hash_undefweak
2014 || h
->root
.type
== bfd_link_hash_undefined
)
2015 && SYMBOLIC_BIND (info
, h
))))
2017 /* If this reloc is in a read-only section, we might
2018 need a copy reloc. We can't check reliably at this
2019 stage whether the section is read-only, as input
2020 sections have not yet been mapped to output sections.
2021 Tentatively set the flag for now, and correct in
2022 adjust_dynamic_symbol. */
2025 /* We may need a .plt entry if the function this reloc
2026 refers to is in a shared lib. */
2027 h
->plt
.refcount
+= 1;
2028 if (r_type
== R_X86_64_PC32
)
2030 /* Since something like ".long foo - ." may be used
2031 as pointer, make sure that PLT is used if foo is
2032 a function defined in a shared library. */
2033 if ((sec
->flags
& SEC_CODE
) == 0)
2034 h
->pointer_equality_needed
= 1;
2036 else if (r_type
!= R_X86_64_PC32_BND
2037 && r_type
!= R_X86_64_PC64
)
2039 h
->pointer_equality_needed
= 1;
2040 /* At run-time, R_X86_64_64 can be resolved for both
2041 x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2042 can only be resolved for x32. */
2043 if ((sec
->flags
& SEC_READONLY
) == 0
2044 && (r_type
== R_X86_64_64
2045 || (!ABI_64_P (abfd
)
2046 && (r_type
== R_X86_64_32
2047 || r_type
== R_X86_64_32S
))))
2048 eh
->func_pointer_refcount
+= 1;
2054 /* If we are creating a shared library, and this is a reloc
2055 against a global symbol, or a non PC relative reloc
2056 against a local symbol, then we need to copy the reloc
2057 into the shared library. However, if we are linking with
2058 -Bsymbolic, we do not need to copy a reloc against a
2059 global symbol which is defined in an object we are
2060 including in the link (i.e., DEF_REGULAR is set). At
2061 this point we have not seen all the input files, so it is
2062 possible that DEF_REGULAR is not set now but will be set
2063 later (it is never cleared). In case of a weak definition,
2064 DEF_REGULAR may be cleared later by a strong definition in
2065 a shared library. We account for that possibility below by
2066 storing information in the relocs_copied field of the hash
2067 table entry. A similar situation occurs when creating
2068 shared libraries and symbol visibility changes render the
2071 If on the other hand, we are creating an executable, we
2072 may need to keep relocations for symbols satisfied by a
2073 dynamic library if we manage to avoid copy relocs for the
2075 if ((bfd_link_pic (info
)
2076 && (sec
->flags
& SEC_ALLOC
) != 0
2077 && (! IS_X86_64_PCREL_TYPE (r_type
)
2079 && (! (bfd_link_pie (info
)
2080 || SYMBOLIC_BIND (info
, h
))
2081 || h
->root
.type
== bfd_link_hash_defweak
2082 || !h
->def_regular
))))
2083 || (ELIMINATE_COPY_RELOCS
2084 && !bfd_link_pic (info
)
2085 && (sec
->flags
& SEC_ALLOC
) != 0
2087 && (h
->root
.type
== bfd_link_hash_defweak
2088 || !h
->def_regular
)))
2090 struct elf_dyn_relocs
*p
;
2091 struct elf_dyn_relocs
**head
;
2093 /* We must copy these reloc types into the output file.
2094 Create a reloc section in dynobj and make room for
2098 if (htab
->elf
.dynobj
== NULL
)
2099 htab
->elf
.dynobj
= abfd
;
2101 sreloc
= _bfd_elf_make_dynamic_reloc_section
2102 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
2103 abfd
, /*rela?*/ TRUE
);
2109 /* If this is a global symbol, we count the number of
2110 relocations we need for this symbol. */
2112 head
= &eh
->dyn_relocs
;
2115 /* Track dynamic relocs needed for local syms too.
2116 We really need local syms available to do this
2121 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2126 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2130 /* Beware of type punned pointers vs strict aliasing
2132 vpp
= &(elf_section_data (s
)->local_dynrel
);
2133 head
= (struct elf_dyn_relocs
**)vpp
;
2137 if (p
== NULL
|| p
->sec
!= sec
)
2139 bfd_size_type amt
= sizeof *p
;
2141 p
= ((struct elf_dyn_relocs
*)
2142 bfd_alloc (htab
->elf
.dynobj
, amt
));
2153 /* Count size relocation as PC-relative relocation. */
2154 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
2159 /* This relocation describes the C++ object vtable hierarchy.
2160 Reconstruct it for later use during GC. */
2161 case R_X86_64_GNU_VTINHERIT
:
2162 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2166 /* This relocation describes which C++ vtable entries are actually
2167 used. Record for later use during GC. */
2168 case R_X86_64_GNU_VTENTRY
:
2169 BFD_ASSERT (h
!= NULL
);
2171 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2181 && h
->plt
.refcount
> 0
2182 && (((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2183 || h
->got
.refcount
> 0)
2184 && htab
->plt_got
== NULL
)
2186 /* Create the GOT procedure linkage table. */
2187 unsigned int plt_got_align
;
2188 const struct elf_backend_data
*bed
;
2190 bed
= get_elf_backend_data (info
->output_bfd
);
2191 BFD_ASSERT (sizeof (elf_x86_64_legacy_plt2_entry
) == 8
2192 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2193 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2196 if (htab
->elf
.dynobj
== NULL
)
2197 htab
->elf
.dynobj
= abfd
;
2199 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2201 (bed
->dynamic_sec_flags
2206 if (htab
->plt_got
== NULL
2207 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2213 if ((r_type
== R_X86_64_GOTPCREL
2214 || r_type
== R_X86_64_GOTPCRELX
2215 || r_type
== R_X86_64_REX_GOTPCRELX
)
2216 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2217 sec
->need_convert_load
= 1;
2223 /* Return the section that should be marked against GC for a given
2227 elf_x86_64_gc_mark_hook (asection
*sec
,
2228 struct bfd_link_info
*info
,
2229 Elf_Internal_Rela
*rel
,
2230 struct elf_link_hash_entry
*h
,
2231 Elf_Internal_Sym
*sym
)
2234 switch (ELF32_R_TYPE (rel
->r_info
))
2236 case R_X86_64_GNU_VTINHERIT
:
2237 case R_X86_64_GNU_VTENTRY
:
2241 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2244 /* Update the got entry reference counts for the section being removed. */
2247 elf_x86_64_gc_sweep_hook (bfd
*abfd
, struct bfd_link_info
*info
,
2249 const Elf_Internal_Rela
*relocs
)
2251 struct elf_x86_64_link_hash_table
*htab
;
2252 Elf_Internal_Shdr
*symtab_hdr
;
2253 struct elf_link_hash_entry
**sym_hashes
;
2254 bfd_signed_vma
*local_got_refcounts
;
2255 const Elf_Internal_Rela
*rel
, *relend
;
2257 if (bfd_link_relocatable (info
))
2260 htab
= elf_x86_64_hash_table (info
);
2264 elf_section_data (sec
)->local_dynrel
= NULL
;
2266 symtab_hdr
= &elf_symtab_hdr (abfd
);
2267 sym_hashes
= elf_sym_hashes (abfd
);
2268 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2270 htab
= elf_x86_64_hash_table (info
);
2271 relend
= relocs
+ sec
->reloc_count
;
2272 for (rel
= relocs
; rel
< relend
; rel
++)
2274 unsigned long r_symndx
;
2275 unsigned int r_type
;
2276 struct elf_link_hash_entry
*h
= NULL
;
2277 bfd_boolean pointer_reloc
;
2279 r_symndx
= htab
->r_sym (rel
->r_info
);
2280 if (r_symndx
>= symtab_hdr
->sh_info
)
2282 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2283 while (h
->root
.type
== bfd_link_hash_indirect
2284 || h
->root
.type
== bfd_link_hash_warning
)
2285 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2289 /* A local symbol. */
2290 Elf_Internal_Sym
*isym
;
2292 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2295 /* Check relocation against local STT_GNU_IFUNC symbol. */
2297 && ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
2299 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
, FALSE
);
2307 struct elf_x86_64_link_hash_entry
*eh
;
2308 struct elf_dyn_relocs
**pp
;
2309 struct elf_dyn_relocs
*p
;
2311 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2313 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
2316 /* Everything must go for SEC. */
2322 r_type
= ELF32_R_TYPE (rel
->r_info
);
2323 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
2324 symtab_hdr
, sym_hashes
,
2325 &r_type
, GOT_UNKNOWN
,
2326 rel
, relend
, h
, r_symndx
))
2329 pointer_reloc
= FALSE
;
2332 case R_X86_64_TLSLD
:
2333 if (htab
->tls_ld_got
.refcount
> 0)
2334 htab
->tls_ld_got
.refcount
-= 1;
2337 case R_X86_64_TLSGD
:
2338 case R_X86_64_GOTPC32_TLSDESC
:
2339 case R_X86_64_TLSDESC_CALL
:
2340 case R_X86_64_GOTTPOFF
:
2341 case R_X86_64_GOT32
:
2342 case R_X86_64_GOTPCREL
:
2343 case R_X86_64_GOTPCRELX
:
2344 case R_X86_64_REX_GOTPCRELX
:
2345 case R_X86_64_GOT64
:
2346 case R_X86_64_GOTPCREL64
:
2347 case R_X86_64_GOTPLT64
:
2350 if (h
->got
.refcount
> 0)
2351 h
->got
.refcount
-= 1;
2352 if (h
->type
== STT_GNU_IFUNC
)
2354 if (h
->plt
.refcount
> 0)
2355 h
->plt
.refcount
-= 1;
2358 else if (local_got_refcounts
!= NULL
)
2360 if (local_got_refcounts
[r_symndx
] > 0)
2361 local_got_refcounts
[r_symndx
] -= 1;
2367 pointer_reloc
= !ABI_64_P (abfd
);
2371 pointer_reloc
= TRUE
;
2377 case R_X86_64_PC32_BND
:
2379 case R_X86_64_SIZE32
:
2380 case R_X86_64_SIZE64
:
2382 if (bfd_link_pic (info
)
2383 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2387 case R_X86_64_PLT32
:
2388 case R_X86_64_PLT32_BND
:
2389 case R_X86_64_PLTOFF64
:
2392 if (h
->plt
.refcount
> 0)
2393 h
->plt
.refcount
-= 1;
2394 if (pointer_reloc
&& (sec
->flags
& SEC_READONLY
) == 0)
2396 struct elf_x86_64_link_hash_entry
*eh
2397 = (struct elf_x86_64_link_hash_entry
*) h
;
2398 if (eh
->func_pointer_refcount
> 0)
2399 eh
->func_pointer_refcount
-= 1;
2412 /* Remove undefined weak symbol from the dynamic symbol table if it
2413 is resolved to 0. */
2416 elf_x86_64_fixup_symbol (struct bfd_link_info
*info
,
2417 struct elf_link_hash_entry
*h
)
2419 if (h
->dynindx
!= -1
2420 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2421 elf_x86_64_hash_entry (h
)))
2424 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2430 /* Adjust a symbol defined by a dynamic object and referenced by a
2431 regular object. The current definition is in some section of the
2432 dynamic object, but we're not including those sections. We have to
2433 change the definition to something the rest of the link can
2437 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2438 struct elf_link_hash_entry
*h
)
2440 struct elf_x86_64_link_hash_table
*htab
;
2442 struct elf_x86_64_link_hash_entry
*eh
;
2443 struct elf_dyn_relocs
*p
;
2445 /* STT_GNU_IFUNC symbol must go through PLT. */
2446 if (h
->type
== STT_GNU_IFUNC
)
2448 /* All local STT_GNU_IFUNC references must be treate as local
2449 calls via local PLT. */
2451 && SYMBOL_CALLS_LOCAL (info
, h
))
2453 bfd_size_type pc_count
= 0, count
= 0;
2454 struct elf_dyn_relocs
**pp
;
2456 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2457 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2459 pc_count
+= p
->pc_count
;
2460 p
->count
-= p
->pc_count
;
2469 if (pc_count
|| count
)
2473 if (h
->plt
.refcount
<= 0)
2474 h
->plt
.refcount
= 1;
2476 h
->plt
.refcount
+= 1;
2480 if (h
->plt
.refcount
<= 0)
2482 h
->plt
.offset
= (bfd_vma
) -1;
2488 /* If this is a function, put it in the procedure linkage table. We
2489 will fill in the contents of the procedure linkage table later,
2490 when we know the address of the .got section. */
2491 if (h
->type
== STT_FUNC
2494 if (h
->plt
.refcount
<= 0
2495 || SYMBOL_CALLS_LOCAL (info
, h
)
2496 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2497 && h
->root
.type
== bfd_link_hash_undefweak
))
2499 /* This case can occur if we saw a PLT32 reloc in an input
2500 file, but the symbol was never referred to by a dynamic
2501 object, or if all references were garbage collected. In
2502 such a case, we don't actually need to build a procedure
2503 linkage table, and we can just do a PC32 reloc instead. */
2504 h
->plt
.offset
= (bfd_vma
) -1;
2511 /* It's possible that we incorrectly decided a .plt reloc was
2512 needed for an R_X86_64_PC32 reloc to a non-function sym in
2513 check_relocs. We can't decide accurately between function and
2514 non-function syms in check-relocs; Objects loaded later in
2515 the link may change h->type. So fix it now. */
2516 h
->plt
.offset
= (bfd_vma
) -1;
2518 /* If this is a weak symbol, and there is a real definition, the
2519 processor independent code will have arranged for us to see the
2520 real definition first, and we can just use the same value. */
2521 if (h
->u
.weakdef
!= NULL
)
2523 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2524 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2525 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2526 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2527 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2529 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2530 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2531 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
2536 /* This is a reference to a symbol defined by a dynamic object which
2537 is not a function. */
2539 /* If we are creating a shared library, we must presume that the
2540 only references to the symbol are via the global offset table.
2541 For such cases we need not do anything here; the relocations will
2542 be handled correctly by relocate_section. */
2543 if (!bfd_link_executable (info
))
2546 /* If there are no references to this symbol that do not use the
2547 GOT, we don't need to generate a copy reloc. */
2548 if (!h
->non_got_ref
)
2551 /* If -z nocopyreloc was given, we won't generate them either. */
2552 if (info
->nocopyreloc
)
2558 if (ELIMINATE_COPY_RELOCS
)
2560 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2561 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2563 s
= p
->sec
->output_section
;
2564 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2568 /* If we didn't find any dynamic relocs in read-only sections, then
2569 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2577 /* We must allocate the symbol in our .dynbss section, which will
2578 become part of the .bss section of the executable. There will be
2579 an entry for this symbol in the .dynsym section. The dynamic
2580 object will contain position independent code, so all references
2581 from the dynamic object to this symbol will go through the global
2582 offset table. The dynamic linker will use the .dynsym entry to
2583 determine the address it must put in the global offset table, so
2584 both the dynamic object and the regular object will refer to the
2585 same memory location for the variable. */
2587 htab
= elf_x86_64_hash_table (info
);
2591 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2592 to copy the initial value out of the dynamic object and into the
2593 runtime process image. */
2594 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2596 const struct elf_backend_data
*bed
;
2597 bed
= get_elf_backend_data (info
->output_bfd
);
2598 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
2604 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2607 /* Allocate space in .plt, .got and associated reloc sections for
2611 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2613 struct bfd_link_info
*info
;
2614 struct elf_x86_64_link_hash_table
*htab
;
2615 struct elf_x86_64_link_hash_entry
*eh
;
2616 struct elf_dyn_relocs
*p
;
2617 const struct elf_backend_data
*bed
;
2618 unsigned int plt_entry_size
;
2619 bfd_boolean resolved_to_zero
;
2621 if (h
->root
.type
== bfd_link_hash_indirect
)
2624 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2626 info
= (struct bfd_link_info
*) inf
;
2627 htab
= elf_x86_64_hash_table (info
);
2630 bed
= get_elf_backend_data (info
->output_bfd
);
2631 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2633 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, eh
);
2635 /* We can't use the GOT PLT if pointer equality is needed since
2636 finish_dynamic_symbol won't clear symbol value and the dynamic
2637 linker won't update the GOT slot. We will get into an infinite
2638 loop at run-time. */
2639 if (htab
->plt_got
!= NULL
2640 && h
->type
!= STT_GNU_IFUNC
2641 && !h
->pointer_equality_needed
2642 && h
->plt
.refcount
> 0
2643 && h
->got
.refcount
> 0)
2645 /* Don't use the regular PLT if there are both GOT and GOTPLT
2647 h
->plt
.offset
= (bfd_vma
) -1;
2649 /* Use the GOT PLT. */
2650 eh
->plt_got
.refcount
= 1;
2653 /* Clear the reference count of function pointer relocations if
2654 symbol isn't a normal function. */
2655 if (h
->type
!= STT_FUNC
)
2656 eh
->func_pointer_refcount
= 0;
2658 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2659 here if it is defined and referenced in a non-shared object. */
2660 if (h
->type
== STT_GNU_IFUNC
2663 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
2665 &htab
->readonly_dynrelocs_against_ifunc
,
2670 asection
*s
= htab
->plt_bnd
;
2671 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
2673 /* Use the .plt.bnd section if it is created. */
2674 eh
->plt_bnd
.offset
= s
->size
;
2676 /* Make room for this entry in the .plt.bnd section. */
2677 s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2685 /* Don't create the PLT entry if there are only function pointer
2686 relocations which can be resolved at run-time. */
2687 else if (htab
->elf
.dynamic_sections_created
2688 && (h
->plt
.refcount
> eh
->func_pointer_refcount
2689 || eh
->plt_got
.refcount
> 0))
2691 bfd_boolean use_plt_got
;
2693 /* Clear the reference count of function pointer relocations
2695 eh
->func_pointer_refcount
= 0;
2697 if ((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2699 /* Don't use the regular PLT for DF_BIND_NOW. */
2700 h
->plt
.offset
= (bfd_vma
) -1;
2702 /* Use the GOT PLT. */
2703 h
->got
.refcount
= 1;
2704 eh
->plt_got
.refcount
= 1;
2707 use_plt_got
= eh
->plt_got
.refcount
> 0;
2709 /* Make sure this symbol is output as a dynamic symbol.
2710 Undefined weak syms won't yet be marked as dynamic. */
2711 if (h
->dynindx
== -1
2713 && !resolved_to_zero
)
2715 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2719 if (bfd_link_pic (info
)
2720 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2722 asection
*s
= htab
->elf
.splt
;
2723 asection
*bnd_s
= htab
->plt_bnd
;
2724 asection
*got_s
= htab
->plt_got
;
2726 /* If this is the first .plt entry, make room for the special
2727 first entry. The .plt section is used by prelink to undo
2728 prelinking for dynamic relocations. */
2730 s
->size
= plt_entry_size
;
2733 eh
->plt_got
.offset
= got_s
->size
;
2736 h
->plt
.offset
= s
->size
;
2738 eh
->plt_bnd
.offset
= bnd_s
->size
;
2741 /* If this symbol is not defined in a regular file, and we are
2742 not generating a shared library, then set the symbol to this
2743 location in the .plt. This is required to make function
2744 pointers compare as equal between the normal executable and
2745 the shared library. */
2746 if (! bfd_link_pic (info
)
2751 /* We need to make a call to the entry of the GOT PLT
2752 instead of regular PLT entry. */
2753 h
->root
.u
.def
.section
= got_s
;
2754 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
2760 /* We need to make a call to the entry of the second
2761 PLT instead of regular PLT entry. */
2762 h
->root
.u
.def
.section
= bnd_s
;
2763 h
->root
.u
.def
.value
= eh
->plt_bnd
.offset
;
2767 h
->root
.u
.def
.section
= s
;
2768 h
->root
.u
.def
.value
= h
->plt
.offset
;
2773 /* Make room for this entry. */
2775 got_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2778 s
->size
+= plt_entry_size
;
2780 bnd_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2782 /* We also need to make an entry in the .got.plt section,
2783 which will be placed in the .got section by the linker
2785 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
2787 /* There should be no PLT relocation against resolved
2788 undefined weak symbol in executable. */
2789 if (!resolved_to_zero
)
2791 /* We also need to make an entry in the .rela.plt
2793 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2794 htab
->elf
.srelplt
->reloc_count
++;
2800 eh
->plt_got
.offset
= (bfd_vma
) -1;
2801 h
->plt
.offset
= (bfd_vma
) -1;
2807 eh
->plt_got
.offset
= (bfd_vma
) -1;
2808 h
->plt
.offset
= (bfd_vma
) -1;
2812 eh
->tlsdesc_got
= (bfd_vma
) -1;
2814 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2815 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2816 if (h
->got
.refcount
> 0
2817 && bfd_link_executable (info
)
2819 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
2821 h
->got
.offset
= (bfd_vma
) -1;
2823 else if (h
->got
.refcount
> 0)
2827 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
2829 /* Make sure this symbol is output as a dynamic symbol.
2830 Undefined weak syms won't yet be marked as dynamic. */
2831 if (h
->dynindx
== -1
2833 && !resolved_to_zero
)
2835 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2839 if (GOT_TLS_GDESC_P (tls_type
))
2841 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2842 - elf_x86_64_compute_jump_table_size (htab
);
2843 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2844 h
->got
.offset
= (bfd_vma
) -2;
2846 if (! GOT_TLS_GDESC_P (tls_type
)
2847 || GOT_TLS_GD_P (tls_type
))
2850 h
->got
.offset
= s
->size
;
2851 s
->size
+= GOT_ENTRY_SIZE
;
2852 if (GOT_TLS_GD_P (tls_type
))
2853 s
->size
+= GOT_ENTRY_SIZE
;
2855 dyn
= htab
->elf
.dynamic_sections_created
;
2856 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2857 and two if global. R_X86_64_GOTTPOFF needs one dynamic
2858 relocation. No dynamic relocation against resolved undefined
2859 weak symbol in executable. */
2860 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2861 || tls_type
== GOT_TLS_IE
)
2862 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2863 else if (GOT_TLS_GD_P (tls_type
))
2864 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
2865 else if (! GOT_TLS_GDESC_P (tls_type
)
2866 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2867 && !resolved_to_zero
)
2868 || h
->root
.type
!= bfd_link_hash_undefweak
)
2869 && (bfd_link_pic (info
)
2870 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2871 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2872 if (GOT_TLS_GDESC_P (tls_type
))
2874 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2875 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2879 h
->got
.offset
= (bfd_vma
) -1;
2881 if (eh
->dyn_relocs
== NULL
)
2884 /* In the shared -Bsymbolic case, discard space allocated for
2885 dynamic pc-relative relocs against symbols which turn out to be
2886 defined in regular objects. For the normal shared case, discard
2887 space for pc-relative relocs that have become local due to symbol
2888 visibility changes. */
2890 if (bfd_link_pic (info
))
2892 /* Relocs that use pc_count are those that appear on a call
2893 insn, or certain REL relocs that can generated via assembly.
2894 We want calls to protected symbols to resolve directly to the
2895 function rather than going via the plt. If people want
2896 function pointer comparisons to work as expected then they
2897 should avoid writing weird assembly. */
2898 if (SYMBOL_CALLS_LOCAL (info
, h
))
2900 struct elf_dyn_relocs
**pp
;
2902 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2904 p
->count
-= p
->pc_count
;
2913 /* Also discard relocs on undefined weak syms with non-default
2914 visibility or in PIE. */
2915 if (eh
->dyn_relocs
!= NULL
)
2917 if (h
->root
.type
== bfd_link_hash_undefweak
)
2919 /* Undefined weak symbol is never bound locally in shared
2921 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2922 || resolved_to_zero
)
2923 eh
->dyn_relocs
= NULL
;
2924 else if (h
->dynindx
== -1
2925 && ! h
->forced_local
2926 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2929 /* For PIE, discard space for pc-relative relocs against
2930 symbols which turn out to need copy relocs. */
2931 else if (bfd_link_executable (info
)
2932 && (h
->needs_copy
|| eh
->needs_copy
)
2936 struct elf_dyn_relocs
**pp
;
2938 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2940 if (p
->pc_count
!= 0)
2948 else if (ELIMINATE_COPY_RELOCS
)
2950 /* For the non-shared case, discard space for relocs against
2951 symbols which turn out to need copy relocs or are not
2952 dynamic. Keep dynamic relocations for run-time function
2953 pointer initialization. */
2955 if ((!h
->non_got_ref
2956 || eh
->func_pointer_refcount
> 0
2957 || (h
->root
.type
== bfd_link_hash_undefweak
2958 && !resolved_to_zero
))
2961 || (htab
->elf
.dynamic_sections_created
2962 && (h
->root
.type
== bfd_link_hash_undefweak
2963 || h
->root
.type
== bfd_link_hash_undefined
))))
2965 /* Make sure this symbol is output as a dynamic symbol.
2966 Undefined weak syms won't yet be marked as dynamic. */
2967 if (h
->dynindx
== -1
2968 && ! h
->forced_local
2969 && ! resolved_to_zero
2970 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2973 /* If that succeeded, we know we'll be keeping all the
2975 if (h
->dynindx
!= -1)
2979 eh
->dyn_relocs
= NULL
;
2980 eh
->func_pointer_refcount
= 0;
2985 /* Finally, allocate space. */
2986 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2990 sreloc
= elf_section_data (p
->sec
)->sreloc
;
2992 BFD_ASSERT (sreloc
!= NULL
);
2994 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3000 /* Allocate space in .plt, .got and associated reloc sections for
3001 local dynamic relocs. */
3004 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
3006 struct elf_link_hash_entry
*h
3007 = (struct elf_link_hash_entry
*) *slot
;
3009 if (h
->type
!= STT_GNU_IFUNC
3013 || h
->root
.type
!= bfd_link_hash_defined
)
3016 return elf_x86_64_allocate_dynrelocs (h
, inf
);
3019 /* Find any dynamic relocs that apply to read-only sections. */
3022 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
3025 struct elf_x86_64_link_hash_entry
*eh
;
3026 struct elf_dyn_relocs
*p
;
3028 /* Skip local IFUNC symbols. */
3029 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
3032 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3033 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3035 asection
*s
= p
->sec
->output_section
;
3037 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
3039 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3041 info
->flags
|= DF_TEXTREL
;
3043 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3044 || info
->error_textrel
)
3045 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
3046 p
->sec
->owner
, h
->root
.root
.string
,
3049 /* Not an error, just cut short the traversal. */
3056 /* With the local symbol, foo, we convert
3057 mov foo@GOTPCREL(%rip), %reg
3061 call/jmp *foo@GOTPCREL(%rip)
3063 nop call foo/jmp foo nop
3064 When PIC is false, convert
3065 test %reg, foo@GOTPCREL(%rip)
3069 binop foo@GOTPCREL(%rip), %reg
3072 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
3076 elf_x86_64_convert_load (bfd
*abfd
, asection
*sec
,
3077 struct bfd_link_info
*link_info
)
3079 Elf_Internal_Shdr
*symtab_hdr
;
3080 Elf_Internal_Rela
*internal_relocs
;
3081 Elf_Internal_Rela
*irel
, *irelend
;
3083 struct elf_x86_64_link_hash_table
*htab
;
3084 bfd_boolean changed_contents
;
3085 bfd_boolean changed_relocs
;
3086 bfd_signed_vma
*local_got_refcounts
;
3087 bfd_vma maxpagesize
;
3089 bfd_boolean require_reloc_pc32
;
3091 /* Don't even try to convert non-ELF outputs. */
3092 if (!is_elf_hash_table (link_info
->hash
))
3095 /* Nothing to do if there is no need or no output. */
3096 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
3097 || sec
->need_convert_load
== 0
3098 || bfd_is_abs_section (sec
->output_section
))
3101 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3103 /* Load the relocations for this section. */
3104 internal_relocs
= (_bfd_elf_link_read_relocs
3105 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
3106 link_info
->keep_memory
));
3107 if (internal_relocs
== NULL
)
3110 htab
= elf_x86_64_hash_table (link_info
);
3111 changed_contents
= FALSE
;
3112 changed_relocs
= FALSE
;
3113 local_got_refcounts
= elf_local_got_refcounts (abfd
);
3114 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
3116 /* Get the section contents. */
3117 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
3118 contents
= elf_section_data (sec
)->this_hdr
.contents
;
3121 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
3125 is_pic
= bfd_link_pic (link_info
);
3127 /* TRUE if we can convert only to R_X86_64_PC32. Enable it for
3130 = link_info
->disable_target_specific_optimizations
> 1;
3132 irelend
= internal_relocs
+ sec
->reloc_count
;
3133 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3135 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
3136 unsigned int r_symndx
= htab
->r_sym (irel
->r_info
);
3138 struct elf_link_hash_entry
*h
;
3142 bfd_signed_vma raddend
;
3143 unsigned int opcode
;
3146 bfd_boolean to_reloc_pc32
;
3148 relocx
= (r_type
== R_X86_64_GOTPCRELX
3149 || r_type
== R_X86_64_REX_GOTPCRELX
);
3150 if (!relocx
&& r_type
!= R_X86_64_GOTPCREL
)
3153 roff
= irel
->r_offset
;
3154 if (roff
< (r_type
== R_X86_64_REX_GOTPCRELX
? 3 : 2))
3157 raddend
= irel
->r_addend
;
3158 /* Addend for 32-bit PC-relative relocation must be -4. */
3162 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
3164 /* Convert mov to lea since it has been done for a while. */
3167 /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
3168 for call, jmp or one of adc, add, and, cmp, or, sbb, sub,
3169 test, xor instructions. */
3174 /* We convert only to R_X86_64_PC32:
3176 2. R_X86_64_GOTPCREL since we can't modify REX byte.
3177 3. require_reloc_pc32 is true.
3180 to_reloc_pc32
= (opcode
== 0xff
3182 || require_reloc_pc32
3185 /* Get the symbol referred to by the reloc. */
3186 if (r_symndx
< symtab_hdr
->sh_info
)
3188 Elf_Internal_Sym
*isym
;
3190 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
3193 symtype
= ELF_ST_TYPE (isym
->st_info
);
3195 /* STT_GNU_IFUNC must keep GOTPCREL relocations and skip
3196 relocation against undefined symbols. */
3197 if (symtype
== STT_GNU_IFUNC
|| isym
->st_shndx
== SHN_UNDEF
)
3200 if (isym
->st_shndx
== SHN_ABS
)
3201 tsec
= bfd_abs_section_ptr
;
3202 else if (isym
->st_shndx
== SHN_COMMON
)
3203 tsec
= bfd_com_section_ptr
;
3204 else if (isym
->st_shndx
== SHN_X86_64_LCOMMON
)
3205 tsec
= &_bfd_elf_large_com_section
;
3207 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
3210 toff
= isym
->st_value
;
3214 indx
= r_symndx
- symtab_hdr
->sh_info
;
3215 h
= elf_sym_hashes (abfd
)[indx
];
3216 BFD_ASSERT (h
!= NULL
);
3218 while (h
->root
.type
== bfd_link_hash_indirect
3219 || h
->root
.type
== bfd_link_hash_warning
)
3220 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3222 /* STT_GNU_IFUNC must keep GOTPCREL relocations. We also
3223 avoid optimizing GOTPCREL relocations againt _DYNAMIC
3224 since ld.so may use its link-time address. */
3225 if (h
->type
== STT_GNU_IFUNC
)
3228 /* Undefined weak symbol is only bound locally in executable
3229 and its reference is resolved as 0 without relocation
3230 overflow. We can only perform this optimization for
3231 GOTPCRELX relocations since we need to modify REX byte.
3232 It is OK convert mov with R_X86_64_GOTPCREL to
3234 if ((relocx
|| opcode
== 0x8b)
3235 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
,
3236 elf_x86_64_hash_entry (h
)))
3240 /* Skip for branch instructions since R_X86_64_PC32
3242 if (require_reloc_pc32
)
3247 /* For non-branch instructions, we can convert to
3248 R_X86_64_32/R_X86_64_32S since we know if there
3250 to_reloc_pc32
= FALSE
;
3253 /* Since we don't know the current PC when PIC is true,
3254 we can't convert to R_X86_64_PC32. */
3255 if (to_reloc_pc32
&& is_pic
)
3260 else if ((h
->def_regular
3261 || h
->root
.type
== bfd_link_hash_defined
3262 || h
->root
.type
== bfd_link_hash_defweak
)
3263 && h
!= htab
->elf
.hdynamic
3264 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
3266 /* bfd_link_hash_new or bfd_link_hash_undefined is
3267 set by an assignment in a linker script in
3268 bfd_elf_record_link_assignment. */
3270 && (h
->root
.type
== bfd_link_hash_new
3271 || h
->root
.type
== bfd_link_hash_undefined
))
3273 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */
3274 if (require_reloc_pc32
)
3278 tsec
= h
->root
.u
.def
.section
;
3279 toff
= h
->root
.u
.def
.value
;
3286 /* We can only estimate relocation overflow for R_X86_64_PC32. */
3290 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
3292 /* At this stage in linking, no SEC_MERGE symbol has been
3293 adjusted, so all references to such symbols need to be
3294 passed through _bfd_merged_section_offset. (Later, in
3295 relocate_section, all SEC_MERGE symbols *except* for
3296 section symbols have been adjusted.)
3298 gas may reduce relocations against symbols in SEC_MERGE
3299 sections to a relocation against the section symbol when
3300 the original addend was zero. When the reloc is against
3301 a section symbol we should include the addend in the
3302 offset passed to _bfd_merged_section_offset, since the
3303 location of interest is the original symbol. On the
3304 other hand, an access to "sym+addend" where "sym" is not
3305 a section symbol should not include the addend; Such an
3306 access is presumed to be an offset from "sym"; The
3307 location of interest is just "sym". */
3308 if (symtype
== STT_SECTION
)
3311 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
3312 elf_section_data (tsec
)->sec_info
,
3315 if (symtype
!= STT_SECTION
)
3321 /* Don't convert if R_X86_64_PC32 relocation overflows. */
3322 if (tsec
->output_section
== sec
->output_section
)
3324 if ((toff
- roff
+ 0x80000000) > 0xffffffff)
3329 bfd_signed_vma distance
;
3331 /* At this point, we don't know the load addresses of TSEC
3332 section nor SEC section. We estimate the distrance between
3333 SEC and TSEC. We store the estimated distances in the
3334 compressed_size field of the output section, which is only
3335 used to decompress the compressed input section. */
3336 if (sec
->output_section
->compressed_size
== 0)
3339 bfd_size_type size
= 0;
3340 for (asect
= link_info
->output_bfd
->sections
;
3342 asect
= asect
->next
)
3345 for (i
= asect
->map_head
.s
;
3349 size
= align_power (size
, i
->alignment_power
);
3352 asect
->compressed_size
= size
;
3356 /* Don't convert GOTPCREL relocations if TSEC isn't placed
3358 distance
= (tsec
->output_section
->compressed_size
3359 - sec
->output_section
->compressed_size
);
3363 /* Take PT_GNU_RELRO segment into account by adding
3365 if ((toff
+ distance
+ maxpagesize
- roff
+ 0x80000000)
3373 /* We have "call/jmp *foo@GOTPCREL(%rip)". */
3378 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
3380 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
3383 /* Convert to "jmp foo nop". */
3386 nop_offset
= irel
->r_offset
+ 3;
3387 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
3388 irel
->r_offset
-= 1;
3389 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
3393 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
3396 nop
= link_info
->call_nop_byte
;
3397 if (link_info
->call_nop_as_suffix
)
3399 nop_offset
= irel
->r_offset
+ 3;
3400 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
3401 irel
->r_offset
-= 1;
3402 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
3405 nop_offset
= irel
->r_offset
- 2;
3407 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
3408 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
3409 r_type
= R_X86_64_PC32
;
3414 unsigned int rex_mask
= REX_R
;
3416 if (r_type
== R_X86_64_REX_GOTPCRELX
)
3417 rex
= bfd_get_8 (abfd
, contents
+ roff
- 3);
3425 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
3426 "lea foo(%rip), %reg". */
3428 r_type
= R_X86_64_PC32
;
3432 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
3433 "mov $foo, %reg". */
3435 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
3436 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
3437 if ((rex
& REX_W
) != 0
3438 && ABI_64_P (link_info
->output_bfd
))
3440 /* Keep the REX_W bit in REX byte for LP64. */
3441 r_type
= R_X86_64_32S
;
3442 goto rewrite_modrm_rex
;
3446 /* If the REX_W bit in REX byte isn't needed,
3447 use R_X86_64_32 and clear the W bit to avoid
3448 sign-extend imm32 to imm64. */
3449 r_type
= R_X86_64_32
;
3450 /* Clear the W bit in REX byte. */
3452 goto rewrite_modrm_rex
;
3458 /* R_X86_64_PC32 isn't supported. */
3462 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
3465 /* Convert "test %reg, foo@GOTPCREL(%rip)" to
3466 "test $foo, %reg". */
3467 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
3472 /* Convert "binop foo@GOTPCREL(%rip), %reg" to
3473 "binop $foo, %reg". */
3474 modrm
= 0xc0 | (modrm
& 0x38) >> 3 | (opcode
& 0x3c);
3478 /* Use R_X86_64_32 with 32-bit operand to avoid relocation
3479 overflow when sign-extending imm32 to imm64. */
3480 r_type
= (rex
& REX_W
) != 0 ? R_X86_64_32S
: R_X86_64_32
;
3483 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
3487 /* Move the R bit to the B bit in REX byte. */
3488 rex
= (rex
& ~rex_mask
) | (rex
& REX_R
) >> 2;
3489 bfd_put_8 (abfd
, rex
, contents
+ roff
- 3);
3492 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */
3496 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
3499 irel
->r_info
= htab
->r_info (r_symndx
, r_type
);
3500 changed_contents
= TRUE
;
3501 changed_relocs
= TRUE
;
3505 if (h
->got
.refcount
> 0)
3506 h
->got
.refcount
-= 1;
3510 if (local_got_refcounts
!= NULL
3511 && local_got_refcounts
[r_symndx
] > 0)
3512 local_got_refcounts
[r_symndx
] -= 1;
3516 if (contents
!= NULL
3517 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3519 if (!changed_contents
&& !link_info
->keep_memory
)
3523 /* Cache the section contents for elf_link_input_bfd. */
3524 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3528 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3530 if (!changed_relocs
)
3531 free (internal_relocs
);
3533 elf_section_data (sec
)->relocs
= internal_relocs
;
3539 if (contents
!= NULL
3540 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3542 if (internal_relocs
!= NULL
3543 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3544 free (internal_relocs
);
3548 /* Set the sizes of the dynamic sections. */
3551 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
3552 struct bfd_link_info
*info
)
3554 struct elf_x86_64_link_hash_table
*htab
;
3559 const struct elf_backend_data
*bed
;
3561 htab
= elf_x86_64_hash_table (info
);
3564 bed
= get_elf_backend_data (output_bfd
);
3566 dynobj
= htab
->elf
.dynobj
;
3570 if (htab
->elf
.dynamic_sections_created
)
3572 /* Set the contents of the .interp section to the interpreter. */
3573 if (bfd_link_executable (info
) && !info
->nointerp
)
3575 s
= bfd_get_linker_section (dynobj
, ".interp");
3578 s
->size
= htab
->dynamic_interpreter_size
;
3579 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
3584 /* Set up .got offsets for local syms, and space for local dynamic
3586 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3588 bfd_signed_vma
*local_got
;
3589 bfd_signed_vma
*end_local_got
;
3590 char *local_tls_type
;
3591 bfd_vma
*local_tlsdesc_gotent
;
3592 bfd_size_type locsymcount
;
3593 Elf_Internal_Shdr
*symtab_hdr
;
3596 if (! is_x86_64_elf (ibfd
))
3599 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3601 struct elf_dyn_relocs
*p
;
3603 if (!elf_x86_64_convert_load (ibfd
, s
, info
))
3606 for (p
= (struct elf_dyn_relocs
*)
3607 (elf_section_data (s
)->local_dynrel
);
3611 if (!bfd_is_abs_section (p
->sec
)
3612 && bfd_is_abs_section (p
->sec
->output_section
))
3614 /* Input section has been discarded, either because
3615 it is a copy of a linkonce section or due to
3616 linker script /DISCARD/, so we'll be discarding
3619 else if (p
->count
!= 0)
3621 srel
= elf_section_data (p
->sec
)->sreloc
;
3622 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3623 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3624 && (info
->flags
& DF_TEXTREL
) == 0)
3626 info
->flags
|= DF_TEXTREL
;
3627 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3628 || info
->error_textrel
)
3629 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3630 p
->sec
->owner
, p
->sec
);
3636 local_got
= elf_local_got_refcounts (ibfd
);
3640 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3641 locsymcount
= symtab_hdr
->sh_info
;
3642 end_local_got
= local_got
+ locsymcount
;
3643 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
3644 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
3646 srel
= htab
->elf
.srelgot
;
3647 for (; local_got
< end_local_got
;
3648 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3650 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3653 if (GOT_TLS_GDESC_P (*local_tls_type
))
3655 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3656 - elf_x86_64_compute_jump_table_size (htab
);
3657 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3658 *local_got
= (bfd_vma
) -2;
3660 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3661 || GOT_TLS_GD_P (*local_tls_type
))
3663 *local_got
= s
->size
;
3664 s
->size
+= GOT_ENTRY_SIZE
;
3665 if (GOT_TLS_GD_P (*local_tls_type
))
3666 s
->size
+= GOT_ENTRY_SIZE
;
3668 if (bfd_link_pic (info
)
3669 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3670 || *local_tls_type
== GOT_TLS_IE
)
3672 if (GOT_TLS_GDESC_P (*local_tls_type
))
3674 htab
->elf
.srelplt
->size
3675 += bed
->s
->sizeof_rela
;
3676 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3678 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3679 || GOT_TLS_GD_P (*local_tls_type
))
3680 srel
->size
+= bed
->s
->sizeof_rela
;
3684 *local_got
= (bfd_vma
) -1;
3688 if (htab
->tls_ld_got
.refcount
> 0)
3690 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3692 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
3693 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
3694 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3697 htab
->tls_ld_got
.offset
= -1;
3699 /* Allocate global sym .plt and .got entries, and space for global
3700 sym dynamic relocs. */
3701 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
3704 /* Allocate .plt and .got entries, and space for local symbols. */
3705 htab_traverse (htab
->loc_hash_table
,
3706 elf_x86_64_allocate_local_dynrelocs
,
3709 /* For every jump slot reserved in the sgotplt, reloc_count is
3710 incremented. However, when we reserve space for TLS descriptors,
3711 it's not incremented, so in order to compute the space reserved
3712 for them, it suffices to multiply the reloc count by the jump
3715 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3716 so that R_X86_64_IRELATIVE entries come last. */
3717 if (htab
->elf
.srelplt
)
3719 htab
->sgotplt_jump_table_size
3720 = elf_x86_64_compute_jump_table_size (htab
);
3721 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3723 else if (htab
->elf
.irelplt
)
3724 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3726 if (htab
->tlsdesc_plt
)
3728 /* If we're not using lazy TLS relocations, don't generate the
3729 PLT and GOT entries they require. */
3730 if ((info
->flags
& DF_BIND_NOW
))
3731 htab
->tlsdesc_plt
= 0;
3734 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
3735 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
3736 /* Reserve room for the initial entry.
3737 FIXME: we could probably do away with it in this case. */
3738 if (htab
->elf
.splt
->size
== 0)
3739 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3740 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
3741 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3745 if (htab
->elf
.sgotplt
)
3747 /* Don't allocate .got.plt section if there are no GOT nor PLT
3748 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3749 if ((htab
->elf
.hgot
== NULL
3750 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3751 && (htab
->elf
.sgotplt
->size
3752 == get_elf_backend_data (output_bfd
)->got_header_size
)
3753 && (htab
->elf
.splt
== NULL
3754 || htab
->elf
.splt
->size
== 0)
3755 && (htab
->elf
.sgot
== NULL
3756 || htab
->elf
.sgot
->size
== 0)
3757 && (htab
->elf
.iplt
== NULL
3758 || htab
->elf
.iplt
->size
== 0)
3759 && (htab
->elf
.igotplt
== NULL
3760 || htab
->elf
.igotplt
->size
== 0))
3761 htab
->elf
.sgotplt
->size
= 0;
3764 if (htab
->plt_eh_frame
!= NULL
3765 && htab
->elf
.splt
!= NULL
3766 && htab
->elf
.splt
->size
!= 0
3767 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3768 && _bfd_elf_eh_frame_present (info
))
3770 const struct elf_x86_64_backend_data
*arch_data
3771 = get_elf_x86_64_arch_data (bed
);
3772 htab
->plt_eh_frame
->size
= arch_data
->eh_frame_plt_size
;
3775 /* We now have determined the sizes of the various dynamic sections.
3776 Allocate memory for them. */
3778 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3780 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3783 if (s
== htab
->elf
.splt
3784 || s
== htab
->elf
.sgot
3785 || s
== htab
->elf
.sgotplt
3786 || s
== htab
->elf
.iplt
3787 || s
== htab
->elf
.igotplt
3788 || s
== htab
->plt_bnd
3789 || s
== htab
->plt_got
3790 || s
== htab
->plt_eh_frame
3791 || s
== htab
->sdynbss
)
3793 /* Strip this section if we don't need it; see the
3796 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3798 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
3801 /* We use the reloc_count field as a counter if we need
3802 to copy relocs into the output file. */
3803 if (s
!= htab
->elf
.srelplt
)
3808 /* It's not one of our sections, so don't allocate space. */
3814 /* If we don't need this section, strip it from the
3815 output file. This is mostly to handle .rela.bss and
3816 .rela.plt. We must create both sections in
3817 create_dynamic_sections, because they must be created
3818 before the linker maps input sections to output
3819 sections. The linker does that before
3820 adjust_dynamic_symbol is called, and it is that
3821 function which decides whether anything needs to go
3822 into these sections. */
3824 s
->flags
|= SEC_EXCLUDE
;
3828 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3831 /* Allocate memory for the section contents. We use bfd_zalloc
3832 here in case unused entries are not reclaimed before the
3833 section's contents are written out. This should not happen,
3834 but this way if it does, we get a R_X86_64_NONE reloc instead
3836 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3837 if (s
->contents
== NULL
)
3841 if (htab
->plt_eh_frame
!= NULL
3842 && htab
->plt_eh_frame
->contents
!= NULL
)
3844 const struct elf_x86_64_backend_data
*arch_data
3845 = get_elf_x86_64_arch_data (bed
);
3847 memcpy (htab
->plt_eh_frame
->contents
,
3848 arch_data
->eh_frame_plt
, htab
->plt_eh_frame
->size
);
3849 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3850 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3853 if (htab
->elf
.dynamic_sections_created
)
3855 /* Add some entries to the .dynamic section. We fill in the
3856 values later, in elf_x86_64_finish_dynamic_sections, but we
3857 must add the entries now so that we get the correct size for
3858 the .dynamic section. The DT_DEBUG entry is filled in by the
3859 dynamic linker and used by the debugger. */
3860 #define add_dynamic_entry(TAG, VAL) \
3861 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3863 if (bfd_link_executable (info
))
3865 if (!add_dynamic_entry (DT_DEBUG
, 0))
3869 if (htab
->elf
.splt
->size
!= 0)
3871 /* DT_PLTGOT is used by prelink even if there is no PLT
3873 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3876 if (htab
->elf
.srelplt
->size
!= 0)
3878 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3879 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3880 || !add_dynamic_entry (DT_JMPREL
, 0))
3884 if (htab
->tlsdesc_plt
3885 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3886 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3892 if (!add_dynamic_entry (DT_RELA
, 0)
3893 || !add_dynamic_entry (DT_RELASZ
, 0)
3894 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3897 /* If any dynamic relocs apply to a read-only section,
3898 then we need a DT_TEXTREL entry. */
3899 if ((info
->flags
& DF_TEXTREL
) == 0)
3900 elf_link_hash_traverse (&htab
->elf
,
3901 elf_x86_64_readonly_dynrelocs
,
3904 if ((info
->flags
& DF_TEXTREL
) != 0)
3906 if (htab
->readonly_dynrelocs_against_ifunc
)
3908 info
->callbacks
->einfo
3909 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3910 bfd_set_error (bfd_error_bad_value
);
3914 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3919 #undef add_dynamic_entry
3925 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3926 struct bfd_link_info
*info
)
3928 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3932 struct elf_link_hash_entry
*tlsbase
;
3934 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3935 "_TLS_MODULE_BASE_",
3936 FALSE
, FALSE
, FALSE
);
3938 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3940 struct elf_x86_64_link_hash_table
*htab
;
3941 struct bfd_link_hash_entry
*bh
= NULL
;
3942 const struct elf_backend_data
*bed
3943 = get_elf_backend_data (output_bfd
);
3945 htab
= elf_x86_64_hash_table (info
);
3949 if (!(_bfd_generic_link_add_one_symbol
3950 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3951 tls_sec
, 0, NULL
, FALSE
,
3952 bed
->collect
, &bh
)))
3955 htab
->tls_module_base
= bh
;
3957 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3958 tlsbase
->def_regular
= 1;
3959 tlsbase
->other
= STV_HIDDEN
;
3960 tlsbase
->root
.linker_def
= 1;
3961 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3968 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3969 executables. Rather than setting it to the beginning of the TLS
3970 section, we have to set it to the end. This function may be called
3971 multiple times, it is idempotent. */
3974 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
3976 struct elf_x86_64_link_hash_table
*htab
;
3977 struct bfd_link_hash_entry
*base
;
3979 if (!bfd_link_executable (info
))
3982 htab
= elf_x86_64_hash_table (info
);
3986 base
= htab
->tls_module_base
;
3990 base
->u
.def
.value
= htab
->elf
.tls_size
;
3993 /* Return the base VMA address which should be subtracted from real addresses
3994 when resolving @dtpoff relocation.
3995 This is PT_TLS segment p_vaddr. */
3998 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
4000 /* If tls_sec is NULL, we should have signalled an error already. */
4001 if (elf_hash_table (info
)->tls_sec
== NULL
)
4003 return elf_hash_table (info
)->tls_sec
->vma
;
4006 /* Return the relocation value for @tpoff relocation
4007 if STT_TLS virtual address is ADDRESS. */
4010 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
4012 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
4013 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
4014 bfd_vma static_tls_size
;
4016 /* If tls_segment is NULL, we should have signalled an error already. */
4017 if (htab
->tls_sec
== NULL
)
4020 /* Consider special static TLS alignment requirements. */
4021 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
4022 return address
- static_tls_size
- htab
->tls_sec
->vma
;
4025 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
4029 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
4031 /* Opcode Instruction
4034 0x0f 0x8x conditional jump */
4036 && (contents
[offset
- 1] == 0xe8
4037 || contents
[offset
- 1] == 0xe9))
4039 && contents
[offset
- 2] == 0x0f
4040 && (contents
[offset
- 1] & 0xf0) == 0x80));
4044 elf_x86_64_need_pic (bfd
*input_bfd
, struct elf_link_hash_entry
*h
,
4045 reloc_howto_type
*howto
)
4049 const char *pic
= "";
4051 switch (ELF_ST_VISIBILITY (h
->other
))
4054 v
= _("hidden symbol");
4057 v
= _("internal symbol");
4060 v
= _("protected symbol");
4064 pic
= _("; recompile with -fPIC");
4069 fmt
= _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
4071 fmt
= _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
4073 (*_bfd_error_handler
) (fmt
, input_bfd
, howto
->name
,
4074 v
, h
->root
.root
.string
, pic
);
4075 bfd_set_error (bfd_error_bad_value
);
4079 /* Relocate an x86_64 ELF section. */
4082 elf_x86_64_relocate_section (bfd
*output_bfd
,
4083 struct bfd_link_info
*info
,
4085 asection
*input_section
,
4087 Elf_Internal_Rela
*relocs
,
4088 Elf_Internal_Sym
*local_syms
,
4089 asection
**local_sections
)
4091 struct elf_x86_64_link_hash_table
*htab
;
4092 Elf_Internal_Shdr
*symtab_hdr
;
4093 struct elf_link_hash_entry
**sym_hashes
;
4094 bfd_vma
*local_got_offsets
;
4095 bfd_vma
*local_tlsdesc_gotents
;
4096 Elf_Internal_Rela
*rel
;
4097 Elf_Internal_Rela
*wrel
;
4098 Elf_Internal_Rela
*relend
;
4099 const unsigned int plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
4101 BFD_ASSERT (is_x86_64_elf (input_bfd
));
4103 htab
= elf_x86_64_hash_table (info
);
4106 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
4107 sym_hashes
= elf_sym_hashes (input_bfd
);
4108 local_got_offsets
= elf_local_got_offsets (input_bfd
);
4109 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
4111 elf_x86_64_set_tls_module_base (info
);
4113 rel
= wrel
= relocs
;
4114 relend
= relocs
+ input_section
->reloc_count
;
4115 for (; rel
< relend
; wrel
++, rel
++)
4117 unsigned int r_type
;
4118 reloc_howto_type
*howto
;
4119 unsigned long r_symndx
;
4120 struct elf_link_hash_entry
*h
;
4121 struct elf_x86_64_link_hash_entry
*eh
;
4122 Elf_Internal_Sym
*sym
;
4124 bfd_vma off
, offplt
, plt_offset
;
4126 bfd_boolean unresolved_reloc
;
4127 bfd_reloc_status_type r
;
4129 asection
*base_got
, *resolved_plt
;
4131 bfd_boolean resolved_to_zero
;
4133 r_type
= ELF32_R_TYPE (rel
->r_info
);
4134 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
4135 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
4142 if (r_type
>= (int) R_X86_64_standard
)
4144 (*_bfd_error_handler
)
4145 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
4146 input_bfd
, input_section
, r_type
);
4147 bfd_set_error (bfd_error_bad_value
);
4151 if (r_type
!= (int) R_X86_64_32
4152 || ABI_64_P (output_bfd
))
4153 howto
= x86_64_elf_howto_table
+ r_type
;
4155 howto
= (x86_64_elf_howto_table
4156 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
4157 r_symndx
= htab
->r_sym (rel
->r_info
);
4161 unresolved_reloc
= FALSE
;
4162 if (r_symndx
< symtab_hdr
->sh_info
)
4164 sym
= local_syms
+ r_symndx
;
4165 sec
= local_sections
[r_symndx
];
4167 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
4169 st_size
= sym
->st_size
;
4171 /* Relocate against local STT_GNU_IFUNC symbol. */
4172 if (!bfd_link_relocatable (info
)
4173 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
4175 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
4180 /* Set STT_GNU_IFUNC symbol value. */
4181 h
->root
.u
.def
.value
= sym
->st_value
;
4182 h
->root
.u
.def
.section
= sec
;
4187 bfd_boolean warned ATTRIBUTE_UNUSED
;
4188 bfd_boolean ignored ATTRIBUTE_UNUSED
;
4190 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
4191 r_symndx
, symtab_hdr
, sym_hashes
,
4193 unresolved_reloc
, warned
, ignored
);
4197 if (sec
!= NULL
&& discarded_section (sec
))
4199 _bfd_clear_contents (howto
, input_bfd
, input_section
,
4200 contents
+ rel
->r_offset
);
4201 wrel
->r_offset
= rel
->r_offset
;
4205 /* For ld -r, remove relocations in debug sections against
4206 sections defined in discarded sections. Not done for
4207 eh_frame editing code expects to be present. */
4208 if (bfd_link_relocatable (info
)
4209 && (input_section
->flags
& SEC_DEBUGGING
))
4215 if (bfd_link_relocatable (info
))
4222 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
4224 if (r_type
== R_X86_64_64
)
4226 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
4227 zero-extend it to 64bit if addend is zero. */
4228 r_type
= R_X86_64_32
;
4229 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4231 else if (r_type
== R_X86_64_SIZE64
)
4233 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
4234 zero-extend it to 64bit if addend is zero. */
4235 r_type
= R_X86_64_SIZE32
;
4236 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4240 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
4242 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
4243 it here if it is defined in a non-shared object. */
4245 && h
->type
== STT_GNU_IFUNC
4251 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4253 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4254 sections because such sections are not SEC_ALLOC and
4255 thus ld.so will not process them. */
4256 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
4260 else if (h
->plt
.offset
== (bfd_vma
) -1)
4263 /* STT_GNU_IFUNC symbol must go through PLT. */
4264 if (htab
->elf
.splt
!= NULL
)
4266 if (htab
->plt_bnd
!= NULL
)
4268 resolved_plt
= htab
->plt_bnd
;
4269 plt_offset
= eh
->plt_bnd
.offset
;
4273 resolved_plt
= htab
->elf
.splt
;
4274 plt_offset
= h
->plt
.offset
;
4279 resolved_plt
= htab
->elf
.iplt
;
4280 plt_offset
= h
->plt
.offset
;
4283 relocation
= (resolved_plt
->output_section
->vma
4284 + resolved_plt
->output_offset
+ plt_offset
);
4289 if (h
->root
.root
.string
)
4290 name
= h
->root
.root
.string
;
4292 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4294 (*_bfd_error_handler
)
4295 (_("%B: relocation %s against STT_GNU_IFUNC "
4296 "symbol `%s' isn't handled by %s"), input_bfd
,
4297 howto
->name
, name
, __FUNCTION__
);
4298 bfd_set_error (bfd_error_bad_value
);
4302 if (bfd_link_pic (info
))
4307 if (ABI_64_P (output_bfd
))
4311 if (rel
->r_addend
!= 0)
4313 if (h
->root
.root
.string
)
4314 name
= h
->root
.root
.string
;
4316 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4318 (*_bfd_error_handler
)
4319 (_("%B: relocation %s against STT_GNU_IFUNC "
4320 "symbol `%s' has non-zero addend: %d"),
4321 input_bfd
, howto
->name
, name
, rel
->r_addend
);
4322 bfd_set_error (bfd_error_bad_value
);
4326 /* Generate dynamic relcoation only when there is a
4327 non-GOT reference in a shared object. */
4328 if (bfd_link_pic (info
) && h
->non_got_ref
)
4330 Elf_Internal_Rela outrel
;
4333 /* Need a dynamic relocation to get the real function
4335 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
4339 if (outrel
.r_offset
== (bfd_vma
) -1
4340 || outrel
.r_offset
== (bfd_vma
) -2)
4343 outrel
.r_offset
+= (input_section
->output_section
->vma
4344 + input_section
->output_offset
);
4346 if (h
->dynindx
== -1
4348 || bfd_link_executable (info
))
4350 /* This symbol is resolved locally. */
4351 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4352 outrel
.r_addend
= (h
->root
.u
.def
.value
4353 + h
->root
.u
.def
.section
->output_section
->vma
4354 + h
->root
.u
.def
.section
->output_offset
);
4358 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4359 outrel
.r_addend
= 0;
4362 sreloc
= htab
->elf
.irelifunc
;
4363 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4365 /* If this reloc is against an external symbol, we
4366 do not want to fiddle with the addend. Otherwise,
4367 we need to include the symbol value so that it
4368 becomes an addend for the dynamic reloc. For an
4369 internal symbol, we have updated addend. */
4374 case R_X86_64_PC32_BND
:
4376 case R_X86_64_PLT32
:
4377 case R_X86_64_PLT32_BND
:
4380 case R_X86_64_GOTPCREL
:
4381 case R_X86_64_GOTPCRELX
:
4382 case R_X86_64_REX_GOTPCRELX
:
4383 case R_X86_64_GOTPCREL64
:
4384 base_got
= htab
->elf
.sgot
;
4385 off
= h
->got
.offset
;
4387 if (base_got
== NULL
)
4390 if (off
== (bfd_vma
) -1)
4392 /* We can't use h->got.offset here to save state, or
4393 even just remember the offset, as finish_dynamic_symbol
4394 would use that as offset into .got. */
4396 if (htab
->elf
.splt
!= NULL
)
4398 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4399 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4400 base_got
= htab
->elf
.sgotplt
;
4404 plt_index
= h
->plt
.offset
/ plt_entry_size
;
4405 off
= plt_index
* GOT_ENTRY_SIZE
;
4406 base_got
= htab
->elf
.igotplt
;
4409 if (h
->dynindx
== -1
4413 /* This references the local defitionion. We must
4414 initialize this entry in the global offset table.
4415 Since the offset must always be a multiple of 8,
4416 we use the least significant bit to record
4417 whether we have initialized it already.
4419 When doing a dynamic link, we create a .rela.got
4420 relocation entry to initialize the value. This
4421 is done in the finish_dynamic_symbol routine. */
4426 bfd_put_64 (output_bfd
, relocation
,
4427 base_got
->contents
+ off
);
4428 /* Note that this is harmless for the GOTPLT64
4429 case, as -1 | 1 still is -1. */
4435 relocation
= (base_got
->output_section
->vma
4436 + base_got
->output_offset
+ off
);
4442 resolved_to_zero
= (eh
!= NULL
4443 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, eh
));
4445 /* When generating a shared object, the relocations handled here are
4446 copied into the output file to be resolved at run time. */
4449 case R_X86_64_GOT32
:
4450 case R_X86_64_GOT64
:
4451 /* Relocation is to the entry for this symbol in the global
4453 case R_X86_64_GOTPCREL
:
4454 case R_X86_64_GOTPCRELX
:
4455 case R_X86_64_REX_GOTPCRELX
:
4456 case R_X86_64_GOTPCREL64
:
4457 /* Use global offset table entry as symbol value. */
4458 case R_X86_64_GOTPLT64
:
4459 /* This is obsolete and treated the the same as GOT64. */
4460 base_got
= htab
->elf
.sgot
;
4462 if (htab
->elf
.sgot
== NULL
)
4469 off
= h
->got
.offset
;
4471 && h
->plt
.offset
!= (bfd_vma
)-1
4472 && off
== (bfd_vma
)-1)
4474 /* We can't use h->got.offset here to save
4475 state, or even just remember the offset, as
4476 finish_dynamic_symbol would use that as offset into
4478 bfd_vma plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4479 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4480 base_got
= htab
->elf
.sgotplt
;
4483 dyn
= htab
->elf
.dynamic_sections_created
;
4485 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
4486 || (bfd_link_pic (info
)
4487 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4488 || (ELF_ST_VISIBILITY (h
->other
)
4489 && h
->root
.type
== bfd_link_hash_undefweak
))
4491 /* This is actually a static link, or it is a -Bsymbolic
4492 link and the symbol is defined locally, or the symbol
4493 was forced to be local because of a version file. We
4494 must initialize this entry in the global offset table.
4495 Since the offset must always be a multiple of 8, we
4496 use the least significant bit to record whether we
4497 have initialized it already.
4499 When doing a dynamic link, we create a .rela.got
4500 relocation entry to initialize the value. This is
4501 done in the finish_dynamic_symbol routine. */
4506 bfd_put_64 (output_bfd
, relocation
,
4507 base_got
->contents
+ off
);
4508 /* Note that this is harmless for the GOTPLT64 case,
4509 as -1 | 1 still is -1. */
4514 unresolved_reloc
= FALSE
;
4518 if (local_got_offsets
== NULL
)
4521 off
= local_got_offsets
[r_symndx
];
4523 /* The offset must always be a multiple of 8. We use
4524 the least significant bit to record whether we have
4525 already generated the necessary reloc. */
4530 bfd_put_64 (output_bfd
, relocation
,
4531 base_got
->contents
+ off
);
4533 if (bfd_link_pic (info
))
4536 Elf_Internal_Rela outrel
;
4538 /* We need to generate a R_X86_64_RELATIVE reloc
4539 for the dynamic linker. */
4540 s
= htab
->elf
.srelgot
;
4544 outrel
.r_offset
= (base_got
->output_section
->vma
4545 + base_got
->output_offset
4547 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4548 outrel
.r_addend
= relocation
;
4549 elf_append_rela (output_bfd
, s
, &outrel
);
4552 local_got_offsets
[r_symndx
] |= 1;
4556 if (off
>= (bfd_vma
) -2)
4559 relocation
= base_got
->output_section
->vma
4560 + base_got
->output_offset
+ off
;
4561 if (r_type
!= R_X86_64_GOTPCREL
4562 && r_type
!= R_X86_64_GOTPCRELX
4563 && r_type
!= R_X86_64_REX_GOTPCRELX
4564 && r_type
!= R_X86_64_GOTPCREL64
)
4565 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4566 - htab
->elf
.sgotplt
->output_offset
;
4570 case R_X86_64_GOTOFF64
:
4571 /* Relocation is relative to the start of the global offset
4574 /* Check to make sure it isn't a protected function or data
4575 symbol for shared library since it may not be local when
4576 used as function address or with copy relocation. We also
4577 need to make sure that a symbol is referenced locally. */
4578 if (bfd_link_pic (info
) && h
)
4580 if (!h
->def_regular
)
4584 switch (ELF_ST_VISIBILITY (h
->other
))
4587 v
= _("hidden symbol");
4590 v
= _("internal symbol");
4593 v
= _("protected symbol");
4600 (*_bfd_error_handler
)
4601 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s `%s' can not be used when making a shared object"),
4602 input_bfd
, v
, h
->root
.root
.string
);
4603 bfd_set_error (bfd_error_bad_value
);
4606 else if (!bfd_link_executable (info
)
4607 && !SYMBOL_REFERENCES_LOCAL (info
, h
)
4608 && (h
->type
== STT_FUNC
4609 || h
->type
== STT_OBJECT
)
4610 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4612 (*_bfd_error_handler
)
4613 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s `%s' can not be used when making a shared object"),
4615 h
->type
== STT_FUNC
? "function" : "data",
4616 h
->root
.root
.string
);
4617 bfd_set_error (bfd_error_bad_value
);
4622 /* Note that sgot is not involved in this
4623 calculation. We always want the start of .got.plt. If we
4624 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4625 permitted by the ABI, we might have to change this
4627 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4628 + htab
->elf
.sgotplt
->output_offset
;
4631 case R_X86_64_GOTPC32
:
4632 case R_X86_64_GOTPC64
:
4633 /* Use global offset table as symbol value. */
4634 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4635 + htab
->elf
.sgotplt
->output_offset
;
4636 unresolved_reloc
= FALSE
;
4639 case R_X86_64_PLTOFF64
:
4640 /* Relocation is PLT entry relative to GOT. For local
4641 symbols it's the symbol itself relative to GOT. */
4643 /* See PLT32 handling. */
4644 && h
->plt
.offset
!= (bfd_vma
) -1
4645 && htab
->elf
.splt
!= NULL
)
4647 if (htab
->plt_bnd
!= NULL
)
4649 resolved_plt
= htab
->plt_bnd
;
4650 plt_offset
= eh
->plt_bnd
.offset
;
4654 resolved_plt
= htab
->elf
.splt
;
4655 plt_offset
= h
->plt
.offset
;
4658 relocation
= (resolved_plt
->output_section
->vma
4659 + resolved_plt
->output_offset
4661 unresolved_reloc
= FALSE
;
4664 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4665 + htab
->elf
.sgotplt
->output_offset
;
4668 case R_X86_64_PLT32
:
4669 case R_X86_64_PLT32_BND
:
4670 /* Relocation is to the entry for this symbol in the
4671 procedure linkage table. */
4673 /* Resolve a PLT32 reloc against a local symbol directly,
4674 without using the procedure linkage table. */
4678 if ((h
->plt
.offset
== (bfd_vma
) -1
4679 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4680 || htab
->elf
.splt
== NULL
)
4682 /* We didn't make a PLT entry for this symbol. This
4683 happens when statically linking PIC code, or when
4684 using -Bsymbolic. */
4688 if (h
->plt
.offset
!= (bfd_vma
) -1)
4690 if (htab
->plt_bnd
!= NULL
)
4692 resolved_plt
= htab
->plt_bnd
;
4693 plt_offset
= eh
->plt_bnd
.offset
;
4697 resolved_plt
= htab
->elf
.splt
;
4698 plt_offset
= h
->plt
.offset
;
4703 /* Use the GOT PLT. */
4704 resolved_plt
= htab
->plt_got
;
4705 plt_offset
= eh
->plt_got
.offset
;
4708 relocation
= (resolved_plt
->output_section
->vma
4709 + resolved_plt
->output_offset
4711 unresolved_reloc
= FALSE
;
4714 case R_X86_64_SIZE32
:
4715 case R_X86_64_SIZE64
:
4716 /* Set to symbol size. */
4717 relocation
= st_size
;
4723 case R_X86_64_PC32_BND
:
4724 /* Don't complain about -fPIC if the symbol is undefined when
4725 building executable unless it is unresolved weak symbol. */
4726 if ((input_section
->flags
& SEC_ALLOC
) != 0
4727 && (input_section
->flags
& SEC_READONLY
) != 0
4729 && ((bfd_link_executable (info
)
4730 && h
->root
.type
== bfd_link_hash_undefweak
4731 && !resolved_to_zero
)
4732 || (bfd_link_pic (info
)
4733 && !(bfd_link_pie (info
)
4734 && h
->root
.type
== bfd_link_hash_undefined
))))
4736 bfd_boolean fail
= FALSE
;
4738 = ((r_type
== R_X86_64_PC32
4739 || r_type
== R_X86_64_PC32_BND
)
4740 && is_32bit_relative_branch (contents
, rel
->r_offset
));
4742 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
4744 /* Symbol is referenced locally. Make sure it is
4745 defined locally or for a branch. */
4746 fail
= !h
->def_regular
&& !branch
;
4748 else if (!(bfd_link_pie (info
)
4749 && (h
->needs_copy
|| eh
->needs_copy
)))
4751 /* Symbol doesn't need copy reloc and isn't referenced
4752 locally. We only allow branch to symbol with
4753 non-default visibility. */
4755 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
4759 return elf_x86_64_need_pic (input_bfd
, h
, howto
);
4768 /* FIXME: The ABI says the linker should make sure the value is
4769 the same when it's zeroextended to 64 bit. */
4772 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4775 /* Don't copy a pc-relative relocation into the output file
4776 if the symbol needs copy reloc or the symbol is undefined
4777 when building executable. Copy dynamic function pointer
4778 relocations. Don't generate dynamic relocations against
4779 resolved undefined weak symbols in PIE. */
4780 if ((bfd_link_pic (info
)
4781 && !(bfd_link_pie (info
)
4785 || h
->root
.type
== bfd_link_hash_undefined
)
4786 && IS_X86_64_PCREL_TYPE (r_type
))
4788 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4789 && !resolved_to_zero
)
4790 || h
->root
.type
!= bfd_link_hash_undefweak
))
4791 && ((! IS_X86_64_PCREL_TYPE (r_type
)
4792 && r_type
!= R_X86_64_SIZE32
4793 && r_type
!= R_X86_64_SIZE64
)
4794 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
4795 || (ELIMINATE_COPY_RELOCS
4796 && !bfd_link_pic (info
)
4800 || eh
->func_pointer_refcount
> 0
4801 || (h
->root
.type
== bfd_link_hash_undefweak
4802 && !resolved_to_zero
))
4803 && ((h
->def_dynamic
&& !h
->def_regular
)
4804 /* Undefined weak symbol is bound locally when
4806 || h
->root
.type
== bfd_link_hash_undefined
)))
4808 Elf_Internal_Rela outrel
;
4809 bfd_boolean skip
, relocate
;
4812 /* When generating a shared object, these relocations
4813 are copied into the output file to be resolved at run
4819 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4821 if (outrel
.r_offset
== (bfd_vma
) -1)
4823 else if (outrel
.r_offset
== (bfd_vma
) -2)
4824 skip
= TRUE
, relocate
= TRUE
;
4826 outrel
.r_offset
+= (input_section
->output_section
->vma
4827 + input_section
->output_offset
);
4830 memset (&outrel
, 0, sizeof outrel
);
4832 /* h->dynindx may be -1 if this symbol was marked to
4836 && (IS_X86_64_PCREL_TYPE (r_type
)
4837 || !(bfd_link_executable (info
)
4838 || SYMBOLIC_BIND (info
, h
))
4839 || ! h
->def_regular
))
4841 if ((r_type
!= R_X86_64_PC64
&& r_type
!= R_X86_64_64
)
4842 && bfd_link_executable (info
)
4843 && h
->root
.type
== bfd_link_hash_undefweak
4844 && !resolved_to_zero
)
4845 return elf_x86_64_need_pic (input_bfd
, h
, howto
);
4846 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4847 outrel
.r_addend
= rel
->r_addend
;
4851 /* This symbol is local, or marked to become local.
4852 When relocation overflow check is disabled, we
4853 convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */
4854 if (r_type
== htab
->pointer_r_type
4855 || (r_type
== R_X86_64_32
4856 && info
->no_reloc_overflow_check
))
4859 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4860 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4862 else if (r_type
== R_X86_64_64
4863 && !ABI_64_P (output_bfd
))
4866 outrel
.r_info
= htab
->r_info (0,
4867 R_X86_64_RELATIVE64
);
4868 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4869 /* Check addend overflow. */
4870 if ((outrel
.r_addend
& 0x80000000)
4871 != (rel
->r_addend
& 0x80000000))
4874 int addend
= rel
->r_addend
;
4875 if (h
&& h
->root
.root
.string
)
4876 name
= h
->root
.root
.string
;
4878 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4881 (*_bfd_error_handler
)
4882 (_("%B: addend -0x%x in relocation %s against "
4883 "symbol `%s' at 0x%lx in section `%A' is "
4885 input_bfd
, input_section
, addend
,
4887 (unsigned long) rel
->r_offset
);
4889 (*_bfd_error_handler
)
4890 (_("%B: addend 0x%x in relocation %s against "
4891 "symbol `%s' at 0x%lx in section `%A' is "
4893 input_bfd
, input_section
, addend
,
4895 (unsigned long) rel
->r_offset
);
4896 bfd_set_error (bfd_error_bad_value
);
4904 if (bfd_is_abs_section (sec
))
4906 else if (sec
== NULL
|| sec
->owner
== NULL
)
4908 bfd_set_error (bfd_error_bad_value
);
4915 /* We are turning this relocation into one
4916 against a section symbol. It would be
4917 proper to subtract the symbol's value,
4918 osec->vma, from the emitted reloc addend,
4919 but ld.so expects buggy relocs. */
4920 osec
= sec
->output_section
;
4921 sindx
= elf_section_data (osec
)->dynindx
;
4924 asection
*oi
= htab
->elf
.text_index_section
;
4925 sindx
= elf_section_data (oi
)->dynindx
;
4927 BFD_ASSERT (sindx
!= 0);
4930 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
4931 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4935 sreloc
= elf_section_data (input_section
)->sreloc
;
4937 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4939 r
= bfd_reloc_notsupported
;
4940 goto check_relocation_error
;
4943 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4945 /* If this reloc is against an external symbol, we do
4946 not want to fiddle with the addend. Otherwise, we
4947 need to include the symbol value so that it becomes
4948 an addend for the dynamic reloc. */
4955 case R_X86_64_TLSGD
:
4956 case R_X86_64_GOTPC32_TLSDESC
:
4957 case R_X86_64_TLSDESC_CALL
:
4958 case R_X86_64_GOTTPOFF
:
4959 tls_type
= GOT_UNKNOWN
;
4960 if (h
== NULL
&& local_got_offsets
)
4961 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
4963 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
4965 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4966 input_section
, contents
,
4967 symtab_hdr
, sym_hashes
,
4968 &r_type
, tls_type
, rel
,
4969 relend
, h
, r_symndx
))
4972 if (r_type
== R_X86_64_TPOFF32
)
4974 bfd_vma roff
= rel
->r_offset
;
4976 BFD_ASSERT (! unresolved_reloc
);
4978 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4980 /* GD->LE transition. For 64bit, change
4981 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4982 .word 0x6666; rex64; call __tls_get_addr
4985 leaq foo@tpoff(%rax), %rax
4987 leaq foo@tlsgd(%rip), %rdi
4988 .word 0x6666; rex64; call __tls_get_addr
4991 leaq foo@tpoff(%rax), %rax
4992 For largepic, change:
4993 leaq foo@tlsgd(%rip), %rdi
4994 movabsq $__tls_get_addr@pltoff, %rax
4999 leaq foo@tpoff(%rax), %rax
5000 nopw 0x0(%rax,%rax,1) */
5002 if (ABI_64_P (output_bfd
)
5003 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
5005 memcpy (contents
+ roff
- 3,
5006 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
5007 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5010 else if (ABI_64_P (output_bfd
))
5011 memcpy (contents
+ roff
- 4,
5012 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5015 memcpy (contents
+ roff
- 3,
5016 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5018 bfd_put_32 (output_bfd
,
5019 elf_x86_64_tpoff (info
, relocation
),
5020 contents
+ roff
+ 8 + largepic
);
5021 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5026 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5028 /* GDesc -> LE transition.
5029 It's originally something like:
5030 leaq x@tlsdesc(%rip), %rax
5033 movl $x@tpoff, %rax. */
5035 unsigned int val
, type
;
5037 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5038 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5039 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
5040 contents
+ roff
- 3);
5041 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
5042 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
5043 contents
+ roff
- 1);
5044 bfd_put_32 (output_bfd
,
5045 elf_x86_64_tpoff (info
, relocation
),
5049 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5051 /* GDesc -> LE transition.
5056 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5057 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5060 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
5062 /* IE->LE transition:
5063 For 64bit, originally it can be one of:
5064 movq foo@gottpoff(%rip), %reg
5065 addq foo@gottpoff(%rip), %reg
5068 leaq foo(%reg), %reg
5070 For 32bit, originally it can be one of:
5071 movq foo@gottpoff(%rip), %reg
5072 addl foo@gottpoff(%rip), %reg
5075 leal foo(%reg), %reg
5078 unsigned int val
, type
, reg
;
5081 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5084 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
5085 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5091 bfd_put_8 (output_bfd
, 0x49,
5092 contents
+ roff
- 3);
5093 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5094 bfd_put_8 (output_bfd
, 0x41,
5095 contents
+ roff
- 3);
5096 bfd_put_8 (output_bfd
, 0xc7,
5097 contents
+ roff
- 2);
5098 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5099 contents
+ roff
- 1);
5103 /* addq/addl -> addq/addl - addressing with %rsp/%r12
5106 bfd_put_8 (output_bfd
, 0x49,
5107 contents
+ roff
- 3);
5108 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5109 bfd_put_8 (output_bfd
, 0x41,
5110 contents
+ roff
- 3);
5111 bfd_put_8 (output_bfd
, 0x81,
5112 contents
+ roff
- 2);
5113 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5114 contents
+ roff
- 1);
5118 /* addq/addl -> leaq/leal */
5120 bfd_put_8 (output_bfd
, 0x4d,
5121 contents
+ roff
- 3);
5122 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5123 bfd_put_8 (output_bfd
, 0x45,
5124 contents
+ roff
- 3);
5125 bfd_put_8 (output_bfd
, 0x8d,
5126 contents
+ roff
- 2);
5127 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
5128 contents
+ roff
- 1);
5130 bfd_put_32 (output_bfd
,
5131 elf_x86_64_tpoff (info
, relocation
),
5139 if (htab
->elf
.sgot
== NULL
)
5144 off
= h
->got
.offset
;
5145 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
5149 if (local_got_offsets
== NULL
)
5152 off
= local_got_offsets
[r_symndx
];
5153 offplt
= local_tlsdesc_gotents
[r_symndx
];
5160 Elf_Internal_Rela outrel
;
5164 if (htab
->elf
.srelgot
== NULL
)
5167 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
5169 if (GOT_TLS_GDESC_P (tls_type
))
5171 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
5172 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
5173 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
5174 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5175 + htab
->elf
.sgotplt
->output_offset
5177 + htab
->sgotplt_jump_table_size
);
5178 sreloc
= htab
->elf
.srelplt
;
5180 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5182 outrel
.r_addend
= 0;
5183 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5186 sreloc
= htab
->elf
.srelgot
;
5188 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5189 + htab
->elf
.sgot
->output_offset
+ off
);
5191 if (GOT_TLS_GD_P (tls_type
))
5192 dr_type
= R_X86_64_DTPMOD64
;
5193 else if (GOT_TLS_GDESC_P (tls_type
))
5196 dr_type
= R_X86_64_TPOFF64
;
5198 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
5199 outrel
.r_addend
= 0;
5200 if ((dr_type
== R_X86_64_TPOFF64
5201 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
5202 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5203 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
5205 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5207 if (GOT_TLS_GD_P (tls_type
))
5211 BFD_ASSERT (! unresolved_reloc
);
5212 bfd_put_64 (output_bfd
,
5213 relocation
- elf_x86_64_dtpoff_base (info
),
5214 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5218 bfd_put_64 (output_bfd
, 0,
5219 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5220 outrel
.r_info
= htab
->r_info (indx
,
5222 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
5223 elf_append_rela (output_bfd
, sreloc
,
5232 local_got_offsets
[r_symndx
] |= 1;
5235 if (off
>= (bfd_vma
) -2
5236 && ! GOT_TLS_GDESC_P (tls_type
))
5238 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
5240 if (r_type
== R_X86_64_GOTPC32_TLSDESC
5241 || r_type
== R_X86_64_TLSDESC_CALL
)
5242 relocation
= htab
->elf
.sgotplt
->output_section
->vma
5243 + htab
->elf
.sgotplt
->output_offset
5244 + offplt
+ htab
->sgotplt_jump_table_size
;
5246 relocation
= htab
->elf
.sgot
->output_section
->vma
5247 + htab
->elf
.sgot
->output_offset
+ off
;
5248 unresolved_reloc
= FALSE
;
5252 bfd_vma roff
= rel
->r_offset
;
5254 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5256 /* GD->IE transition. For 64bit, change
5257 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5258 .word 0x6666; rex64; call __tls_get_addr@plt
5261 addq foo@gottpoff(%rip), %rax
5263 leaq foo@tlsgd(%rip), %rdi
5264 .word 0x6666; rex64; call __tls_get_addr@plt
5267 addq foo@gottpoff(%rip), %rax
5268 For largepic, change:
5269 leaq foo@tlsgd(%rip), %rdi
5270 movabsq $__tls_get_addr@pltoff, %rax
5275 addq foo@gottpoff(%rax), %rax
5276 nopw 0x0(%rax,%rax,1) */
5278 if (ABI_64_P (output_bfd
)
5279 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
5281 memcpy (contents
+ roff
- 3,
5282 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
5283 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5286 else if (ABI_64_P (output_bfd
))
5287 memcpy (contents
+ roff
- 4,
5288 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5291 memcpy (contents
+ roff
- 3,
5292 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5295 relocation
= (htab
->elf
.sgot
->output_section
->vma
5296 + htab
->elf
.sgot
->output_offset
+ off
5299 - input_section
->output_section
->vma
5300 - input_section
->output_offset
5302 bfd_put_32 (output_bfd
, relocation
,
5303 contents
+ roff
+ 8 + largepic
);
5304 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5309 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5311 /* GDesc -> IE transition.
5312 It's originally something like:
5313 leaq x@tlsdesc(%rip), %rax
5316 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
5318 /* Now modify the instruction as appropriate. To
5319 turn a leaq into a movq in the form we use it, it
5320 suffices to change the second byte from 0x8d to
5322 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
5324 bfd_put_32 (output_bfd
,
5325 htab
->elf
.sgot
->output_section
->vma
5326 + htab
->elf
.sgot
->output_offset
+ off
5328 - input_section
->output_section
->vma
5329 - input_section
->output_offset
5334 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5336 /* GDesc -> IE transition.
5343 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5344 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5352 case R_X86_64_TLSLD
:
5353 if (! elf_x86_64_tls_transition (info
, input_bfd
,
5354 input_section
, contents
,
5355 symtab_hdr
, sym_hashes
,
5356 &r_type
, GOT_UNKNOWN
,
5357 rel
, relend
, h
, r_symndx
))
5360 if (r_type
!= R_X86_64_TLSLD
)
5362 /* LD->LE transition:
5363 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
5364 For 64bit, we change it into:
5365 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
5366 For 32bit, we change it into:
5367 nopl 0x0(%rax); movl %fs:0, %eax.
5368 For largepic, change:
5369 leaq foo@tlsgd(%rip), %rdi
5370 movabsq $__tls_get_addr@pltoff, %rax
5374 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
5377 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
5378 if (ABI_64_P (output_bfd
)
5379 && contents
[rel
->r_offset
+ 5] == (bfd_byte
) '\xb8')
5380 memcpy (contents
+ rel
->r_offset
- 3,
5381 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
5382 "\x64\x48\x8b\x04\x25\0\0\0", 22);
5383 else if (ABI_64_P (output_bfd
))
5384 memcpy (contents
+ rel
->r_offset
- 3,
5385 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
5387 memcpy (contents
+ rel
->r_offset
- 3,
5388 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
5389 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5395 if (htab
->elf
.sgot
== NULL
)
5398 off
= htab
->tls_ld_got
.offset
;
5403 Elf_Internal_Rela outrel
;
5405 if (htab
->elf
.srelgot
== NULL
)
5408 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5409 + htab
->elf
.sgot
->output_offset
+ off
);
5411 bfd_put_64 (output_bfd
, 0,
5412 htab
->elf
.sgot
->contents
+ off
);
5413 bfd_put_64 (output_bfd
, 0,
5414 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5415 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
5416 outrel
.r_addend
= 0;
5417 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
5419 htab
->tls_ld_got
.offset
|= 1;
5421 relocation
= htab
->elf
.sgot
->output_section
->vma
5422 + htab
->elf
.sgot
->output_offset
+ off
;
5423 unresolved_reloc
= FALSE
;
5426 case R_X86_64_DTPOFF32
:
5427 if (!bfd_link_executable (info
)
5428 || (input_section
->flags
& SEC_CODE
) == 0)
5429 relocation
-= elf_x86_64_dtpoff_base (info
);
5431 relocation
= elf_x86_64_tpoff (info
, relocation
);
5434 case R_X86_64_TPOFF32
:
5435 case R_X86_64_TPOFF64
:
5436 BFD_ASSERT (bfd_link_executable (info
));
5437 relocation
= elf_x86_64_tpoff (info
, relocation
);
5440 case R_X86_64_DTPOFF64
:
5441 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
5442 relocation
-= elf_x86_64_dtpoff_base (info
);
5449 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5450 because such sections are not SEC_ALLOC and thus ld.so will
5451 not process them. */
5452 if (unresolved_reloc
5453 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
5455 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5456 rel
->r_offset
) != (bfd_vma
) -1)
5458 (*_bfd_error_handler
)
5459 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5462 (long) rel
->r_offset
,
5464 h
->root
.root
.string
);
5469 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5470 contents
, rel
->r_offset
,
5471 relocation
, rel
->r_addend
);
5473 check_relocation_error
:
5474 if (r
!= bfd_reloc_ok
)
5479 name
= h
->root
.root
.string
;
5482 name
= bfd_elf_string_from_elf_section (input_bfd
,
5483 symtab_hdr
->sh_link
,
5488 name
= bfd_section_name (input_bfd
, sec
);
5491 if (r
== bfd_reloc_overflow
)
5493 if (! ((*info
->callbacks
->reloc_overflow
)
5494 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5495 (bfd_vma
) 0, input_bfd
, input_section
,
5501 (*_bfd_error_handler
)
5502 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5503 input_bfd
, input_section
,
5504 (long) rel
->r_offset
, name
, (int) r
);
5515 Elf_Internal_Shdr
*rel_hdr
;
5516 size_t deleted
= rel
- wrel
;
5518 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
5519 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5520 if (rel_hdr
->sh_size
== 0)
5522 /* It is too late to remove an empty reloc section. Leave
5524 ??? What is wrong with an empty section??? */
5525 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
5528 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5529 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5530 input_section
->reloc_count
-= deleted
;
5536 /* Finish up dynamic symbol handling. We set the contents of various
5537 dynamic sections here. */
5540 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
5541 struct bfd_link_info
*info
,
5542 struct elf_link_hash_entry
*h
,
5543 Elf_Internal_Sym
*sym
)
5545 struct elf_x86_64_link_hash_table
*htab
;
5546 const struct elf_x86_64_backend_data
*abed
;
5547 bfd_boolean use_plt_bnd
;
5548 struct elf_x86_64_link_hash_entry
*eh
;
5549 bfd_boolean local_undefweak
;
5551 htab
= elf_x86_64_hash_table (info
);
5555 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5556 section only if there is .plt section. */
5557 use_plt_bnd
= htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
;
5559 ? &elf_x86_64_bnd_arch_bed
5560 : get_elf_x86_64_backend_data (output_bfd
));
5562 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
5564 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5565 resolved undefined weak symbols in executable so that their
5566 references have value 0 at run-time. */
5567 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, eh
);
5569 if (h
->plt
.offset
!= (bfd_vma
) -1)
5572 bfd_vma got_offset
, plt_offset
, plt_plt_offset
, plt_got_offset
;
5573 bfd_vma plt_plt_insn_end
, plt_got_insn_size
;
5574 Elf_Internal_Rela rela
;
5576 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
5577 const struct elf_backend_data
*bed
;
5578 bfd_vma plt_got_pcrel_offset
;
5580 /* When building a static executable, use .iplt, .igot.plt and
5581 .rela.iplt sections for STT_GNU_IFUNC symbols. */
5582 if (htab
->elf
.splt
!= NULL
)
5584 plt
= htab
->elf
.splt
;
5585 gotplt
= htab
->elf
.sgotplt
;
5586 relplt
= htab
->elf
.srelplt
;
5590 plt
= htab
->elf
.iplt
;
5591 gotplt
= htab
->elf
.igotplt
;
5592 relplt
= htab
->elf
.irelplt
;
5595 /* This symbol has an entry in the procedure linkage table. Set
5597 if ((h
->dynindx
== -1
5599 && !((h
->forced_local
|| bfd_link_executable (info
))
5601 && h
->type
== STT_GNU_IFUNC
))
5607 /* Get the index in the procedure linkage table which
5608 corresponds to this symbol. This is the index of this symbol
5609 in all the symbols for which we are making plt entries. The
5610 first entry in the procedure linkage table is reserved.
5612 Get the offset into the .got table of the entry that
5613 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
5614 bytes. The first three are reserved for the dynamic linker.
5616 For static executables, we don't reserve anything. */
5618 if (plt
== htab
->elf
.splt
)
5620 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
5621 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
5625 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
5626 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
5629 plt_plt_insn_end
= abed
->plt_plt_insn_end
;
5630 plt_plt_offset
= abed
->plt_plt_offset
;
5631 plt_got_insn_size
= abed
->plt_got_insn_size
;
5632 plt_got_offset
= abed
->plt_got_offset
;
5635 /* Use the second PLT with BND relocations. */
5636 const bfd_byte
*plt_entry
, *plt2_entry
;
5638 if (eh
->has_bnd_reloc
)
5640 plt_entry
= elf_x86_64_bnd_plt_entry
;
5641 plt2_entry
= elf_x86_64_bnd_plt2_entry
;
5645 plt_entry
= elf_x86_64_legacy_plt_entry
;
5646 plt2_entry
= elf_x86_64_legacy_plt2_entry
;
5648 /* Subtract 1 since there is no BND prefix. */
5649 plt_plt_insn_end
-= 1;
5650 plt_plt_offset
-= 1;
5651 plt_got_insn_size
-= 1;
5652 plt_got_offset
-= 1;
5655 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry
)
5656 == sizeof (elf_x86_64_legacy_plt_entry
));
5658 /* Fill in the entry in the procedure linkage table. */
5659 memcpy (plt
->contents
+ h
->plt
.offset
,
5660 plt_entry
, sizeof (elf_x86_64_legacy_plt_entry
));
5661 /* Fill in the entry in the second PLT. */
5662 memcpy (htab
->plt_bnd
->contents
+ eh
->plt_bnd
.offset
,
5663 plt2_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5665 resolved_plt
= htab
->plt_bnd
;
5666 plt_offset
= eh
->plt_bnd
.offset
;
5670 /* Fill in the entry in the procedure linkage table. */
5671 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
5672 abed
->plt_entry_size
);
5675 plt_offset
= h
->plt
.offset
;
5678 /* Insert the relocation positions of the plt section. */
5680 /* Put offset the PC-relative instruction referring to the GOT entry,
5681 subtracting the size of that instruction. */
5682 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
5683 + gotplt
->output_offset
5685 - resolved_plt
->output_section
->vma
5686 - resolved_plt
->output_offset
5688 - plt_got_insn_size
);
5690 /* Check PC-relative offset overflow in PLT entry. */
5691 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
5692 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5693 output_bfd
, h
->root
.root
.string
);
5695 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
5696 resolved_plt
->contents
+ plt_offset
+ plt_got_offset
);
5698 /* Fill in the entry in the global offset table, initially this
5699 points to the second part of the PLT entry. Leave the entry
5700 as zero for undefined weak symbol in PIE. No PLT relocation
5701 against undefined weak symbol in PIE. */
5702 if (!local_undefweak
)
5704 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5705 + plt
->output_offset
5707 + abed
->plt_lazy_offset
),
5708 gotplt
->contents
+ got_offset
);
5710 /* Fill in the entry in the .rela.plt section. */
5711 rela
.r_offset
= (gotplt
->output_section
->vma
5712 + gotplt
->output_offset
5714 if (h
->dynindx
== -1
5715 || ((bfd_link_executable (info
)
5716 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5718 && h
->type
== STT_GNU_IFUNC
))
5720 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5721 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
5722 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
5723 rela
.r_addend
= (h
->root
.u
.def
.value
5724 + h
->root
.u
.def
.section
->output_section
->vma
5725 + h
->root
.u
.def
.section
->output_offset
);
5726 /* R_X86_64_IRELATIVE comes last. */
5727 plt_index
= htab
->next_irelative_index
--;
5731 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
5733 plt_index
= htab
->next_jump_slot_index
++;
5736 /* Don't fill PLT entry for static executables. */
5737 if (plt
== htab
->elf
.splt
)
5739 bfd_vma plt0_offset
= h
->plt
.offset
+ plt_plt_insn_end
;
5741 /* Put relocation index. */
5742 bfd_put_32 (output_bfd
, plt_index
,
5743 (plt
->contents
+ h
->plt
.offset
5744 + abed
->plt_reloc_offset
));
5746 /* Put offset for jmp .PLT0 and check for overflow. We don't
5747 check relocation index for overflow since branch displacement
5748 will overflow first. */
5749 if (plt0_offset
> 0x80000000)
5750 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5751 output_bfd
, h
->root
.root
.string
);
5752 bfd_put_32 (output_bfd
, - plt0_offset
,
5753 plt
->contents
+ h
->plt
.offset
+ plt_plt_offset
);
5756 bed
= get_elf_backend_data (output_bfd
);
5757 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
5758 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
5761 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5763 bfd_vma got_offset
, plt_offset
, plt_got_offset
, plt_got_insn_size
;
5764 asection
*plt
, *got
;
5765 bfd_boolean got_after_plt
;
5766 int32_t got_pcrel_offset
;
5767 const bfd_byte
*got_plt_entry
;
5769 /* Set the entry in the GOT procedure linkage table. */
5770 plt
= htab
->plt_got
;
5771 got
= htab
->elf
.sgot
;
5772 got_offset
= h
->got
.offset
;
5774 if (got_offset
== (bfd_vma
) -1
5775 || h
->type
== STT_GNU_IFUNC
5780 /* Use the second PLT entry template for the GOT PLT since they
5781 are the identical. */
5782 plt_got_insn_size
= elf_x86_64_bnd_arch_bed
.plt_got_insn_size
;
5783 plt_got_offset
= elf_x86_64_bnd_arch_bed
.plt_got_offset
;
5784 if (eh
->has_bnd_reloc
)
5785 got_plt_entry
= elf_x86_64_bnd_plt2_entry
;
5788 got_plt_entry
= elf_x86_64_legacy_plt2_entry
;
5790 /* Subtract 1 since there is no BND prefix. */
5791 plt_got_insn_size
-= 1;
5792 plt_got_offset
-= 1;
5795 /* Fill in the entry in the GOT procedure linkage table. */
5796 plt_offset
= eh
->plt_got
.offset
;
5797 memcpy (plt
->contents
+ plt_offset
,
5798 got_plt_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5800 /* Put offset the PC-relative instruction referring to the GOT
5801 entry, subtracting the size of that instruction. */
5802 got_pcrel_offset
= (got
->output_section
->vma
5803 + got
->output_offset
5805 - plt
->output_section
->vma
5806 - plt
->output_offset
5808 - plt_got_insn_size
);
5810 /* Check PC-relative offset overflow in GOT PLT entry. */
5811 got_after_plt
= got
->output_section
->vma
> plt
->output_section
->vma
;
5812 if ((got_after_plt
&& got_pcrel_offset
< 0)
5813 || (!got_after_plt
&& got_pcrel_offset
> 0))
5814 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
5815 output_bfd
, h
->root
.root
.string
);
5817 bfd_put_32 (output_bfd
, got_pcrel_offset
,
5818 plt
->contents
+ plt_offset
+ plt_got_offset
);
5821 if (!local_undefweak
5823 && (h
->plt
.offset
!= (bfd_vma
) -1
5824 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5826 /* Mark the symbol as undefined, rather than as defined in
5827 the .plt section. Leave the value if there were any
5828 relocations where pointer equality matters (this is a clue
5829 for the dynamic linker, to make function pointer
5830 comparisons work between an application and shared
5831 library), otherwise set it to zero. If a function is only
5832 called from a binary, there is no need to slow down
5833 shared libraries because of that. */
5834 sym
->st_shndx
= SHN_UNDEF
;
5835 if (!h
->pointer_equality_needed
)
5839 /* Don't generate dynamic GOT relocation against undefined weak
5840 symbol in executable. */
5841 if (h
->got
.offset
!= (bfd_vma
) -1
5842 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
5843 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
5844 && !local_undefweak
)
5846 Elf_Internal_Rela rela
;
5848 /* This symbol has an entry in the global offset table. Set it
5850 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5853 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5854 + htab
->elf
.sgot
->output_offset
5855 + (h
->got
.offset
&~ (bfd_vma
) 1));
5857 /* If this is a static link, or it is a -Bsymbolic link and the
5858 symbol is defined locally or was forced to be local because
5859 of a version file, we just want to emit a RELATIVE reloc.
5860 The entry in the global offset table will already have been
5861 initialized in the relocate_section function. */
5863 && h
->type
== STT_GNU_IFUNC
)
5865 if (bfd_link_pic (info
))
5867 /* Generate R_X86_64_GLOB_DAT. */
5874 if (!h
->pointer_equality_needed
)
5877 /* For non-shared object, we can't use .got.plt, which
5878 contains the real function addres if we need pointer
5879 equality. We load the GOT entry with the PLT entry. */
5880 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5881 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5882 + plt
->output_offset
5884 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5888 else if (bfd_link_pic (info
)
5889 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5891 if (!h
->def_regular
)
5893 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5894 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
5895 rela
.r_addend
= (h
->root
.u
.def
.value
5896 + h
->root
.u
.def
.section
->output_section
->vma
5897 + h
->root
.u
.def
.section
->output_offset
);
5901 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5903 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5904 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5905 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
5909 elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &rela
);
5914 Elf_Internal_Rela rela
;
5916 /* This symbol needs a copy reloc. Set it up. */
5918 if (h
->dynindx
== -1
5919 || (h
->root
.type
!= bfd_link_hash_defined
5920 && h
->root
.type
!= bfd_link_hash_defweak
)
5921 || htab
->srelbss
== NULL
)
5924 rela
.r_offset
= (h
->root
.u
.def
.value
5925 + h
->root
.u
.def
.section
->output_section
->vma
5926 + h
->root
.u
.def
.section
->output_offset
);
5927 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
5929 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
5935 /* Finish up local dynamic symbol handling. We set the contents of
5936 various dynamic sections here. */
5939 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
5941 struct elf_link_hash_entry
*h
5942 = (struct elf_link_hash_entry
*) *slot
;
5943 struct bfd_link_info
*info
5944 = (struct bfd_link_info
*) inf
;
5946 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5950 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5951 here since undefined weak symbol may not be dynamic and may not be
5952 called for elf_x86_64_finish_dynamic_symbol. */
5955 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
5958 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
5959 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5961 if (h
->root
.type
!= bfd_link_hash_undefweak
5962 || h
->dynindx
!= -1)
5965 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5969 /* Used to decide how to sort relocs in an optimal manner for the
5970 dynamic linker, before writing them out. */
5972 static enum elf_reloc_type_class
5973 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info
,
5974 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5975 const Elf_Internal_Rela
*rela
)
5977 bfd
*abfd
= info
->output_bfd
;
5978 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5979 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
5981 if (htab
->elf
.dynsym
!= NULL
5982 && htab
->elf
.dynsym
->contents
!= NULL
)
5984 /* Check relocation against STT_GNU_IFUNC symbol if there are
5986 unsigned long r_symndx
= htab
->r_sym (rela
->r_info
);
5987 Elf_Internal_Sym sym
;
5988 if (!bed
->s
->swap_symbol_in (abfd
,
5989 (htab
->elf
.dynsym
->contents
5990 + r_symndx
* bed
->s
->sizeof_sym
),
5994 if (ELF_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
5995 return reloc_class_ifunc
;
5998 switch ((int) ELF32_R_TYPE (rela
->r_info
))
6000 case R_X86_64_RELATIVE
:
6001 case R_X86_64_RELATIVE64
:
6002 return reloc_class_relative
;
6003 case R_X86_64_JUMP_SLOT
:
6004 return reloc_class_plt
;
6006 return reloc_class_copy
;
6008 return reloc_class_normal
;
6012 /* Finish up the dynamic sections. */
6015 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
6016 struct bfd_link_info
*info
)
6018 struct elf_x86_64_link_hash_table
*htab
;
6021 const struct elf_x86_64_backend_data
*abed
;
6023 htab
= elf_x86_64_hash_table (info
);
6027 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
6028 section only if there is .plt section. */
6029 abed
= (htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
6030 ? &elf_x86_64_bnd_arch_bed
6031 : get_elf_x86_64_backend_data (output_bfd
));
6033 dynobj
= htab
->elf
.dynobj
;
6034 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
6036 if (htab
->elf
.dynamic_sections_created
)
6038 bfd_byte
*dyncon
, *dynconend
;
6039 const struct elf_backend_data
*bed
;
6040 bfd_size_type sizeof_dyn
;
6042 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
6045 bed
= get_elf_backend_data (dynobj
);
6046 sizeof_dyn
= bed
->s
->sizeof_dyn
;
6047 dyncon
= sdyn
->contents
;
6048 dynconend
= sdyn
->contents
+ sdyn
->size
;
6049 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
6051 Elf_Internal_Dyn dyn
;
6054 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
6062 s
= htab
->elf
.sgotplt
;
6063 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
6067 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
6071 s
= htab
->elf
.srelplt
->output_section
;
6072 dyn
.d_un
.d_val
= s
->size
;
6076 /* The procedure linkage table relocs (DT_JMPREL) should
6077 not be included in the overall relocs (DT_RELA).
6078 Therefore, we override the DT_RELASZ entry here to
6079 make it not include the JMPREL relocs. Since the
6080 linker script arranges for .rela.plt to follow all
6081 other relocation sections, we don't have to worry
6082 about changing the DT_RELA entry. */
6083 if (htab
->elf
.srelplt
!= NULL
)
6085 s
= htab
->elf
.srelplt
->output_section
;
6086 dyn
.d_un
.d_val
-= s
->size
;
6090 case DT_TLSDESC_PLT
:
6092 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6093 + htab
->tlsdesc_plt
;
6096 case DT_TLSDESC_GOT
:
6098 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6099 + htab
->tlsdesc_got
;
6103 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
6106 /* Fill in the special first entry in the procedure linkage table. */
6107 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
6109 /* Fill in the first entry in the procedure linkage table. */
6110 memcpy (htab
->elf
.splt
->contents
,
6111 abed
->plt0_entry
, abed
->plt_entry_size
);
6112 /* Add offset for pushq GOT+8(%rip), since the instruction
6113 uses 6 bytes subtract this value. */
6114 bfd_put_32 (output_bfd
,
6115 (htab
->elf
.sgotplt
->output_section
->vma
6116 + htab
->elf
.sgotplt
->output_offset
6118 - htab
->elf
.splt
->output_section
->vma
6119 - htab
->elf
.splt
->output_offset
6121 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
6122 /* Add offset for the PC-relative instruction accessing GOT+16,
6123 subtracting the offset to the end of that instruction. */
6124 bfd_put_32 (output_bfd
,
6125 (htab
->elf
.sgotplt
->output_section
->vma
6126 + htab
->elf
.sgotplt
->output_offset
6128 - htab
->elf
.splt
->output_section
->vma
6129 - htab
->elf
.splt
->output_offset
6130 - abed
->plt0_got2_insn_end
),
6131 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
6133 elf_section_data (htab
->elf
.splt
->output_section
)
6134 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
6136 if (htab
->tlsdesc_plt
)
6138 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6139 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
6141 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
6142 abed
->plt0_entry
, abed
->plt_entry_size
);
6144 /* Add offset for pushq GOT+8(%rip), since the
6145 instruction uses 6 bytes subtract this value. */
6146 bfd_put_32 (output_bfd
,
6147 (htab
->elf
.sgotplt
->output_section
->vma
6148 + htab
->elf
.sgotplt
->output_offset
6150 - htab
->elf
.splt
->output_section
->vma
6151 - htab
->elf
.splt
->output_offset
6154 htab
->elf
.splt
->contents
6155 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
6156 /* Add offset for the PC-relative instruction accessing GOT+TDG,
6157 where TGD stands for htab->tlsdesc_got, subtracting the offset
6158 to the end of that instruction. */
6159 bfd_put_32 (output_bfd
,
6160 (htab
->elf
.sgot
->output_section
->vma
6161 + htab
->elf
.sgot
->output_offset
6163 - htab
->elf
.splt
->output_section
->vma
6164 - htab
->elf
.splt
->output_offset
6166 - abed
->plt0_got2_insn_end
),
6167 htab
->elf
.splt
->contents
6168 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
6173 if (htab
->plt_bnd
!= NULL
)
6174 elf_section_data (htab
->plt_bnd
->output_section
)
6175 ->this_hdr
.sh_entsize
= sizeof (elf_x86_64_bnd_plt2_entry
);
6177 if (htab
->elf
.sgotplt
)
6179 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
6181 (*_bfd_error_handler
)
6182 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
6186 /* Fill in the first three entries in the global offset table. */
6187 if (htab
->elf
.sgotplt
->size
> 0)
6189 /* Set the first entry in the global offset table to the address of
6190 the dynamic section. */
6192 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
6194 bfd_put_64 (output_bfd
,
6195 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
6196 htab
->elf
.sgotplt
->contents
);
6197 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
6198 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
6199 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
6202 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
6206 /* Adjust .eh_frame for .plt section. */
6207 if (htab
->plt_eh_frame
!= NULL
6208 && htab
->plt_eh_frame
->contents
!= NULL
)
6210 if (htab
->elf
.splt
!= NULL
6211 && htab
->elf
.splt
->size
!= 0
6212 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
6213 && htab
->elf
.splt
->output_section
!= NULL
6214 && htab
->plt_eh_frame
->output_section
!= NULL
)
6216 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
6217 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
6218 + htab
->plt_eh_frame
->output_offset
6219 + PLT_FDE_START_OFFSET
;
6220 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6221 htab
->plt_eh_frame
->contents
6222 + PLT_FDE_START_OFFSET
);
6224 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
6226 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6228 htab
->plt_eh_frame
->contents
))
6233 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
6234 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
6237 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
6238 htab_traverse (htab
->loc_hash_table
,
6239 elf_x86_64_finish_local_dynamic_symbol
,
6242 /* Fill PLT entries for undefined weak symbols in PIE. */
6243 if (bfd_link_pie (info
))
6244 bfd_hash_traverse (&info
->hash
->table
,
6245 elf_x86_64_pie_finish_undefweak_symbol
,
6251 /* Return an array of PLT entry symbol values. */
6254 elf_x86_64_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
6257 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
6260 bfd_vma
*plt_sym_val
;
6262 bfd_byte
*plt_contents
;
6263 const struct elf_x86_64_backend_data
*bed
;
6264 Elf_Internal_Shdr
*hdr
;
6267 /* Get the .plt section contents. PLT passed down may point to the
6268 .plt.bnd section. Make sure that PLT always points to the .plt
6270 plt_bnd
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6275 plt
= bfd_get_section_by_name (abfd
, ".plt");
6278 bed
= &elf_x86_64_bnd_arch_bed
;
6281 bed
= get_elf_x86_64_backend_data (abfd
);
6283 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
6284 if (plt_contents
== NULL
)
6286 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
6287 plt_contents
, 0, plt
->size
))
6290 free (plt_contents
);
6294 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
6295 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
6298 hdr
= &elf_section_data (relplt
)->this_hdr
;
6299 count
= relplt
->size
/ hdr
->sh_entsize
;
6301 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
6302 if (plt_sym_val
== NULL
)
6305 for (i
= 0; i
< count
; i
++)
6306 plt_sym_val
[i
] = -1;
6308 plt_offset
= bed
->plt_entry_size
;
6309 p
= relplt
->relocation
;
6310 for (i
= 0; i
< count
; i
++, p
++)
6314 /* Skip unknown relocation. */
6315 if (p
->howto
== NULL
)
6318 if (p
->howto
->type
!= R_X86_64_JUMP_SLOT
6319 && p
->howto
->type
!= R_X86_64_IRELATIVE
)
6322 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
6323 + bed
->plt_reloc_offset
));
6324 if (reloc_index
< count
)
6328 /* This is the index in .plt section. */
6329 long plt_index
= plt_offset
/ bed
->plt_entry_size
;
6330 /* Store VMA + the offset in .plt.bnd section. */
6331 plt_sym_val
[reloc_index
] =
6333 + (plt_index
- 1) * sizeof (elf_x86_64_legacy_plt2_entry
));
6336 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
6338 plt_offset
+= bed
->plt_entry_size
;
6340 /* PR binutils/18437: Skip extra relocations in the .rela.plt
6342 if (plt_offset
>= plt
->size
)
6346 free (plt_contents
);
6351 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
6355 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
6362 /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
6363 as PLT if it exists. */
6364 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6366 plt
= bfd_get_section_by_name (abfd
, ".plt");
6367 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
6368 dynsymcount
, dynsyms
, ret
,
6370 elf_x86_64_get_plt_sym_val
);
6373 /* Handle an x86-64 specific section when reading an object file. This
6374 is called when elfcode.h finds a section with an unknown type. */
6377 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
6378 const char *name
, int shindex
)
6380 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
6383 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
6389 /* Hook called by the linker routine which adds symbols from an object
6390 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
6394 elf_x86_64_add_symbol_hook (bfd
*abfd
,
6395 struct bfd_link_info
*info
,
6396 Elf_Internal_Sym
*sym
,
6397 const char **namep ATTRIBUTE_UNUSED
,
6398 flagword
*flagsp ATTRIBUTE_UNUSED
,
6404 switch (sym
->st_shndx
)
6406 case SHN_X86_64_LCOMMON
:
6407 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
6410 lcomm
= bfd_make_section_with_flags (abfd
,
6414 | SEC_LINKER_CREATED
));
6417 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
6420 *valp
= sym
->st_size
;
6424 if (ELF_ST_BIND (sym
->st_info
) == STB_GNU_UNIQUE
6425 && (abfd
->flags
& DYNAMIC
) == 0
6426 && bfd_get_flavour (info
->output_bfd
) == bfd_target_elf_flavour
)
6427 elf_tdata (info
->output_bfd
)->has_gnu_symbols
6428 |= elf_gnu_symbol_unique
;
6434 /* Given a BFD section, try to locate the corresponding ELF section
6438 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
6439 asection
*sec
, int *index_return
)
6441 if (sec
== &_bfd_elf_large_com_section
)
6443 *index_return
= SHN_X86_64_LCOMMON
;
6449 /* Process a symbol. */
6452 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
6455 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
6457 switch (elfsym
->internal_elf_sym
.st_shndx
)
6459 case SHN_X86_64_LCOMMON
:
6460 asym
->section
= &_bfd_elf_large_com_section
;
6461 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
6462 /* Common symbol doesn't set BSF_GLOBAL. */
6463 asym
->flags
&= ~BSF_GLOBAL
;
6469 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
6471 return (sym
->st_shndx
== SHN_COMMON
6472 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
6476 elf_x86_64_common_section_index (asection
*sec
)
6478 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6481 return SHN_X86_64_LCOMMON
;
6485 elf_x86_64_common_section (asection
*sec
)
6487 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6488 return bfd_com_section_ptr
;
6490 return &_bfd_elf_large_com_section
;
6494 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
6495 const Elf_Internal_Sym
*sym
,
6500 const asection
*oldsec
)
6502 /* A normal common symbol and a large common symbol result in a
6503 normal common symbol. We turn the large common symbol into a
6506 && h
->root
.type
== bfd_link_hash_common
6508 && bfd_is_com_section (*psec
)
6511 if (sym
->st_shndx
== SHN_COMMON
6512 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
6514 h
->root
.u
.c
.p
->section
6515 = bfd_make_section_old_way (oldbfd
, "COMMON");
6516 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
6518 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
6519 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
6520 *psec
= bfd_com_section_ptr
;
6527 elf_x86_64_additional_program_headers (bfd
*abfd
,
6528 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6533 /* Check to see if we need a large readonly segment. */
6534 s
= bfd_get_section_by_name (abfd
, ".lrodata");
6535 if (s
&& (s
->flags
& SEC_LOAD
))
6538 /* Check to see if we need a large data segment. Since .lbss sections
6539 is placed right after the .bss section, there should be no need for
6540 a large data segment just because of .lbss. */
6541 s
= bfd_get_section_by_name (abfd
, ".ldata");
6542 if (s
&& (s
->flags
& SEC_LOAD
))
6548 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6551 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
6553 if (h
->plt
.offset
!= (bfd_vma
) -1
6555 && !h
->pointer_equality_needed
)
6558 return _bfd_elf_hash_symbol (h
);
6561 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
6564 elf_x86_64_relocs_compatible (const bfd_target
*input
,
6565 const bfd_target
*output
)
6567 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
6568 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
6569 && _bfd_elf_relocs_compatible (input
, output
));
6572 static const struct bfd_elf_special_section
6573 elf_x86_64_special_sections
[]=
6575 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6576 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6577 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
6578 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6579 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6580 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6581 { NULL
, 0, 0, 0, 0 }
6584 #define TARGET_LITTLE_SYM x86_64_elf64_vec
6585 #define TARGET_LITTLE_NAME "elf64-x86-64"
6586 #define ELF_ARCH bfd_arch_i386
6587 #define ELF_TARGET_ID X86_64_ELF_DATA
6588 #define ELF_MACHINE_CODE EM_X86_64
6589 #define ELF_MAXPAGESIZE 0x200000
6590 #define ELF_MINPAGESIZE 0x1000
6591 #define ELF_COMMONPAGESIZE 0x1000
6593 #define elf_backend_can_gc_sections 1
6594 #define elf_backend_can_refcount 1
6595 #define elf_backend_want_got_plt 1
6596 #define elf_backend_plt_readonly 1
6597 #define elf_backend_want_plt_sym 0
6598 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
6599 #define elf_backend_rela_normal 1
6600 #define elf_backend_plt_alignment 4
6601 #define elf_backend_extern_protected_data 1
6603 #define elf_info_to_howto elf_x86_64_info_to_howto
6605 #define bfd_elf64_bfd_link_hash_table_create \
6606 elf_x86_64_link_hash_table_create
6607 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
6608 #define bfd_elf64_bfd_reloc_name_lookup \
6609 elf_x86_64_reloc_name_lookup
6611 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
6612 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
6613 #define elf_backend_check_relocs elf_x86_64_check_relocs
6614 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
6615 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
6616 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
6617 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
6618 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
6619 #define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
6620 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
6621 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
6623 #define elf_backend_write_core_note elf_x86_64_write_core_note
6625 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
6626 #define elf_backend_relocate_section elf_x86_64_relocate_section
6627 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
6628 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
6629 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
6630 #define elf_backend_object_p elf64_x86_64_elf_object_p
6631 #define bfd_elf64_mkobject elf_x86_64_mkobject
6632 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
6634 #define elf_backend_section_from_shdr \
6635 elf_x86_64_section_from_shdr
6637 #define elf_backend_section_from_bfd_section \
6638 elf_x86_64_elf_section_from_bfd_section
6639 #define elf_backend_add_symbol_hook \
6640 elf_x86_64_add_symbol_hook
6641 #define elf_backend_symbol_processing \
6642 elf_x86_64_symbol_processing
6643 #define elf_backend_common_section_index \
6644 elf_x86_64_common_section_index
6645 #define elf_backend_common_section \
6646 elf_x86_64_common_section
6647 #define elf_backend_common_definition \
6648 elf_x86_64_common_definition
6649 #define elf_backend_merge_symbol \
6650 elf_x86_64_merge_symbol
6651 #define elf_backend_special_sections \
6652 elf_x86_64_special_sections
6653 #define elf_backend_additional_program_headers \
6654 elf_x86_64_additional_program_headers
6655 #define elf_backend_hash_symbol \
6656 elf_x86_64_hash_symbol
6657 #define elf_backend_omit_section_dynsym \
6658 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6659 #define elf_backend_fixup_symbol \
6660 elf_x86_64_fixup_symbol
6662 #include "elf64-target.h"
6664 /* CloudABI support. */
6666 #undef TARGET_LITTLE_SYM
6667 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
6668 #undef TARGET_LITTLE_NAME
6669 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
6672 #define ELF_OSABI ELFOSABI_CLOUDABI
6675 #define elf64_bed elf64_x86_64_cloudabi_bed
6677 #include "elf64-target.h"
6679 /* FreeBSD support. */
6681 #undef TARGET_LITTLE_SYM
6682 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
6683 #undef TARGET_LITTLE_NAME
6684 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
6687 #define ELF_OSABI ELFOSABI_FREEBSD
6690 #define elf64_bed elf64_x86_64_fbsd_bed
6692 #include "elf64-target.h"
6694 /* Solaris 2 support. */
6696 #undef TARGET_LITTLE_SYM
6697 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
6698 #undef TARGET_LITTLE_NAME
6699 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
6701 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6702 objects won't be recognized. */
6706 #define elf64_bed elf64_x86_64_sol2_bed
6708 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
6710 #undef elf_backend_static_tls_alignment
6711 #define elf_backend_static_tls_alignment 16
6713 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6715 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6717 #undef elf_backend_want_plt_sym
6718 #define elf_backend_want_plt_sym 1
6720 #undef elf_backend_strtab_flags
6721 #define elf_backend_strtab_flags SHF_STRINGS
6724 elf64_x86_64_set_special_info_link (const bfd
*ibfd ATTRIBUTE_UNUSED
,
6725 bfd
*obfd ATTRIBUTE_UNUSED
,
6726 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
6727 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
6729 /* PR 19938: FIXME: Need to add code for setting the sh_info
6730 and sh_link fields of Solaris specific section types. */
6734 #undef elf_backend_set_special_section_info_and_link
6735 #define elf_backend_set_special_section_info_and_link elf64_x86_64_set_special_info_link
6737 #include "elf64-target.h"
6739 /* Native Client support. */
6742 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
6744 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
6745 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
6749 #undef TARGET_LITTLE_SYM
6750 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
6751 #undef TARGET_LITTLE_NAME
6752 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
6754 #define elf64_bed elf64_x86_64_nacl_bed
6756 #undef ELF_MAXPAGESIZE
6757 #undef ELF_MINPAGESIZE
6758 #undef ELF_COMMONPAGESIZE
6759 #define ELF_MAXPAGESIZE 0x10000
6760 #define ELF_MINPAGESIZE 0x10000
6761 #define ELF_COMMONPAGESIZE 0x10000
6763 /* Restore defaults. */
6765 #undef elf_backend_static_tls_alignment
6766 #undef elf_backend_want_plt_sym
6767 #define elf_backend_want_plt_sym 0
6768 #undef elf_backend_strtab_flags
6769 #undef elf_backend_set_special_section_info_and_link
6771 /* NaCl uses substantially different PLT entries for the same effects. */
6773 #undef elf_backend_plt_alignment
6774 #define elf_backend_plt_alignment 5
6775 #define NACL_PLT_ENTRY_SIZE 64
6776 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6778 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
6780 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
6781 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
6782 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6783 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6784 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6786 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
6787 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
6789 /* 32 bytes of nop to pad out to the standard size. */
6790 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6791 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6792 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6793 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6794 0x66, /* excess data32 prefix */
6798 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6800 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
6801 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6802 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6803 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6805 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
6806 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6807 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6809 /* Lazy GOT entries point here (32-byte aligned). */
6810 0x68, /* pushq immediate */
6811 0, 0, 0, 0, /* replaced with index into relocation table. */
6812 0xe9, /* jmp relative */
6813 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
6815 /* 22 bytes of nop to pad out to the standard size. */
6816 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6817 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6818 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
6821 /* .eh_frame covering the .plt section. */
6823 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
6825 #if (PLT_CIE_LENGTH != 20 \
6826 || PLT_FDE_LENGTH != 36 \
6827 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6828 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6829 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
6831 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6832 0, 0, 0, 0, /* CIE ID */
6833 1, /* CIE version */
6834 'z', 'R', 0, /* Augmentation string */
6835 1, /* Code alignment factor */
6836 0x78, /* Data alignment factor */
6837 16, /* Return address column */
6838 1, /* Augmentation size */
6839 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6840 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
6841 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
6842 DW_CFA_nop
, DW_CFA_nop
,
6844 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6845 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
6846 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
6847 0, 0, 0, 0, /* .plt size goes here */
6848 0, /* Augmentation size */
6849 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
6850 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6851 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
6852 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6853 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6854 13, /* Block length */
6855 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
6856 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
6857 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6858 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
6859 DW_CFA_nop
, DW_CFA_nop
6862 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
6864 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
6865 elf_x86_64_nacl_plt_entry
, /* plt_entry */
6866 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6867 2, /* plt0_got1_offset */
6868 9, /* plt0_got2_offset */
6869 13, /* plt0_got2_insn_end */
6870 3, /* plt_got_offset */
6871 33, /* plt_reloc_offset */
6872 38, /* plt_plt_offset */
6873 7, /* plt_got_insn_size */
6874 42, /* plt_plt_insn_end */
6875 32, /* plt_lazy_offset */
6876 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
6877 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
6880 #undef elf_backend_arch_data
6881 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
6883 #undef elf_backend_object_p
6884 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
6885 #undef elf_backend_modify_segment_map
6886 #define elf_backend_modify_segment_map nacl_modify_segment_map
6887 #undef elf_backend_modify_program_headers
6888 #define elf_backend_modify_program_headers nacl_modify_program_headers
6889 #undef elf_backend_final_write_processing
6890 #define elf_backend_final_write_processing nacl_final_write_processing
6892 #include "elf64-target.h"
6894 /* Native Client x32 support. */
6897 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
6899 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
6900 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
6904 #undef TARGET_LITTLE_SYM
6905 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
6906 #undef TARGET_LITTLE_NAME
6907 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
6909 #define elf32_bed elf32_x86_64_nacl_bed
6911 #define bfd_elf32_bfd_link_hash_table_create \
6912 elf_x86_64_link_hash_table_create
6913 #define bfd_elf32_bfd_reloc_type_lookup \
6914 elf_x86_64_reloc_type_lookup
6915 #define bfd_elf32_bfd_reloc_name_lookup \
6916 elf_x86_64_reloc_name_lookup
6917 #define bfd_elf32_mkobject \
6919 #define bfd_elf32_get_synthetic_symtab \
6920 elf_x86_64_get_synthetic_symtab
6922 #undef elf_backend_object_p
6923 #define elf_backend_object_p \
6924 elf32_x86_64_nacl_elf_object_p
6926 #undef elf_backend_bfd_from_remote_memory
6927 #define elf_backend_bfd_from_remote_memory \
6928 _bfd_elf32_bfd_from_remote_memory
6930 #undef elf_backend_size_info
6931 #define elf_backend_size_info \
6932 _bfd_elf32_size_info
6934 #include "elf32-target.h"
6936 /* Restore defaults. */
6937 #undef elf_backend_object_p
6938 #define elf_backend_object_p elf64_x86_64_elf_object_p
6939 #undef elf_backend_bfd_from_remote_memory
6940 #undef elf_backend_size_info
6941 #undef elf_backend_modify_segment_map
6942 #undef elf_backend_modify_program_headers
6943 #undef elf_backend_final_write_processing
6945 /* Intel L1OM support. */
6948 elf64_l1om_elf_object_p (bfd
*abfd
)
6950 /* Set the right machine number for an L1OM elf64 file. */
6951 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
6955 #undef TARGET_LITTLE_SYM
6956 #define TARGET_LITTLE_SYM l1om_elf64_vec
6957 #undef TARGET_LITTLE_NAME
6958 #define TARGET_LITTLE_NAME "elf64-l1om"
6960 #define ELF_ARCH bfd_arch_l1om
6962 #undef ELF_MACHINE_CODE
6963 #define ELF_MACHINE_CODE EM_L1OM
6968 #define elf64_bed elf64_l1om_bed
6970 #undef elf_backend_object_p
6971 #define elf_backend_object_p elf64_l1om_elf_object_p
6973 /* Restore defaults. */
6974 #undef ELF_MAXPAGESIZE
6975 #undef ELF_MINPAGESIZE
6976 #undef ELF_COMMONPAGESIZE
6977 #define ELF_MAXPAGESIZE 0x200000
6978 #define ELF_MINPAGESIZE 0x1000
6979 #define ELF_COMMONPAGESIZE 0x1000
6980 #undef elf_backend_plt_alignment
6981 #define elf_backend_plt_alignment 4
6982 #undef elf_backend_arch_data
6983 #define elf_backend_arch_data &elf_x86_64_arch_bed
6985 #include "elf64-target.h"
6987 /* FreeBSD L1OM support. */
6989 #undef TARGET_LITTLE_SYM
6990 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
6991 #undef TARGET_LITTLE_NAME
6992 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
6995 #define ELF_OSABI ELFOSABI_FREEBSD
6998 #define elf64_bed elf64_l1om_fbsd_bed
7000 #include "elf64-target.h"
7002 /* Intel K1OM support. */
7005 elf64_k1om_elf_object_p (bfd
*abfd
)
7007 /* Set the right machine number for an K1OM elf64 file. */
7008 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
7012 #undef TARGET_LITTLE_SYM
7013 #define TARGET_LITTLE_SYM k1om_elf64_vec
7014 #undef TARGET_LITTLE_NAME
7015 #define TARGET_LITTLE_NAME "elf64-k1om"
7017 #define ELF_ARCH bfd_arch_k1om
7019 #undef ELF_MACHINE_CODE
7020 #define ELF_MACHINE_CODE EM_K1OM
7025 #define elf64_bed elf64_k1om_bed
7027 #undef elf_backend_object_p
7028 #define elf_backend_object_p elf64_k1om_elf_object_p
7030 #undef elf_backend_static_tls_alignment
7032 #undef elf_backend_want_plt_sym
7033 #define elf_backend_want_plt_sym 0
7035 #include "elf64-target.h"
7037 /* FreeBSD K1OM support. */
7039 #undef TARGET_LITTLE_SYM
7040 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
7041 #undef TARGET_LITTLE_NAME
7042 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
7045 #define ELF_OSABI ELFOSABI_FREEBSD
7048 #define elf64_bed elf64_k1om_fbsd_bed
7050 #include "elf64-target.h"
7052 /* 32bit x86-64 support. */
7054 #undef TARGET_LITTLE_SYM
7055 #define TARGET_LITTLE_SYM x86_64_elf32_vec
7056 #undef TARGET_LITTLE_NAME
7057 #define TARGET_LITTLE_NAME "elf32-x86-64"
7061 #define ELF_ARCH bfd_arch_i386
7063 #undef ELF_MACHINE_CODE
7064 #define ELF_MACHINE_CODE EM_X86_64
7068 #undef elf_backend_object_p
7069 #define elf_backend_object_p \
7070 elf32_x86_64_elf_object_p
7072 #undef elf_backend_bfd_from_remote_memory
7073 #define elf_backend_bfd_from_remote_memory \
7074 _bfd_elf32_bfd_from_remote_memory
7076 #undef elf_backend_size_info
7077 #define elf_backend_size_info \
7078 _bfd_elf32_size_info
7080 #include "elf32-target.h"