1 /* X86-64 specific support for ELF
2 Copyright (C) 2000-2016 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka <jh@suse.cz>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
28 #include "bfd_stdint.h"
32 #include "libiberty.h"
34 #include "opcode/i386.h"
35 #include "elf/x86-64.h"
42 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
43 #define MINUS_ONE (~ (bfd_vma) 0)
45 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
46 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
47 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
48 since they are the same. */
50 #define ABI_64_P(abfd) \
51 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
53 /* The relocation "howto" table. Order of fields:
54 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
55 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
56 static reloc_howto_type x86_64_elf_howto_table
[] =
58 HOWTO(R_X86_64_NONE
, 0, 3, 0, FALSE
, 0, complain_overflow_dont
,
59 bfd_elf_generic_reloc
, "R_X86_64_NONE", FALSE
, 0x00000000, 0x00000000,
61 HOWTO(R_X86_64_64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
62 bfd_elf_generic_reloc
, "R_X86_64_64", FALSE
, MINUS_ONE
, MINUS_ONE
,
64 HOWTO(R_X86_64_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
65 bfd_elf_generic_reloc
, "R_X86_64_PC32", FALSE
, 0xffffffff, 0xffffffff,
67 HOWTO(R_X86_64_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
68 bfd_elf_generic_reloc
, "R_X86_64_GOT32", FALSE
, 0xffffffff, 0xffffffff,
70 HOWTO(R_X86_64_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
71 bfd_elf_generic_reloc
, "R_X86_64_PLT32", FALSE
, 0xffffffff, 0xffffffff,
73 HOWTO(R_X86_64_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
74 bfd_elf_generic_reloc
, "R_X86_64_COPY", FALSE
, 0xffffffff, 0xffffffff,
76 HOWTO(R_X86_64_GLOB_DAT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
77 bfd_elf_generic_reloc
, "R_X86_64_GLOB_DAT", FALSE
, MINUS_ONE
,
79 HOWTO(R_X86_64_JUMP_SLOT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
80 bfd_elf_generic_reloc
, "R_X86_64_JUMP_SLOT", FALSE
, MINUS_ONE
,
82 HOWTO(R_X86_64_RELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
83 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE", FALSE
, MINUS_ONE
,
85 HOWTO(R_X86_64_GOTPCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
86 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL", FALSE
, 0xffffffff,
88 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
89 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
91 HOWTO(R_X86_64_32S
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
92 bfd_elf_generic_reloc
, "R_X86_64_32S", FALSE
, 0xffffffff, 0xffffffff,
94 HOWTO(R_X86_64_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
95 bfd_elf_generic_reloc
, "R_X86_64_16", FALSE
, 0xffff, 0xffff, FALSE
),
96 HOWTO(R_X86_64_PC16
,0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
97 bfd_elf_generic_reloc
, "R_X86_64_PC16", FALSE
, 0xffff, 0xffff, TRUE
),
98 HOWTO(R_X86_64_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
99 bfd_elf_generic_reloc
, "R_X86_64_8", FALSE
, 0xff, 0xff, FALSE
),
100 HOWTO(R_X86_64_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
101 bfd_elf_generic_reloc
, "R_X86_64_PC8", FALSE
, 0xff, 0xff, TRUE
),
102 HOWTO(R_X86_64_DTPMOD64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
103 bfd_elf_generic_reloc
, "R_X86_64_DTPMOD64", FALSE
, MINUS_ONE
,
105 HOWTO(R_X86_64_DTPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
106 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF64", FALSE
, MINUS_ONE
,
108 HOWTO(R_X86_64_TPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
109 bfd_elf_generic_reloc
, "R_X86_64_TPOFF64", FALSE
, MINUS_ONE
,
111 HOWTO(R_X86_64_TLSGD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
112 bfd_elf_generic_reloc
, "R_X86_64_TLSGD", FALSE
, 0xffffffff,
114 HOWTO(R_X86_64_TLSLD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
115 bfd_elf_generic_reloc
, "R_X86_64_TLSLD", FALSE
, 0xffffffff,
117 HOWTO(R_X86_64_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
118 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF32", FALSE
, 0xffffffff,
120 HOWTO(R_X86_64_GOTTPOFF
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
121 bfd_elf_generic_reloc
, "R_X86_64_GOTTPOFF", FALSE
, 0xffffffff,
123 HOWTO(R_X86_64_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
124 bfd_elf_generic_reloc
, "R_X86_64_TPOFF32", FALSE
, 0xffffffff,
126 HOWTO(R_X86_64_PC64
, 0, 4, 64, TRUE
, 0, complain_overflow_bitfield
,
127 bfd_elf_generic_reloc
, "R_X86_64_PC64", FALSE
, MINUS_ONE
, MINUS_ONE
,
129 HOWTO(R_X86_64_GOTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
130 bfd_elf_generic_reloc
, "R_X86_64_GOTOFF64",
131 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
132 HOWTO(R_X86_64_GOTPC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
133 bfd_elf_generic_reloc
, "R_X86_64_GOTPC32",
134 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
135 HOWTO(R_X86_64_GOT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
136 bfd_elf_generic_reloc
, "R_X86_64_GOT64", FALSE
, MINUS_ONE
, MINUS_ONE
,
138 HOWTO(R_X86_64_GOTPCREL64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
139 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL64", FALSE
, MINUS_ONE
,
141 HOWTO(R_X86_64_GOTPC64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
142 bfd_elf_generic_reloc
, "R_X86_64_GOTPC64",
143 FALSE
, MINUS_ONE
, MINUS_ONE
, TRUE
),
144 HOWTO(R_X86_64_GOTPLT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
145 bfd_elf_generic_reloc
, "R_X86_64_GOTPLT64", FALSE
, MINUS_ONE
,
147 HOWTO(R_X86_64_PLTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
148 bfd_elf_generic_reloc
, "R_X86_64_PLTOFF64", FALSE
, MINUS_ONE
,
150 HOWTO(R_X86_64_SIZE32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
151 bfd_elf_generic_reloc
, "R_X86_64_SIZE32", FALSE
, 0xffffffff, 0xffffffff,
153 HOWTO(R_X86_64_SIZE64
, 0, 4, 64, FALSE
, 0, complain_overflow_unsigned
,
154 bfd_elf_generic_reloc
, "R_X86_64_SIZE64", FALSE
, MINUS_ONE
, MINUS_ONE
,
156 HOWTO(R_X86_64_GOTPC32_TLSDESC
, 0, 2, 32, TRUE
, 0,
157 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
158 "R_X86_64_GOTPC32_TLSDESC",
159 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
160 HOWTO(R_X86_64_TLSDESC_CALL
, 0, 0, 0, FALSE
, 0,
161 complain_overflow_dont
, bfd_elf_generic_reloc
,
162 "R_X86_64_TLSDESC_CALL",
164 HOWTO(R_X86_64_TLSDESC
, 0, 4, 64, FALSE
, 0,
165 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
167 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
168 HOWTO(R_X86_64_IRELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
169 bfd_elf_generic_reloc
, "R_X86_64_IRELATIVE", FALSE
, MINUS_ONE
,
171 HOWTO(R_X86_64_RELATIVE64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
172 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE64", FALSE
, MINUS_ONE
,
174 HOWTO(R_X86_64_PC32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
175 bfd_elf_generic_reloc
, "R_X86_64_PC32_BND", FALSE
, 0xffffffff, 0xffffffff,
177 HOWTO(R_X86_64_PLT32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
178 bfd_elf_generic_reloc
, "R_X86_64_PLT32_BND", FALSE
, 0xffffffff, 0xffffffff,
180 HOWTO(R_X86_64_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
181 bfd_elf_generic_reloc
, "R_X86_64_GOTPCRELX", FALSE
, 0xffffffff,
183 HOWTO(R_X86_64_REX_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
184 bfd_elf_generic_reloc
, "R_X86_64_REX_GOTPCRELX", FALSE
, 0xffffffff,
187 /* We have a gap in the reloc numbers here.
188 R_X86_64_standard counts the number up to this point, and
189 R_X86_64_vt_offset is the value to subtract from a reloc type of
190 R_X86_64_GNU_VT* to form an index into this table. */
191 #define R_X86_64_standard (R_X86_64_REX_GOTPCRELX + 1)
192 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
194 /* GNU extension to record C++ vtable hierarchy. */
195 HOWTO (R_X86_64_GNU_VTINHERIT
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
196 NULL
, "R_X86_64_GNU_VTINHERIT", FALSE
, 0, 0, FALSE
),
198 /* GNU extension to record C++ vtable member usage. */
199 HOWTO (R_X86_64_GNU_VTENTRY
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
200 _bfd_elf_rel_vtable_reloc_fn
, "R_X86_64_GNU_VTENTRY", FALSE
, 0, 0,
203 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
204 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
205 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
209 #define IS_X86_64_PCREL_TYPE(TYPE) \
210 ( ((TYPE) == R_X86_64_PC8) \
211 || ((TYPE) == R_X86_64_PC16) \
212 || ((TYPE) == R_X86_64_PC32) \
213 || ((TYPE) == R_X86_64_PC32_BND) \
214 || ((TYPE) == R_X86_64_PC64))
216 /* Map BFD relocs to the x86_64 elf relocs. */
219 bfd_reloc_code_real_type bfd_reloc_val
;
220 unsigned char elf_reloc_val
;
223 static const struct elf_reloc_map x86_64_reloc_map
[] =
225 { BFD_RELOC_NONE
, R_X86_64_NONE
, },
226 { BFD_RELOC_64
, R_X86_64_64
, },
227 { BFD_RELOC_32_PCREL
, R_X86_64_PC32
, },
228 { BFD_RELOC_X86_64_GOT32
, R_X86_64_GOT32
,},
229 { BFD_RELOC_X86_64_PLT32
, R_X86_64_PLT32
,},
230 { BFD_RELOC_X86_64_COPY
, R_X86_64_COPY
, },
231 { BFD_RELOC_X86_64_GLOB_DAT
, R_X86_64_GLOB_DAT
, },
232 { BFD_RELOC_X86_64_JUMP_SLOT
, R_X86_64_JUMP_SLOT
, },
233 { BFD_RELOC_X86_64_RELATIVE
, R_X86_64_RELATIVE
, },
234 { BFD_RELOC_X86_64_GOTPCREL
, R_X86_64_GOTPCREL
, },
235 { BFD_RELOC_32
, R_X86_64_32
, },
236 { BFD_RELOC_X86_64_32S
, R_X86_64_32S
, },
237 { BFD_RELOC_16
, R_X86_64_16
, },
238 { BFD_RELOC_16_PCREL
, R_X86_64_PC16
, },
239 { BFD_RELOC_8
, R_X86_64_8
, },
240 { BFD_RELOC_8_PCREL
, R_X86_64_PC8
, },
241 { BFD_RELOC_X86_64_DTPMOD64
, R_X86_64_DTPMOD64
, },
242 { BFD_RELOC_X86_64_DTPOFF64
, R_X86_64_DTPOFF64
, },
243 { BFD_RELOC_X86_64_TPOFF64
, R_X86_64_TPOFF64
, },
244 { BFD_RELOC_X86_64_TLSGD
, R_X86_64_TLSGD
, },
245 { BFD_RELOC_X86_64_TLSLD
, R_X86_64_TLSLD
, },
246 { BFD_RELOC_X86_64_DTPOFF32
, R_X86_64_DTPOFF32
, },
247 { BFD_RELOC_X86_64_GOTTPOFF
, R_X86_64_GOTTPOFF
, },
248 { BFD_RELOC_X86_64_TPOFF32
, R_X86_64_TPOFF32
, },
249 { BFD_RELOC_64_PCREL
, R_X86_64_PC64
, },
250 { BFD_RELOC_X86_64_GOTOFF64
, R_X86_64_GOTOFF64
, },
251 { BFD_RELOC_X86_64_GOTPC32
, R_X86_64_GOTPC32
, },
252 { BFD_RELOC_X86_64_GOT64
, R_X86_64_GOT64
, },
253 { BFD_RELOC_X86_64_GOTPCREL64
,R_X86_64_GOTPCREL64
, },
254 { BFD_RELOC_X86_64_GOTPC64
, R_X86_64_GOTPC64
, },
255 { BFD_RELOC_X86_64_GOTPLT64
, R_X86_64_GOTPLT64
, },
256 { BFD_RELOC_X86_64_PLTOFF64
, R_X86_64_PLTOFF64
, },
257 { BFD_RELOC_SIZE32
, R_X86_64_SIZE32
, },
258 { BFD_RELOC_SIZE64
, R_X86_64_SIZE64
, },
259 { BFD_RELOC_X86_64_GOTPC32_TLSDESC
, R_X86_64_GOTPC32_TLSDESC
, },
260 { BFD_RELOC_X86_64_TLSDESC_CALL
, R_X86_64_TLSDESC_CALL
, },
261 { BFD_RELOC_X86_64_TLSDESC
, R_X86_64_TLSDESC
, },
262 { BFD_RELOC_X86_64_IRELATIVE
, R_X86_64_IRELATIVE
, },
263 { BFD_RELOC_X86_64_PC32_BND
, R_X86_64_PC32_BND
, },
264 { BFD_RELOC_X86_64_PLT32_BND
, R_X86_64_PLT32_BND
, },
265 { BFD_RELOC_X86_64_GOTPCRELX
, R_X86_64_GOTPCRELX
, },
266 { BFD_RELOC_X86_64_REX_GOTPCRELX
, R_X86_64_REX_GOTPCRELX
, },
267 { BFD_RELOC_VTABLE_INHERIT
, R_X86_64_GNU_VTINHERIT
, },
268 { BFD_RELOC_VTABLE_ENTRY
, R_X86_64_GNU_VTENTRY
, },
271 static reloc_howto_type
*
272 elf_x86_64_rtype_to_howto (bfd
*abfd
, unsigned r_type
)
276 if (r_type
== (unsigned int) R_X86_64_32
)
281 i
= ARRAY_SIZE (x86_64_elf_howto_table
) - 1;
283 else if (r_type
< (unsigned int) R_X86_64_GNU_VTINHERIT
284 || r_type
>= (unsigned int) R_X86_64_max
)
286 if (r_type
>= (unsigned int) R_X86_64_standard
)
288 (*_bfd_error_handler
) (_("%B: invalid relocation type %d"),
290 r_type
= R_X86_64_NONE
;
295 i
= r_type
- (unsigned int) R_X86_64_vt_offset
;
296 BFD_ASSERT (x86_64_elf_howto_table
[i
].type
== r_type
);
297 return &x86_64_elf_howto_table
[i
];
300 /* Given a BFD reloc type, return a HOWTO structure. */
301 static reloc_howto_type
*
302 elf_x86_64_reloc_type_lookup (bfd
*abfd
,
303 bfd_reloc_code_real_type code
)
307 for (i
= 0; i
< sizeof (x86_64_reloc_map
) / sizeof (struct elf_reloc_map
);
310 if (x86_64_reloc_map
[i
].bfd_reloc_val
== code
)
311 return elf_x86_64_rtype_to_howto (abfd
,
312 x86_64_reloc_map
[i
].elf_reloc_val
);
317 static reloc_howto_type
*
318 elf_x86_64_reloc_name_lookup (bfd
*abfd
,
323 if (!ABI_64_P (abfd
) && strcasecmp (r_name
, "R_X86_64_32") == 0)
325 /* Get x32 R_X86_64_32. */
326 reloc_howto_type
*reloc
327 = &x86_64_elf_howto_table
[ARRAY_SIZE (x86_64_elf_howto_table
) - 1];
328 BFD_ASSERT (reloc
->type
== (unsigned int) R_X86_64_32
);
332 for (i
= 0; i
< ARRAY_SIZE (x86_64_elf_howto_table
); i
++)
333 if (x86_64_elf_howto_table
[i
].name
!= NULL
334 && strcasecmp (x86_64_elf_howto_table
[i
].name
, r_name
) == 0)
335 return &x86_64_elf_howto_table
[i
];
340 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
343 elf_x86_64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
344 Elf_Internal_Rela
*dst
)
348 r_type
= ELF32_R_TYPE (dst
->r_info
);
349 cache_ptr
->howto
= elf_x86_64_rtype_to_howto (abfd
, r_type
);
350 BFD_ASSERT (r_type
== cache_ptr
->howto
->type
);
353 /* Support for core dump NOTE sections. */
355 elf_x86_64_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
360 switch (note
->descsz
)
365 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
367 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
370 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
378 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
380 elf_tdata (abfd
)->core
->signal
381 = bfd_get_16 (abfd
, note
->descdata
+ 12);
384 elf_tdata (abfd
)->core
->lwpid
385 = bfd_get_32 (abfd
, note
->descdata
+ 32);
394 /* Make a ".reg/999" section. */
395 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
396 size
, note
->descpos
+ offset
);
400 elf_x86_64_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
402 switch (note
->descsz
)
407 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
408 elf_tdata (abfd
)->core
->pid
409 = bfd_get_32 (abfd
, note
->descdata
+ 12);
410 elf_tdata (abfd
)->core
->program
411 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
412 elf_tdata (abfd
)->core
->command
413 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
416 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
417 elf_tdata (abfd
)->core
->pid
418 = bfd_get_32 (abfd
, note
->descdata
+ 24);
419 elf_tdata (abfd
)->core
->program
420 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
421 elf_tdata (abfd
)->core
->command
422 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
425 /* Note that for some reason, a spurious space is tacked
426 onto the end of the args in some (at least one anyway)
427 implementations, so strip it off if it exists. */
430 char *command
= elf_tdata (abfd
)->core
->command
;
431 int n
= strlen (command
);
433 if (0 < n
&& command
[n
- 1] == ' ')
434 command
[n
- 1] = '\0';
442 elf_x86_64_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
,
445 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
447 const char *fname
, *psargs
;
458 va_start (ap
, note_type
);
459 fname
= va_arg (ap
, const char *);
460 psargs
= va_arg (ap
, const char *);
463 if (bed
->s
->elfclass
== ELFCLASS32
)
466 memset (&data
, 0, sizeof (data
));
467 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
468 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
469 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
470 &data
, sizeof (data
));
475 memset (&data
, 0, sizeof (data
));
476 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
477 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
478 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
479 &data
, sizeof (data
));
484 va_start (ap
, note_type
);
485 pid
= va_arg (ap
, long);
486 cursig
= va_arg (ap
, int);
487 gregs
= va_arg (ap
, const void *);
490 if (bed
->s
->elfclass
== ELFCLASS32
)
492 if (bed
->elf_machine_code
== EM_X86_64
)
494 prstatusx32_t prstat
;
495 memset (&prstat
, 0, sizeof (prstat
));
497 prstat
.pr_cursig
= cursig
;
498 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
499 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
500 &prstat
, sizeof (prstat
));
505 memset (&prstat
, 0, sizeof (prstat
));
507 prstat
.pr_cursig
= cursig
;
508 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
509 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
510 &prstat
, sizeof (prstat
));
516 memset (&prstat
, 0, sizeof (prstat
));
518 prstat
.pr_cursig
= cursig
;
519 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
520 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
521 &prstat
, sizeof (prstat
));
528 /* Functions for the x86-64 ELF linker. */
530 /* The name of the dynamic interpreter. This is put in the .interp
533 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
534 #define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
536 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
537 copying dynamic variables from a shared lib into an app's dynbss
538 section, and instead use a dynamic relocation to point into the
540 #define ELIMINATE_COPY_RELOCS 1
542 /* The size in bytes of an entry in the global offset table. */
544 #define GOT_ENTRY_SIZE 8
546 /* The size in bytes of an entry in the procedure linkage table. */
548 #define PLT_ENTRY_SIZE 16
550 /* The first entry in a procedure linkage table looks like this. See the
551 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
553 static const bfd_byte elf_x86_64_plt0_entry
[PLT_ENTRY_SIZE
] =
555 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
556 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
557 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
560 /* Subsequent entries in a procedure linkage table look like this. */
562 static const bfd_byte elf_x86_64_plt_entry
[PLT_ENTRY_SIZE
] =
564 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
565 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
566 0x68, /* pushq immediate */
567 0, 0, 0, 0, /* replaced with index into relocation table. */
568 0xe9, /* jmp relative */
569 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
572 /* The first entry in a procedure linkage table with BND relocations
575 static const bfd_byte elf_x86_64_bnd_plt0_entry
[PLT_ENTRY_SIZE
] =
577 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
578 0xf2, 0xff, 0x25, 16, 0, 0, 0, /* bnd jmpq *GOT+16(%rip) */
579 0x0f, 0x1f, 0 /* nopl (%rax) */
582 /* Subsequent entries for legacy branches in a procedure linkage table
583 with BND relocations look like this. */
585 static const bfd_byte elf_x86_64_legacy_plt_entry
[PLT_ENTRY_SIZE
] =
587 0x68, 0, 0, 0, 0, /* pushq immediate */
588 0xe9, 0, 0, 0, 0, /* jmpq relative */
589 0x66, 0x0f, 0x1f, 0x44, 0, 0 /* nopw (%rax,%rax,1) */
592 /* Subsequent entries for branches with BND prefx in a procedure linkage
593 table with BND relocations look like this. */
595 static const bfd_byte elf_x86_64_bnd_plt_entry
[PLT_ENTRY_SIZE
] =
597 0x68, 0, 0, 0, 0, /* pushq immediate */
598 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
599 0x0f, 0x1f, 0x44, 0, 0 /* nopl 0(%rax,%rax,1) */
602 /* Entries for legacy branches in the second procedure linkage table
605 static const bfd_byte elf_x86_64_legacy_plt2_entry
[8] =
607 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
608 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
609 0x66, 0x90 /* xchg %ax,%ax */
612 /* Entries for branches with BND prefix in the second procedure linkage
613 table look like this. */
615 static const bfd_byte elf_x86_64_bnd_plt2_entry
[8] =
617 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
618 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
622 /* .eh_frame covering the .plt section. */
624 static const bfd_byte elf_x86_64_eh_frame_plt
[] =
626 #define PLT_CIE_LENGTH 20
627 #define PLT_FDE_LENGTH 36
628 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
629 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
630 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
631 0, 0, 0, 0, /* CIE ID */
633 'z', 'R', 0, /* Augmentation string */
634 1, /* Code alignment factor */
635 0x78, /* Data alignment factor */
636 16, /* Return address column */
637 1, /* Augmentation size */
638 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
639 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
640 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
641 DW_CFA_nop
, DW_CFA_nop
,
643 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
644 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
645 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
646 0, 0, 0, 0, /* .plt size goes here */
647 0, /* Augmentation size */
648 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
649 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
650 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
651 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
652 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
653 11, /* Block length */
654 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
655 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
656 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
657 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
658 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
661 /* Architecture-specific backend data for x86-64. */
663 struct elf_x86_64_backend_data
665 /* Templates for the initial PLT entry and for subsequent entries. */
666 const bfd_byte
*plt0_entry
;
667 const bfd_byte
*plt_entry
;
668 unsigned int plt_entry_size
; /* Size of each PLT entry. */
670 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
671 unsigned int plt0_got1_offset
;
672 unsigned int plt0_got2_offset
;
674 /* Offset of the end of the PC-relative instruction containing
676 unsigned int plt0_got2_insn_end
;
678 /* Offsets into plt_entry that are to be replaced with... */
679 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
680 unsigned int plt_reloc_offset
; /* ... offset into relocation table. */
681 unsigned int plt_plt_offset
; /* ... offset to start of .plt. */
683 /* Length of the PC-relative instruction containing plt_got_offset. */
684 unsigned int plt_got_insn_size
;
686 /* Offset of the end of the PC-relative jump to plt0_entry. */
687 unsigned int plt_plt_insn_end
;
689 /* Offset into plt_entry where the initial value of the GOT entry points. */
690 unsigned int plt_lazy_offset
;
692 /* .eh_frame covering the .plt section. */
693 const bfd_byte
*eh_frame_plt
;
694 unsigned int eh_frame_plt_size
;
697 #define get_elf_x86_64_arch_data(bed) \
698 ((const struct elf_x86_64_backend_data *) (bed)->arch_data)
700 #define get_elf_x86_64_backend_data(abfd) \
701 get_elf_x86_64_arch_data (get_elf_backend_data (abfd))
703 #define GET_PLT_ENTRY_SIZE(abfd) \
704 get_elf_x86_64_backend_data (abfd)->plt_entry_size
706 /* These are the standard parameters. */
707 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed
=
709 elf_x86_64_plt0_entry
, /* plt0_entry */
710 elf_x86_64_plt_entry
, /* plt_entry */
711 sizeof (elf_x86_64_plt_entry
), /* plt_entry_size */
712 2, /* plt0_got1_offset */
713 8, /* plt0_got2_offset */
714 12, /* plt0_got2_insn_end */
715 2, /* plt_got_offset */
716 7, /* plt_reloc_offset */
717 12, /* plt_plt_offset */
718 6, /* plt_got_insn_size */
719 PLT_ENTRY_SIZE
, /* plt_plt_insn_end */
720 6, /* plt_lazy_offset */
721 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
722 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
725 static const struct elf_x86_64_backend_data elf_x86_64_bnd_arch_bed
=
727 elf_x86_64_bnd_plt0_entry
, /* plt0_entry */
728 elf_x86_64_bnd_plt_entry
, /* plt_entry */
729 sizeof (elf_x86_64_bnd_plt_entry
), /* plt_entry_size */
730 2, /* plt0_got1_offset */
731 1+8, /* plt0_got2_offset */
732 1+12, /* plt0_got2_insn_end */
733 1+2, /* plt_got_offset */
734 1, /* plt_reloc_offset */
735 7, /* plt_plt_offset */
736 1+6, /* plt_got_insn_size */
737 11, /* plt_plt_insn_end */
738 0, /* plt_lazy_offset */
739 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
740 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
743 #define elf_backend_arch_data &elf_x86_64_arch_bed
745 /* Is a undefined weak symbol which is resolved to 0. Reference to an
746 undefined weak symbol is resolved to 0 when building executable if
748 1. Has non-GOT/non-PLT relocations in text section. Or
749 2. Has no GOT/PLT relocation.
751 #define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, GOT_RELOC, EH) \
752 ((EH)->elf.root.type == bfd_link_hash_undefweak \
753 && bfd_link_executable (INFO) \
754 && (elf_x86_64_hash_table (INFO)->interp == NULL \
756 || (EH)->has_non_got_reloc \
757 || !(INFO)->dynamic_undefined_weak))
759 /* x86-64 ELF linker hash entry. */
761 struct elf_x86_64_link_hash_entry
763 struct elf_link_hash_entry elf
;
765 /* Track dynamic relocs copied for this symbol. */
766 struct elf_dyn_relocs
*dyn_relocs
;
768 #define GOT_UNKNOWN 0
772 #define GOT_TLS_GDESC 4
773 #define GOT_TLS_GD_BOTH_P(type) \
774 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
775 #define GOT_TLS_GD_P(type) \
776 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
777 #define GOT_TLS_GDESC_P(type) \
778 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
779 #define GOT_TLS_GD_ANY_P(type) \
780 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
781 unsigned char tls_type
;
783 /* TRUE if a weak symbol with a real definition needs a copy reloc.
784 When there is a weak symbol with a real definition, the processor
785 independent code will have arranged for us to see the real
786 definition first. We need to copy the needs_copy bit from the
787 real definition and check it when allowing copy reloc in PIE. */
788 unsigned int needs_copy
: 1;
790 /* TRUE if symbol has at least one BND relocation. */
791 unsigned int has_bnd_reloc
: 1;
793 /* TRUE if symbol has GOT or PLT relocations. */
794 unsigned int has_got_reloc
: 1;
796 /* TRUE if symbol has non-GOT/non-PLT relocations in text sections. */
797 unsigned int has_non_got_reloc
: 1;
799 /* 0: symbol isn't __tls_get_addr.
800 1: symbol is __tls_get_addr.
801 2: symbol is unknown. */
802 unsigned int tls_get_addr
: 2;
804 /* Reference count of C/C++ function pointer relocations in read-write
805 section which can be resolved at run-time. */
806 bfd_signed_vma func_pointer_refcount
;
808 /* Information about the GOT PLT entry. Filled when there are both
809 GOT and PLT relocations against the same function. */
810 union gotplt_union plt_got
;
812 /* Information about the second PLT entry. Filled when has_bnd_reloc is
814 union gotplt_union plt_bnd
;
816 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
817 starting at the end of the jump table. */
821 #define elf_x86_64_hash_entry(ent) \
822 ((struct elf_x86_64_link_hash_entry *)(ent))
824 struct elf_x86_64_obj_tdata
826 struct elf_obj_tdata root
;
828 /* tls_type for each local got entry. */
829 char *local_got_tls_type
;
831 /* GOTPLT entries for TLS descriptors. */
832 bfd_vma
*local_tlsdesc_gotent
;
835 #define elf_x86_64_tdata(abfd) \
836 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
838 #define elf_x86_64_local_got_tls_type(abfd) \
839 (elf_x86_64_tdata (abfd)->local_got_tls_type)
841 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
842 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
844 #define is_x86_64_elf(bfd) \
845 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
846 && elf_tdata (bfd) != NULL \
847 && elf_object_id (bfd) == X86_64_ELF_DATA)
850 elf_x86_64_mkobject (bfd
*abfd
)
852 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_x86_64_obj_tdata
),
856 /* x86-64 ELF linker hash table. */
858 struct elf_x86_64_link_hash_table
860 struct elf_link_hash_table elf
;
862 /* Short-cuts to get to dynamic linker sections. */
866 asection
*plt_eh_frame
;
872 bfd_signed_vma refcount
;
876 /* The amount of space used by the jump slots in the GOT. */
877 bfd_vma sgotplt_jump_table_size
;
879 /* Small local sym cache. */
880 struct sym_cache sym_cache
;
882 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
883 bfd_vma (*r_sym
) (bfd_vma
);
884 unsigned int pointer_r_type
;
885 const char *dynamic_interpreter
;
886 int dynamic_interpreter_size
;
888 /* _TLS_MODULE_BASE_ symbol. */
889 struct bfd_link_hash_entry
*tls_module_base
;
891 /* Used by local STT_GNU_IFUNC symbols. */
892 htab_t loc_hash_table
;
893 void * loc_hash_memory
;
895 /* The offset into splt of the PLT entry for the TLS descriptor
896 resolver. Special values are 0, if not necessary (or not found
897 to be necessary yet), and -1 if needed but not determined
900 /* The offset into sgot of the GOT entry used by the PLT entry
904 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
905 bfd_vma next_jump_slot_index
;
906 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
907 bfd_vma next_irelative_index
;
909 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
910 to read-only sections. */
911 bfd_boolean readonly_dynrelocs_against_ifunc
;
914 /* Get the x86-64 ELF linker hash table from a link_info structure. */
916 #define elf_x86_64_hash_table(p) \
917 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
918 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
920 #define elf_x86_64_compute_jump_table_size(htab) \
921 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
923 /* Create an entry in an x86-64 ELF linker hash table. */
925 static struct bfd_hash_entry
*
926 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
927 struct bfd_hash_table
*table
,
930 /* Allocate the structure if it has not already been allocated by a
934 entry
= (struct bfd_hash_entry
*)
935 bfd_hash_allocate (table
,
936 sizeof (struct elf_x86_64_link_hash_entry
));
941 /* Call the allocation method of the superclass. */
942 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
945 struct elf_x86_64_link_hash_entry
*eh
;
947 eh
= (struct elf_x86_64_link_hash_entry
*) entry
;
948 eh
->dyn_relocs
= NULL
;
949 eh
->tls_type
= GOT_UNKNOWN
;
951 eh
->has_bnd_reloc
= 0;
952 eh
->has_got_reloc
= 0;
953 eh
->has_non_got_reloc
= 0;
954 eh
->tls_get_addr
= 2;
955 eh
->func_pointer_refcount
= 0;
956 eh
->plt_bnd
.offset
= (bfd_vma
) -1;
957 eh
->plt_got
.offset
= (bfd_vma
) -1;
958 eh
->tlsdesc_got
= (bfd_vma
) -1;
964 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
965 for local symbol so that we can handle local STT_GNU_IFUNC symbols
966 as global symbol. We reuse indx and dynstr_index for local symbol
967 hash since they aren't used by global symbols in this backend. */
970 elf_x86_64_local_htab_hash (const void *ptr
)
972 struct elf_link_hash_entry
*h
973 = (struct elf_link_hash_entry
*) ptr
;
974 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
977 /* Compare local hash entries. */
980 elf_x86_64_local_htab_eq (const void *ptr1
, const void *ptr2
)
982 struct elf_link_hash_entry
*h1
983 = (struct elf_link_hash_entry
*) ptr1
;
984 struct elf_link_hash_entry
*h2
985 = (struct elf_link_hash_entry
*) ptr2
;
987 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
990 /* Find and/or create a hash entry for local symbol. */
992 static struct elf_link_hash_entry
*
993 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table
*htab
,
994 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
997 struct elf_x86_64_link_hash_entry e
, *ret
;
998 asection
*sec
= abfd
->sections
;
999 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
1000 htab
->r_sym (rel
->r_info
));
1003 e
.elf
.indx
= sec
->id
;
1004 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
1005 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
1006 create
? INSERT
: NO_INSERT
);
1013 ret
= (struct elf_x86_64_link_hash_entry
*) *slot
;
1017 ret
= (struct elf_x86_64_link_hash_entry
*)
1018 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
1019 sizeof (struct elf_x86_64_link_hash_entry
));
1022 memset (ret
, 0, sizeof (*ret
));
1023 ret
->elf
.indx
= sec
->id
;
1024 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
1025 ret
->elf
.dynindx
= -1;
1026 ret
->func_pointer_refcount
= 0;
1027 ret
->plt_got
.offset
= (bfd_vma
) -1;
1033 /* Destroy an X86-64 ELF linker hash table. */
1036 elf_x86_64_link_hash_table_free (bfd
*obfd
)
1038 struct elf_x86_64_link_hash_table
*htab
1039 = (struct elf_x86_64_link_hash_table
*) obfd
->link
.hash
;
1041 if (htab
->loc_hash_table
)
1042 htab_delete (htab
->loc_hash_table
);
1043 if (htab
->loc_hash_memory
)
1044 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
1045 _bfd_elf_link_hash_table_free (obfd
);
1048 /* Create an X86-64 ELF linker hash table. */
1050 static struct bfd_link_hash_table
*
1051 elf_x86_64_link_hash_table_create (bfd
*abfd
)
1053 struct elf_x86_64_link_hash_table
*ret
;
1054 bfd_size_type amt
= sizeof (struct elf_x86_64_link_hash_table
);
1056 ret
= (struct elf_x86_64_link_hash_table
*) bfd_zmalloc (amt
);
1060 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1061 elf_x86_64_link_hash_newfunc
,
1062 sizeof (struct elf_x86_64_link_hash_entry
),
1069 if (ABI_64_P (abfd
))
1071 ret
->r_info
= elf64_r_info
;
1072 ret
->r_sym
= elf64_r_sym
;
1073 ret
->pointer_r_type
= R_X86_64_64
;
1074 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
1075 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
1079 ret
->r_info
= elf32_r_info
;
1080 ret
->r_sym
= elf32_r_sym
;
1081 ret
->pointer_r_type
= R_X86_64_32
;
1082 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
1083 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
1086 ret
->loc_hash_table
= htab_try_create (1024,
1087 elf_x86_64_local_htab_hash
,
1088 elf_x86_64_local_htab_eq
,
1090 ret
->loc_hash_memory
= objalloc_create ();
1091 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1093 elf_x86_64_link_hash_table_free (abfd
);
1096 ret
->elf
.root
.hash_table_free
= elf_x86_64_link_hash_table_free
;
1098 return &ret
->elf
.root
;
1101 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1102 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1106 elf_x86_64_create_dynamic_sections (bfd
*dynobj
,
1107 struct bfd_link_info
*info
)
1109 struct elf_x86_64_link_hash_table
*htab
;
1111 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1114 htab
= elf_x86_64_hash_table (info
);
1118 /* Set the contents of the .interp section to the interpreter. */
1119 if (bfd_link_executable (info
) && !info
->nointerp
)
1121 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
1124 s
->size
= htab
->dynamic_interpreter_size
;
1125 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
1129 htab
->sdynbss
= bfd_get_linker_section (dynobj
, ".dynbss");
1133 if (bfd_link_executable (info
))
1135 /* Always allow copy relocs for building executables. */
1136 asection
*s
= bfd_get_linker_section (dynobj
, ".rela.bss");
1139 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
1140 s
= bfd_make_section_anyway_with_flags (dynobj
,
1142 (bed
->dynamic_sec_flags
1145 || ! bfd_set_section_alignment (dynobj
, s
,
1146 bed
->s
->log_file_align
))
1152 if (!info
->no_ld_generated_unwind_info
1153 && htab
->plt_eh_frame
== NULL
1154 && htab
->elf
.splt
!= NULL
)
1156 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1157 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1158 | SEC_LINKER_CREATED
);
1160 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
1161 if (htab
->plt_eh_frame
== NULL
1162 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 3))
1168 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1171 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
1172 struct elf_link_hash_entry
*dir
,
1173 struct elf_link_hash_entry
*ind
)
1175 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
1177 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
1178 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
1180 if (!edir
->has_bnd_reloc
)
1181 edir
->has_bnd_reloc
= eind
->has_bnd_reloc
;
1183 if (!edir
->has_got_reloc
)
1184 edir
->has_got_reloc
= eind
->has_got_reloc
;
1186 if (!edir
->has_non_got_reloc
)
1187 edir
->has_non_got_reloc
= eind
->has_non_got_reloc
;
1189 if (eind
->dyn_relocs
!= NULL
)
1191 if (edir
->dyn_relocs
!= NULL
)
1193 struct elf_dyn_relocs
**pp
;
1194 struct elf_dyn_relocs
*p
;
1196 /* Add reloc counts against the indirect sym to the direct sym
1197 list. Merge any entries against the same section. */
1198 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1200 struct elf_dyn_relocs
*q
;
1202 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1203 if (q
->sec
== p
->sec
)
1205 q
->pc_count
+= p
->pc_count
;
1206 q
->count
+= p
->count
;
1213 *pp
= edir
->dyn_relocs
;
1216 edir
->dyn_relocs
= eind
->dyn_relocs
;
1217 eind
->dyn_relocs
= NULL
;
1220 if (ind
->root
.type
== bfd_link_hash_indirect
1221 && dir
->got
.refcount
<= 0)
1223 edir
->tls_type
= eind
->tls_type
;
1224 eind
->tls_type
= GOT_UNKNOWN
;
1227 if (ELIMINATE_COPY_RELOCS
1228 && ind
->root
.type
!= bfd_link_hash_indirect
1229 && dir
->dynamic_adjusted
)
1231 /* If called to transfer flags for a weakdef during processing
1232 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1233 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1234 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1235 dir
->ref_regular
|= ind
->ref_regular
;
1236 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1237 dir
->needs_plt
|= ind
->needs_plt
;
1238 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1242 if (eind
->func_pointer_refcount
> 0)
1244 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1245 eind
->func_pointer_refcount
= 0;
1248 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1253 elf64_x86_64_elf_object_p (bfd
*abfd
)
1255 /* Set the right machine number for an x86-64 elf64 file. */
1256 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
1261 elf32_x86_64_elf_object_p (bfd
*abfd
)
1263 /* Set the right machine number for an x86-64 elf32 file. */
1264 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
1268 /* Return TRUE if the TLS access code sequence support transition
1272 elf_x86_64_check_tls_transition (bfd
*abfd
,
1273 struct bfd_link_info
*info
,
1276 Elf_Internal_Shdr
*symtab_hdr
,
1277 struct elf_link_hash_entry
**sym_hashes
,
1278 unsigned int r_type
,
1279 const Elf_Internal_Rela
*rel
,
1280 const Elf_Internal_Rela
*relend
)
1283 unsigned long r_symndx
;
1284 bfd_boolean largepic
= FALSE
;
1285 struct elf_link_hash_entry
*h
;
1287 struct elf_x86_64_link_hash_table
*htab
;
1289 bfd_boolean indirect_call
, tls_get_addr
;
1291 htab
= elf_x86_64_hash_table (info
);
1292 offset
= rel
->r_offset
;
1295 case R_X86_64_TLSGD
:
1296 case R_X86_64_TLSLD
:
1297 if ((rel
+ 1) >= relend
)
1300 if (r_type
== R_X86_64_TLSGD
)
1302 /* Check transition from GD access model. For 64bit, only
1303 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1304 .word 0x6666; rex64; call __tls_get_addr@PLT
1306 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1308 call *__tls_get_addr@GOTPCREL(%rip)
1309 which may be converted to
1310 addr32 call __tls_get_addr
1311 can transit to different access model. For 32bit, only
1312 leaq foo@tlsgd(%rip), %rdi
1313 .word 0x6666; rex64; call __tls_get_addr@PLT
1315 leaq foo@tlsgd(%rip), %rdi
1317 call *__tls_get_addr@GOTPCREL(%rip)
1318 which may be converted to
1319 addr32 call __tls_get_addr
1320 can transit to different access model. For largepic,
1322 leaq foo@tlsgd(%rip), %rdi
1323 movabsq $__tls_get_addr@pltoff, %rax
1327 leaq foo@tlsgd(%rip), %rdi
1328 movabsq $__tls_get_addr@pltoff, %rax
1332 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1334 if ((offset
+ 12) > sec
->size
)
1337 call
= contents
+ offset
+ 4;
1339 || !((call
[1] == 0x48
1347 && call
[3] == 0xe8)))
1349 if (!ABI_64_P (abfd
)
1350 || (offset
+ 19) > sec
->size
1352 || memcmp (call
- 7, leaq
+ 1, 3) != 0
1353 || memcmp (call
, "\x48\xb8", 2) != 0
1357 || !((call
[10] == 0x48 && call
[12] == 0xd8)
1358 || (call
[10] == 0x4c && call
[12] == 0xf8)))
1362 else if (ABI_64_P (abfd
))
1365 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1371 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1374 indirect_call
= call
[2] == 0xff;
1378 /* Check transition from LD access model. Only
1379 leaq foo@tlsld(%rip), %rdi;
1380 call __tls_get_addr@PLT
1382 leaq foo@tlsld(%rip), %rdi;
1383 call *__tls_get_addr@GOTPCREL(%rip)
1384 which may be converted to
1385 addr32 call __tls_get_addr
1386 can transit to different access model. For largepic
1388 leaq foo@tlsld(%rip), %rdi
1389 movabsq $__tls_get_addr@pltoff, %rax
1393 leaq foo@tlsld(%rip), %rdi
1394 movabsq $__tls_get_addr@pltoff, %rax
1398 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1400 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1403 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0)
1406 call
= contents
+ offset
+ 4;
1407 if (!(call
[0] == 0xe8
1408 || (call
[0] == 0xff && call
[1] == 0x15)
1409 || (call
[0] == 0x67 && call
[1] == 0xe8)))
1411 if (!ABI_64_P (abfd
)
1412 || (offset
+ 19) > sec
->size
1413 || memcmp (call
, "\x48\xb8", 2) != 0
1417 || !((call
[10] == 0x48 && call
[12] == 0xd8)
1418 || (call
[10] == 0x4c && call
[12] == 0xf8)))
1422 indirect_call
= call
[0] == 0xff;
1425 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1426 if (r_symndx
< symtab_hdr
->sh_info
)
1429 tls_get_addr
= FALSE
;
1430 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1431 if (h
!= NULL
&& h
->root
.root
.string
!= NULL
)
1433 struct elf_x86_64_link_hash_entry
*eh
1434 = (struct elf_x86_64_link_hash_entry
*) h
;
1435 tls_get_addr
= eh
->tls_get_addr
== 1;
1436 if (eh
->tls_get_addr
> 1)
1438 /* Use strncmp to check __tls_get_addr since
1439 __tls_get_addr may be versioned. */
1440 if (strncmp (h
->root
.root
.string
, "__tls_get_addr", 14)
1443 eh
->tls_get_addr
= 1;
1444 tls_get_addr
= TRUE
;
1447 eh
->tls_get_addr
= 0;
1454 return ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLTOFF64
;
1455 else if (indirect_call
)
1456 return ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_GOTPCRELX
;
1458 return (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1459 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
);
1461 case R_X86_64_GOTTPOFF
:
1462 /* Check transition from IE access model:
1463 mov foo@gottpoff(%rip), %reg
1464 add foo@gottpoff(%rip), %reg
1467 /* Check REX prefix first. */
1468 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1470 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1471 if (val
!= 0x48 && val
!= 0x4c)
1473 /* X32 may have 0x44 REX prefix or no REX prefix. */
1474 if (ABI_64_P (abfd
))
1480 /* X32 may not have any REX prefix. */
1481 if (ABI_64_P (abfd
))
1483 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1487 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1488 if (val
!= 0x8b && val
!= 0x03)
1491 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1492 return (val
& 0xc7) == 5;
1494 case R_X86_64_GOTPC32_TLSDESC
:
1495 /* Check transition from GDesc access model:
1496 leaq x@tlsdesc(%rip), %rax
1498 Make sure it's a leaq adding rip to a 32-bit offset
1499 into any register, although it's probably almost always
1502 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1505 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1506 if ((val
& 0xfb) != 0x48)
1509 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1512 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1513 return (val
& 0xc7) == 0x05;
1515 case R_X86_64_TLSDESC_CALL
:
1516 /* Check transition from GDesc access model:
1517 call *x@tlsdesc(%rax)
1519 if (offset
+ 2 <= sec
->size
)
1521 /* Make sure that it's a call *x@tlsdesc(%rax). */
1522 call
= contents
+ offset
;
1523 return call
[0] == 0xff && call
[1] == 0x10;
1533 /* Return TRUE if the TLS access transition is OK or no transition
1534 will be performed. Update R_TYPE if there is a transition. */
1537 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1538 asection
*sec
, bfd_byte
*contents
,
1539 Elf_Internal_Shdr
*symtab_hdr
,
1540 struct elf_link_hash_entry
**sym_hashes
,
1541 unsigned int *r_type
, int tls_type
,
1542 const Elf_Internal_Rela
*rel
,
1543 const Elf_Internal_Rela
*relend
,
1544 struct elf_link_hash_entry
*h
,
1545 unsigned long r_symndx
,
1546 bfd_boolean from_relocate_section
)
1548 unsigned int from_type
= *r_type
;
1549 unsigned int to_type
= from_type
;
1550 bfd_boolean check
= TRUE
;
1552 /* Skip TLS transition for functions. */
1554 && (h
->type
== STT_FUNC
1555 || h
->type
== STT_GNU_IFUNC
))
1560 case R_X86_64_TLSGD
:
1561 case R_X86_64_GOTPC32_TLSDESC
:
1562 case R_X86_64_TLSDESC_CALL
:
1563 case R_X86_64_GOTTPOFF
:
1564 if (bfd_link_executable (info
))
1567 to_type
= R_X86_64_TPOFF32
;
1569 to_type
= R_X86_64_GOTTPOFF
;
1572 /* When we are called from elf_x86_64_relocate_section, there may
1573 be additional transitions based on TLS_TYPE. */
1574 if (from_relocate_section
)
1576 unsigned int new_to_type
= to_type
;
1578 if (bfd_link_executable (info
)
1581 && tls_type
== GOT_TLS_IE
)
1582 new_to_type
= R_X86_64_TPOFF32
;
1584 if (to_type
== R_X86_64_TLSGD
1585 || to_type
== R_X86_64_GOTPC32_TLSDESC
1586 || to_type
== R_X86_64_TLSDESC_CALL
)
1588 if (tls_type
== GOT_TLS_IE
)
1589 new_to_type
= R_X86_64_GOTTPOFF
;
1592 /* We checked the transition before when we were called from
1593 elf_x86_64_check_relocs. We only want to check the new
1594 transition which hasn't been checked before. */
1595 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1596 to_type
= new_to_type
;
1601 case R_X86_64_TLSLD
:
1602 if (bfd_link_executable (info
))
1603 to_type
= R_X86_64_TPOFF32
;
1610 /* Return TRUE if there is no transition. */
1611 if (from_type
== to_type
)
1614 /* Check if the transition can be performed. */
1616 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1617 symtab_hdr
, sym_hashes
,
1618 from_type
, rel
, relend
))
1620 reloc_howto_type
*from
, *to
;
1623 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1624 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1627 name
= h
->root
.root
.string
;
1630 struct elf_x86_64_link_hash_table
*htab
;
1632 htab
= elf_x86_64_hash_table (info
);
1637 Elf_Internal_Sym
*isym
;
1639 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1641 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1645 (*_bfd_error_handler
)
1646 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1647 "in section `%A' failed"),
1648 abfd
, sec
, from
->name
, to
->name
, name
,
1649 (unsigned long) rel
->r_offset
);
1650 bfd_set_error (bfd_error_bad_value
);
1658 /* Rename some of the generic section flags to better document how they
1660 #define need_convert_load sec_flg0
1661 #define check_relocs_failed sec_flg1
1664 elf_x86_64_need_pic (bfd
*input_bfd
, asection
*sec
,
1665 struct elf_link_hash_entry
*h
,
1666 Elf_Internal_Shdr
*symtab_hdr
,
1667 Elf_Internal_Sym
*isym
,
1668 reloc_howto_type
*howto
)
1671 const char *und
= "";
1672 const char *pic
= "";
1677 name
= h
->root
.root
.string
;
1678 switch (ELF_ST_VISIBILITY (h
->other
))
1681 v
= _("hidden symbol ");
1684 v
= _("internal symbol ");
1687 v
= _("protected symbol ");
1691 pic
= _("; recompile with -fPIC");
1695 if (!h
->def_regular
&& !h
->def_dynamic
)
1696 und
= _("undefined ");
1700 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, isym
, NULL
);
1701 pic
= _("; recompile with -fPIC");
1704 (*_bfd_error_handler
) (_("%B: relocation %s against %s%s`%s' can "
1705 "not be used when making a shared object%s"),
1706 input_bfd
, howto
->name
, und
, v
, name
, pic
);
1707 bfd_set_error (bfd_error_bad_value
);
1708 sec
->check_relocs_failed
= 1;
1712 /* With the local symbol, foo, we convert
1713 mov foo@GOTPCREL(%rip), %reg
1717 call/jmp *foo@GOTPCREL(%rip)
1719 nop call foo/jmp foo nop
1720 When PIC is false, convert
1721 test %reg, foo@GOTPCREL(%rip)
1725 binop foo@GOTPCREL(%rip), %reg
1728 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1732 elf_x86_64_convert_load_reloc (bfd
*abfd
, asection
*sec
,
1734 Elf_Internal_Rela
*irel
,
1735 struct elf_link_hash_entry
*h
,
1736 bfd_boolean
*converted
,
1737 struct bfd_link_info
*link_info
)
1739 struct elf_x86_64_link_hash_table
*htab
;
1741 bfd_boolean require_reloc_pc32
;
1743 bfd_boolean to_reloc_pc32
;
1746 bfd_signed_vma raddend
;
1747 unsigned int opcode
;
1749 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
1750 unsigned int r_symndx
;
1752 bfd_vma roff
= irel
->r_offset
;
1754 if (roff
< (r_type
== R_X86_64_REX_GOTPCRELX
? 3 : 2))
1757 raddend
= irel
->r_addend
;
1758 /* Addend for 32-bit PC-relative relocation must be -4. */
1762 htab
= elf_x86_64_hash_table (link_info
);
1763 is_pic
= bfd_link_pic (link_info
);
1765 relocx
= (r_type
== R_X86_64_GOTPCRELX
1766 || r_type
== R_X86_64_REX_GOTPCRELX
);
1768 /* TRUE if we can convert only to R_X86_64_PC32. Enable it for
1771 = link_info
->disable_target_specific_optimizations
> 1;
1773 r_symndx
= htab
->r_sym (irel
->r_info
);
1775 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
1777 /* Convert mov to lea since it has been done for a while. */
1780 /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
1781 for call, jmp or one of adc, add, and, cmp, or, sbb, sub,
1782 test, xor instructions. */
1787 /* We convert only to R_X86_64_PC32:
1789 2. R_X86_64_GOTPCREL since we can't modify REX byte.
1790 3. require_reloc_pc32 is true.
1793 to_reloc_pc32
= (opcode
== 0xff
1795 || require_reloc_pc32
1798 /* Get the symbol referred to by the reloc. */
1801 Elf_Internal_Sym
*isym
1802 = bfd_sym_from_r_symndx (&htab
->sym_cache
, abfd
, r_symndx
);
1804 /* Skip relocation against undefined symbols. */
1805 if (isym
->st_shndx
== SHN_UNDEF
)
1808 symtype
= ELF_ST_TYPE (isym
->st_info
);
1810 if (isym
->st_shndx
== SHN_ABS
)
1811 tsec
= bfd_abs_section_ptr
;
1812 else if (isym
->st_shndx
== SHN_COMMON
)
1813 tsec
= bfd_com_section_ptr
;
1814 else if (isym
->st_shndx
== SHN_X86_64_LCOMMON
)
1815 tsec
= &_bfd_elf_large_com_section
;
1817 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1819 toff
= isym
->st_value
;
1823 /* Undefined weak symbol is only bound locally in executable
1824 and its reference is resolved as 0 without relocation
1825 overflow. We can only perform this optimization for
1826 GOTPCRELX relocations since we need to modify REX byte.
1827 It is OK convert mov with R_X86_64_GOTPCREL to
1829 if ((relocx
|| opcode
== 0x8b)
1830 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
,
1832 elf_x86_64_hash_entry (h
)))
1836 /* Skip for branch instructions since R_X86_64_PC32
1838 if (require_reloc_pc32
)
1843 /* For non-branch instructions, we can convert to
1844 R_X86_64_32/R_X86_64_32S since we know if there
1846 to_reloc_pc32
= FALSE
;
1849 /* Since we don't know the current PC when PIC is true,
1850 we can't convert to R_X86_64_PC32. */
1851 if (to_reloc_pc32
&& is_pic
)
1856 /* Avoid optimizing GOTPCREL relocations againt _DYNAMIC since
1857 ld.so may use its link-time address. */
1858 else if ((h
->def_regular
1859 || h
->root
.type
== bfd_link_hash_defined
1860 || h
->root
.type
== bfd_link_hash_defweak
)
1861 && h
!= htab
->elf
.hdynamic
1862 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
1864 /* bfd_link_hash_new or bfd_link_hash_undefined is
1865 set by an assignment in a linker script in
1866 bfd_elf_record_link_assignment. */
1868 && (h
->root
.type
== bfd_link_hash_new
1869 || h
->root
.type
== bfd_link_hash_undefined
))
1871 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */
1872 if (require_reloc_pc32
)
1876 tsec
= h
->root
.u
.def
.section
;
1877 toff
= h
->root
.u
.def
.value
;
1884 /* Don't convert GOTPCREL relocation against large section. */
1885 if (elf_section_data (tsec
) != NULL
1886 && (elf_section_flags (tsec
) & SHF_X86_64_LARGE
) != 0)
1889 /* We can only estimate relocation overflow for R_X86_64_PC32. */
1893 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
1895 /* At this stage in linking, no SEC_MERGE symbol has been
1896 adjusted, so all references to such symbols need to be
1897 passed through _bfd_merged_section_offset. (Later, in
1898 relocate_section, all SEC_MERGE symbols *except* for
1899 section symbols have been adjusted.)
1901 gas may reduce relocations against symbols in SEC_MERGE
1902 sections to a relocation against the section symbol when
1903 the original addend was zero. When the reloc is against
1904 a section symbol we should include the addend in the
1905 offset passed to _bfd_merged_section_offset, since the
1906 location of interest is the original symbol. On the
1907 other hand, an access to "sym+addend" where "sym" is not
1908 a section symbol should not include the addend; Such an
1909 access is presumed to be an offset from "sym"; The
1910 location of interest is just "sym". */
1911 if (symtype
== STT_SECTION
)
1914 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
1915 elf_section_data (tsec
)->sec_info
,
1918 if (symtype
!= STT_SECTION
)
1924 /* Don't convert if R_X86_64_PC32 relocation overflows. */
1925 if (tsec
->output_section
== sec
->output_section
)
1927 if ((toff
- roff
+ 0x80000000) > 0xffffffff)
1932 bfd_signed_vma distance
;
1934 /* At this point, we don't know the load addresses of TSEC
1935 section nor SEC section. We estimate the distrance between
1936 SEC and TSEC. We store the estimated distances in the
1937 compressed_size field of the output section, which is only
1938 used to decompress the compressed input section. */
1939 if (sec
->output_section
->compressed_size
== 0)
1942 bfd_size_type size
= 0;
1943 for (asect
= link_info
->output_bfd
->sections
;
1945 asect
= asect
->next
)
1946 /* Skip debug sections since compressed_size is used to
1947 compress debug sections. */
1948 if ((asect
->flags
& SEC_DEBUGGING
) == 0)
1951 for (i
= asect
->map_head
.s
;
1955 size
= align_power (size
, i
->alignment_power
);
1958 asect
->compressed_size
= size
;
1962 /* Don't convert GOTPCREL relocations if TSEC isn't placed
1964 distance
= (tsec
->output_section
->compressed_size
1965 - sec
->output_section
->compressed_size
);
1969 /* Take PT_GNU_RELRO segment into account by adding
1971 if ((toff
+ distance
+ get_elf_backend_data (abfd
)->maxpagesize
1972 - roff
+ 0x80000000) > 0xffffffff)
1979 /* We have "call/jmp *foo@GOTPCREL(%rip)". */
1984 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
1986 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
1989 /* Convert to "jmp foo nop". */
1992 nop_offset
= irel
->r_offset
+ 3;
1993 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
1994 irel
->r_offset
-= 1;
1995 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
1999 struct elf_x86_64_link_hash_entry
*eh
2000 = (struct elf_x86_64_link_hash_entry
*) h
;
2002 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
2005 /* To support TLS optimization, always use addr32 prefix for
2006 "call *__tls_get_addr@GOTPCREL(%rip)". */
2007 if (eh
&& eh
->tls_get_addr
== 1)
2010 nop_offset
= irel
->r_offset
- 2;
2014 nop
= link_info
->call_nop_byte
;
2015 if (link_info
->call_nop_as_suffix
)
2017 nop_offset
= irel
->r_offset
+ 3;
2018 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
2019 irel
->r_offset
-= 1;
2020 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
2023 nop_offset
= irel
->r_offset
- 2;
2026 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
2027 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
2028 r_type
= R_X86_64_PC32
;
2033 unsigned int rex_mask
= REX_R
;
2035 if (r_type
== R_X86_64_REX_GOTPCRELX
)
2036 rex
= bfd_get_8 (abfd
, contents
+ roff
- 3);
2044 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
2045 "lea foo(%rip), %reg". */
2047 r_type
= R_X86_64_PC32
;
2051 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
2052 "mov $foo, %reg". */
2054 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2055 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
2056 if ((rex
& REX_W
) != 0
2057 && ABI_64_P (link_info
->output_bfd
))
2059 /* Keep the REX_W bit in REX byte for LP64. */
2060 r_type
= R_X86_64_32S
;
2061 goto rewrite_modrm_rex
;
2065 /* If the REX_W bit in REX byte isn't needed,
2066 use R_X86_64_32 and clear the W bit to avoid
2067 sign-extend imm32 to imm64. */
2068 r_type
= R_X86_64_32
;
2069 /* Clear the W bit in REX byte. */
2071 goto rewrite_modrm_rex
;
2077 /* R_X86_64_PC32 isn't supported. */
2081 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2084 /* Convert "test %reg, foo@GOTPCREL(%rip)" to
2085 "test $foo, %reg". */
2086 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
2091 /* Convert "binop foo@GOTPCREL(%rip), %reg" to
2092 "binop $foo, %reg". */
2093 modrm
= 0xc0 | (modrm
& 0x38) >> 3 | (opcode
& 0x3c);
2097 /* Use R_X86_64_32 with 32-bit operand to avoid relocation
2098 overflow when sign-extending imm32 to imm64. */
2099 r_type
= (rex
& REX_W
) != 0 ? R_X86_64_32S
: R_X86_64_32
;
2102 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
2106 /* Move the R bit to the B bit in REX byte. */
2107 rex
= (rex
& ~rex_mask
) | (rex
& REX_R
) >> 2;
2108 bfd_put_8 (abfd
, rex
, contents
+ roff
- 3);
2111 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */
2115 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
2118 irel
->r_info
= htab
->r_info (r_symndx
, r_type
);
2125 /* Look through the relocs for a section during the first phase, and
2126 calculate needed space in the global offset table, procedure
2127 linkage table, and dynamic reloc sections. */
2130 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
2132 const Elf_Internal_Rela
*relocs
)
2134 struct elf_x86_64_link_hash_table
*htab
;
2135 Elf_Internal_Shdr
*symtab_hdr
;
2136 struct elf_link_hash_entry
**sym_hashes
;
2137 const Elf_Internal_Rela
*rel
;
2138 const Elf_Internal_Rela
*rel_end
;
2141 bfd_boolean use_plt_got
;
2143 if (bfd_link_relocatable (info
))
2146 /* Don't do anything special with non-loaded, non-alloced sections.
2147 In particular, any relocs in such sections should not affect GOT
2148 and PLT reference counting (ie. we don't allow them to create GOT
2149 or PLT entries), there's no possibility or desire to optimize TLS
2150 relocs, and there's not much point in propagating relocs to shared
2151 libs that the dynamic linker won't relocate. */
2152 if ((sec
->flags
& SEC_ALLOC
) == 0)
2155 BFD_ASSERT (is_x86_64_elf (abfd
));
2157 htab
= elf_x86_64_hash_table (info
);
2160 sec
->check_relocs_failed
= 1;
2164 /* Get the section contents. */
2165 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2166 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2167 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2169 sec
->check_relocs_failed
= 1;
2173 use_plt_got
= get_elf_x86_64_backend_data (abfd
) == &elf_x86_64_arch_bed
;
2175 symtab_hdr
= &elf_symtab_hdr (abfd
);
2176 sym_hashes
= elf_sym_hashes (abfd
);
2180 rel_end
= relocs
+ sec
->reloc_count
;
2181 for (rel
= relocs
; rel
< rel_end
; rel
++)
2183 unsigned int r_type
;
2184 unsigned long r_symndx
;
2185 struct elf_link_hash_entry
*h
;
2186 struct elf_x86_64_link_hash_entry
*eh
;
2187 Elf_Internal_Sym
*isym
;
2189 bfd_boolean size_reloc
;
2191 r_symndx
= htab
->r_sym (rel
->r_info
);
2192 r_type
= ELF32_R_TYPE (rel
->r_info
);
2194 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
2196 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
2201 if (r_symndx
< symtab_hdr
->sh_info
)
2203 /* A local symbol. */
2204 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2209 /* Check relocation against local STT_GNU_IFUNC symbol. */
2210 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
2212 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
2217 /* Fake a STT_GNU_IFUNC symbol. */
2218 h
->type
= STT_GNU_IFUNC
;
2221 h
->forced_local
= 1;
2222 h
->root
.type
= bfd_link_hash_defined
;
2230 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2231 while (h
->root
.type
== bfd_link_hash_indirect
2232 || h
->root
.type
== bfd_link_hash_warning
)
2233 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2236 /* Check invalid x32 relocations. */
2237 if (!ABI_64_P (abfd
))
2243 case R_X86_64_DTPOFF64
:
2244 case R_X86_64_TPOFF64
:
2246 case R_X86_64_GOTOFF64
:
2247 case R_X86_64_GOT64
:
2248 case R_X86_64_GOTPCREL64
:
2249 case R_X86_64_GOTPC64
:
2250 case R_X86_64_GOTPLT64
:
2251 case R_X86_64_PLTOFF64
:
2254 name
= h
->root
.root
.string
;
2256 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
2258 (*_bfd_error_handler
)
2259 (_("%B: relocation %s against symbol `%s' isn't "
2260 "supported in x32 mode"), abfd
,
2261 x86_64_elf_howto_table
[r_type
].name
, name
);
2262 bfd_set_error (bfd_error_bad_value
);
2275 case R_X86_64_PC32_BND
:
2276 case R_X86_64_PLT32_BND
:
2278 case R_X86_64_PLT32
:
2281 /* MPX PLT is supported only if elf_x86_64_arch_bed
2282 is used in 64-bit mode. */
2285 && (get_elf_x86_64_backend_data (abfd
)
2286 == &elf_x86_64_arch_bed
))
2288 elf_x86_64_hash_entry (h
)->has_bnd_reloc
= 1;
2290 /* Create the second PLT for Intel MPX support. */
2291 if (htab
->plt_bnd
== NULL
)
2293 unsigned int plt_bnd_align
;
2294 const struct elf_backend_data
*bed
;
2296 bed
= get_elf_backend_data (info
->output_bfd
);
2297 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry
) == 8
2298 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2299 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2302 if (htab
->elf
.dynobj
== NULL
)
2303 htab
->elf
.dynobj
= abfd
;
2305 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2307 (bed
->dynamic_sec_flags
2312 if (htab
->plt_bnd
== NULL
2313 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2322 case R_X86_64_GOTPCREL
:
2323 case R_X86_64_GOTPCRELX
:
2324 case R_X86_64_REX_GOTPCRELX
:
2325 case R_X86_64_GOTPCREL64
:
2326 if (htab
->elf
.dynobj
== NULL
)
2327 htab
->elf
.dynobj
= abfd
;
2328 /* Create the ifunc sections for static executables. */
2329 if (h
->type
== STT_GNU_IFUNC
2330 && !_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
,
2336 /* It is referenced by a non-shared object. */
2338 h
->root
.non_ir_ref
= 1;
2340 if (h
->type
== STT_GNU_IFUNC
)
2341 elf_tdata (info
->output_bfd
)->has_gnu_symbols
2342 |= elf_gnu_symbol_ifunc
;
2345 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, contents
,
2346 symtab_hdr
, sym_hashes
,
2347 &r_type
, GOT_UNKNOWN
,
2348 rel
, rel_end
, h
, r_symndx
, FALSE
))
2351 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2354 case R_X86_64_TLSLD
:
2355 htab
->tls_ld_got
.refcount
+= 1;
2358 case R_X86_64_TPOFF32
:
2359 if (!bfd_link_executable (info
) && ABI_64_P (abfd
))
2360 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
2361 &x86_64_elf_howto_table
[r_type
]);
2363 eh
->has_got_reloc
= 1;
2366 case R_X86_64_GOTTPOFF
:
2367 if (!bfd_link_executable (info
))
2368 info
->flags
|= DF_STATIC_TLS
;
2371 case R_X86_64_GOT32
:
2372 case R_X86_64_GOTPCREL
:
2373 case R_X86_64_GOTPCRELX
:
2374 case R_X86_64_REX_GOTPCRELX
:
2375 case R_X86_64_TLSGD
:
2376 case R_X86_64_GOT64
:
2377 case R_X86_64_GOTPCREL64
:
2378 case R_X86_64_GOTPLT64
:
2379 case R_X86_64_GOTPC32_TLSDESC
:
2380 case R_X86_64_TLSDESC_CALL
:
2381 /* This symbol requires a global offset table entry. */
2383 int tls_type
, old_tls_type
;
2387 default: tls_type
= GOT_NORMAL
; break;
2388 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
2389 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
2390 case R_X86_64_GOTPC32_TLSDESC
:
2391 case R_X86_64_TLSDESC_CALL
:
2392 tls_type
= GOT_TLS_GDESC
; break;
2397 h
->got
.refcount
+= 1;
2398 old_tls_type
= eh
->tls_type
;
2402 bfd_signed_vma
*local_got_refcounts
;
2404 /* This is a global offset table entry for a local symbol. */
2405 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2406 if (local_got_refcounts
== NULL
)
2410 size
= symtab_hdr
->sh_info
;
2411 size
*= sizeof (bfd_signed_vma
)
2412 + sizeof (bfd_vma
) + sizeof (char);
2413 local_got_refcounts
= ((bfd_signed_vma
*)
2414 bfd_zalloc (abfd
, size
));
2415 if (local_got_refcounts
== NULL
)
2417 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2418 elf_x86_64_local_tlsdesc_gotent (abfd
)
2419 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
2420 elf_x86_64_local_got_tls_type (abfd
)
2421 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
2423 local_got_refcounts
[r_symndx
] += 1;
2425 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
2428 /* If a TLS symbol is accessed using IE at least once,
2429 there is no point to use dynamic model for it. */
2430 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
2431 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
2432 || tls_type
!= GOT_TLS_IE
))
2434 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
2435 tls_type
= old_tls_type
;
2436 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
2437 && GOT_TLS_GD_ANY_P (tls_type
))
2438 tls_type
|= old_tls_type
;
2442 name
= h
->root
.root
.string
;
2444 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
2446 (*_bfd_error_handler
)
2447 (_("%B: '%s' accessed both as normal and thread local symbol"),
2449 bfd_set_error (bfd_error_bad_value
);
2454 if (old_tls_type
!= tls_type
)
2457 eh
->tls_type
= tls_type
;
2459 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
2464 case R_X86_64_GOTOFF64
:
2465 case R_X86_64_GOTPC32
:
2466 case R_X86_64_GOTPC64
:
2469 eh
->has_got_reloc
= 1;
2470 if (htab
->elf
.sgot
== NULL
)
2472 if (htab
->elf
.dynobj
== NULL
)
2473 htab
->elf
.dynobj
= abfd
;
2474 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
2480 case R_X86_64_PLT32
:
2481 case R_X86_64_PLT32_BND
:
2482 /* This symbol requires a procedure linkage table entry. We
2483 actually build the entry in adjust_dynamic_symbol,
2484 because this might be a case of linking PIC code which is
2485 never referenced by a dynamic object, in which case we
2486 don't need to generate a procedure linkage table entry
2489 /* If this is a local symbol, we resolve it directly without
2490 creating a procedure linkage table entry. */
2494 eh
->has_got_reloc
= 1;
2496 h
->plt
.refcount
+= 1;
2499 case R_X86_64_PLTOFF64
:
2500 /* This tries to form the 'address' of a function relative
2501 to GOT. For global symbols we need a PLT entry. */
2505 h
->plt
.refcount
+= 1;
2509 case R_X86_64_SIZE32
:
2510 case R_X86_64_SIZE64
:
2515 if (!ABI_64_P (abfd
))
2520 /* Check relocation overflow as these relocs may lead to
2521 run-time relocation overflow. Don't error out for
2522 sections we don't care about, such as debug sections or
2523 when relocation overflow check is disabled. */
2524 if (!info
->no_reloc_overflow_check
2525 && (bfd_link_pic (info
)
2526 || (bfd_link_executable (info
)
2530 && (sec
->flags
& SEC_READONLY
) == 0)))
2531 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
2532 &x86_64_elf_howto_table
[r_type
]);
2538 case R_X86_64_PC32_BND
:
2542 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2543 eh
->has_non_got_reloc
= 1;
2544 /* STT_GNU_IFUNC symbol must go through PLT even if it is
2545 locally defined and undefined symbol may turn out to be
2546 a STT_GNU_IFUNC symbol later. */
2548 && (bfd_link_executable (info
)
2549 || ((h
->type
== STT_GNU_IFUNC
2550 || h
->root
.type
== bfd_link_hash_undefweak
2551 || h
->root
.type
== bfd_link_hash_undefined
)
2552 && SYMBOLIC_BIND (info
, h
))))
2554 /* If this reloc is in a read-only section, we might
2555 need a copy reloc. We can't check reliably at this
2556 stage whether the section is read-only, as input
2557 sections have not yet been mapped to output sections.
2558 Tentatively set the flag for now, and correct in
2559 adjust_dynamic_symbol. */
2562 /* We may need a .plt entry if the function this reloc
2563 refers to is in a shared lib. */
2564 h
->plt
.refcount
+= 1;
2565 if (r_type
== R_X86_64_PC32
)
2567 /* Since something like ".long foo - ." may be used
2568 as pointer, make sure that PLT is used if foo is
2569 a function defined in a shared library. */
2570 if ((sec
->flags
& SEC_CODE
) == 0)
2571 h
->pointer_equality_needed
= 1;
2573 else if (r_type
!= R_X86_64_PC32_BND
2574 && r_type
!= R_X86_64_PC64
)
2576 h
->pointer_equality_needed
= 1;
2577 /* At run-time, R_X86_64_64 can be resolved for both
2578 x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2579 can only be resolved for x32. */
2580 if ((sec
->flags
& SEC_READONLY
) == 0
2581 && (r_type
== R_X86_64_64
2582 || (!ABI_64_P (abfd
)
2583 && (r_type
== R_X86_64_32
2584 || r_type
== R_X86_64_32S
))))
2585 eh
->func_pointer_refcount
+= 1;
2591 /* If we are creating a shared library, and this is a reloc
2592 against a global symbol, or a non PC relative reloc
2593 against a local symbol, then we need to copy the reloc
2594 into the shared library. However, if we are linking with
2595 -Bsymbolic, we do not need to copy a reloc against a
2596 global symbol which is defined in an object we are
2597 including in the link (i.e., DEF_REGULAR is set). At
2598 this point we have not seen all the input files, so it is
2599 possible that DEF_REGULAR is not set now but will be set
2600 later (it is never cleared). In case of a weak definition,
2601 DEF_REGULAR may be cleared later by a strong definition in
2602 a shared library. We account for that possibility below by
2603 storing information in the relocs_copied field of the hash
2604 table entry. A similar situation occurs when creating
2605 shared libraries and symbol visibility changes render the
2608 If on the other hand, we are creating an executable, we
2609 may need to keep relocations for symbols satisfied by a
2610 dynamic library if we manage to avoid copy relocs for the
2612 if ((bfd_link_pic (info
)
2613 && (! IS_X86_64_PCREL_TYPE (r_type
)
2615 && (! (bfd_link_pie (info
)
2616 || SYMBOLIC_BIND (info
, h
))
2617 || h
->root
.type
== bfd_link_hash_defweak
2618 || !h
->def_regular
))))
2619 || (ELIMINATE_COPY_RELOCS
2620 && !bfd_link_pic (info
)
2622 && (h
->root
.type
== bfd_link_hash_defweak
2623 || !h
->def_regular
)))
2625 struct elf_dyn_relocs
*p
;
2626 struct elf_dyn_relocs
**head
;
2628 /* We must copy these reloc types into the output file.
2629 Create a reloc section in dynobj and make room for
2633 if (htab
->elf
.dynobj
== NULL
)
2634 htab
->elf
.dynobj
= abfd
;
2636 sreloc
= _bfd_elf_make_dynamic_reloc_section
2637 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
2638 abfd
, /*rela?*/ TRUE
);
2644 /* If this is a global symbol, we count the number of
2645 relocations we need for this symbol. */
2647 head
= &eh
->dyn_relocs
;
2650 /* Track dynamic relocs needed for local syms too.
2651 We really need local syms available to do this
2656 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2661 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2665 /* Beware of type punned pointers vs strict aliasing
2667 vpp
= &(elf_section_data (s
)->local_dynrel
);
2668 head
= (struct elf_dyn_relocs
**)vpp
;
2672 if (p
== NULL
|| p
->sec
!= sec
)
2674 bfd_size_type amt
= sizeof *p
;
2676 p
= ((struct elf_dyn_relocs
*)
2677 bfd_alloc (htab
->elf
.dynobj
, amt
));
2688 /* Count size relocation as PC-relative relocation. */
2689 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
2694 /* This relocation describes the C++ object vtable hierarchy.
2695 Reconstruct it for later use during GC. */
2696 case R_X86_64_GNU_VTINHERIT
:
2697 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2701 /* This relocation describes which C++ vtable entries are actually
2702 used. Record for later use during GC. */
2703 case R_X86_64_GNU_VTENTRY
:
2704 BFD_ASSERT (h
!= NULL
);
2706 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2716 && h
->plt
.refcount
> 0
2717 && (((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2718 || h
->got
.refcount
> 0)
2719 && htab
->plt_got
== NULL
)
2721 /* Create the GOT procedure linkage table. */
2722 unsigned int plt_got_align
;
2723 const struct elf_backend_data
*bed
;
2725 bed
= get_elf_backend_data (info
->output_bfd
);
2726 BFD_ASSERT (sizeof (elf_x86_64_legacy_plt2_entry
) == 8
2727 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2728 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2731 if (htab
->elf
.dynobj
== NULL
)
2732 htab
->elf
.dynobj
= abfd
;
2734 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2736 (bed
->dynamic_sec_flags
2741 if (htab
->plt_got
== NULL
2742 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2748 if ((r_type
== R_X86_64_GOTPCREL
2749 || r_type
== R_X86_64_GOTPCRELX
2750 || r_type
== R_X86_64_REX_GOTPCRELX
)
2751 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2752 sec
->need_convert_load
= 1;
2755 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2757 if (!info
->keep_memory
)
2761 /* Cache the section contents for elf_link_input_bfd. */
2762 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2769 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2771 sec
->check_relocs_failed
= 1;
2775 /* Return the section that should be marked against GC for a given
2779 elf_x86_64_gc_mark_hook (asection
*sec
,
2780 struct bfd_link_info
*info
,
2781 Elf_Internal_Rela
*rel
,
2782 struct elf_link_hash_entry
*h
,
2783 Elf_Internal_Sym
*sym
)
2786 switch (ELF32_R_TYPE (rel
->r_info
))
2788 case R_X86_64_GNU_VTINHERIT
:
2789 case R_X86_64_GNU_VTENTRY
:
2793 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2796 /* Remove undefined weak symbol from the dynamic symbol table if it
2797 is resolved to 0. */
2800 elf_x86_64_fixup_symbol (struct bfd_link_info
*info
,
2801 struct elf_link_hash_entry
*h
)
2803 if (h
->dynindx
!= -1
2804 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2805 elf_x86_64_hash_entry (h
)->has_got_reloc
,
2806 elf_x86_64_hash_entry (h
)))
2809 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2815 /* Adjust a symbol defined by a dynamic object and referenced by a
2816 regular object. The current definition is in some section of the
2817 dynamic object, but we're not including those sections. We have to
2818 change the definition to something the rest of the link can
2822 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2823 struct elf_link_hash_entry
*h
)
2825 struct elf_x86_64_link_hash_table
*htab
;
2827 struct elf_x86_64_link_hash_entry
*eh
;
2828 struct elf_dyn_relocs
*p
;
2830 /* STT_GNU_IFUNC symbol must go through PLT. */
2831 if (h
->type
== STT_GNU_IFUNC
)
2833 /* All local STT_GNU_IFUNC references must be treate as local
2834 calls via local PLT. */
2836 && SYMBOL_CALLS_LOCAL (info
, h
))
2838 bfd_size_type pc_count
= 0, count
= 0;
2839 struct elf_dyn_relocs
**pp
;
2841 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2842 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2844 pc_count
+= p
->pc_count
;
2845 p
->count
-= p
->pc_count
;
2854 if (pc_count
|| count
)
2858 if (h
->plt
.refcount
<= 0)
2859 h
->plt
.refcount
= 1;
2861 h
->plt
.refcount
+= 1;
2865 if (h
->plt
.refcount
<= 0)
2867 h
->plt
.offset
= (bfd_vma
) -1;
2873 /* If this is a function, put it in the procedure linkage table. We
2874 will fill in the contents of the procedure linkage table later,
2875 when we know the address of the .got section. */
2876 if (h
->type
== STT_FUNC
2879 if (h
->plt
.refcount
<= 0
2880 || SYMBOL_CALLS_LOCAL (info
, h
)
2881 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2882 && h
->root
.type
== bfd_link_hash_undefweak
))
2884 /* This case can occur if we saw a PLT32 reloc in an input
2885 file, but the symbol was never referred to by a dynamic
2886 object, or if all references were garbage collected. In
2887 such a case, we don't actually need to build a procedure
2888 linkage table, and we can just do a PC32 reloc instead. */
2889 h
->plt
.offset
= (bfd_vma
) -1;
2896 /* It's possible that we incorrectly decided a .plt reloc was
2897 needed for an R_X86_64_PC32 reloc to a non-function sym in
2898 check_relocs. We can't decide accurately between function and
2899 non-function syms in check-relocs; Objects loaded later in
2900 the link may change h->type. So fix it now. */
2901 h
->plt
.offset
= (bfd_vma
) -1;
2903 /* If this is a weak symbol, and there is a real definition, the
2904 processor independent code will have arranged for us to see the
2905 real definition first, and we can just use the same value. */
2906 if (h
->u
.weakdef
!= NULL
)
2908 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2909 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2910 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2911 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2912 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2914 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2915 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2916 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
2921 /* This is a reference to a symbol defined by a dynamic object which
2922 is not a function. */
2924 /* If we are creating a shared library, we must presume that the
2925 only references to the symbol are via the global offset table.
2926 For such cases we need not do anything here; the relocations will
2927 be handled correctly by relocate_section. */
2928 if (!bfd_link_executable (info
))
2931 /* If there are no references to this symbol that do not use the
2932 GOT, we don't need to generate a copy reloc. */
2933 if (!h
->non_got_ref
)
2936 /* If -z nocopyreloc was given, we won't generate them either. */
2937 if (info
->nocopyreloc
)
2943 if (ELIMINATE_COPY_RELOCS
)
2945 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2946 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2948 s
= p
->sec
->output_section
;
2949 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2953 /* If we didn't find any dynamic relocs in read-only sections, then
2954 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2962 /* We must allocate the symbol in our .dynbss section, which will
2963 become part of the .bss section of the executable. There will be
2964 an entry for this symbol in the .dynsym section. The dynamic
2965 object will contain position independent code, so all references
2966 from the dynamic object to this symbol will go through the global
2967 offset table. The dynamic linker will use the .dynsym entry to
2968 determine the address it must put in the global offset table, so
2969 both the dynamic object and the regular object will refer to the
2970 same memory location for the variable. */
2972 htab
= elf_x86_64_hash_table (info
);
2976 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2977 to copy the initial value out of the dynamic object and into the
2978 runtime process image. */
2979 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2981 const struct elf_backend_data
*bed
;
2982 bed
= get_elf_backend_data (info
->output_bfd
);
2983 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
2989 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2992 /* Allocate space in .plt, .got and associated reloc sections for
2996 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2998 struct bfd_link_info
*info
;
2999 struct elf_x86_64_link_hash_table
*htab
;
3000 struct elf_x86_64_link_hash_entry
*eh
;
3001 struct elf_dyn_relocs
*p
;
3002 const struct elf_backend_data
*bed
;
3003 unsigned int plt_entry_size
;
3004 bfd_boolean resolved_to_zero
;
3006 if (h
->root
.type
== bfd_link_hash_indirect
)
3009 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3011 info
= (struct bfd_link_info
*) inf
;
3012 htab
= elf_x86_64_hash_table (info
);
3015 bed
= get_elf_backend_data (info
->output_bfd
);
3016 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
3018 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
3022 /* We can't use the GOT PLT if pointer equality is needed since
3023 finish_dynamic_symbol won't clear symbol value and the dynamic
3024 linker won't update the GOT slot. We will get into an infinite
3025 loop at run-time. */
3026 if (htab
->plt_got
!= NULL
3027 && h
->type
!= STT_GNU_IFUNC
3028 && !h
->pointer_equality_needed
3029 && h
->plt
.refcount
> 0
3030 && h
->got
.refcount
> 0)
3032 /* Don't use the regular PLT if there are both GOT and GOTPLT
3034 h
->plt
.offset
= (bfd_vma
) -1;
3036 /* Use the GOT PLT. */
3037 eh
->plt_got
.refcount
= 1;
3040 /* Clear the reference count of function pointer relocations if
3041 symbol isn't a normal function. */
3042 if (h
->type
!= STT_FUNC
)
3043 eh
->func_pointer_refcount
= 0;
3045 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
3046 here if it is defined and referenced in a non-shared object. */
3047 if (h
->type
== STT_GNU_IFUNC
3050 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
3052 &htab
->readonly_dynrelocs_against_ifunc
,
3057 asection
*s
= htab
->plt_bnd
;
3058 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
3060 /* Use the .plt.bnd section if it is created. */
3061 eh
->plt_bnd
.offset
= s
->size
;
3063 /* Make room for this entry in the .plt.bnd section. */
3064 s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
3072 /* Don't create the PLT entry if there are only function pointer
3073 relocations which can be resolved at run-time. */
3074 else if (htab
->elf
.dynamic_sections_created
3075 && (h
->plt
.refcount
> eh
->func_pointer_refcount
3076 || eh
->plt_got
.refcount
> 0))
3078 bfd_boolean use_plt_got
;
3080 /* Clear the reference count of function pointer relocations
3082 eh
->func_pointer_refcount
= 0;
3084 if ((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
3086 /* Don't use the regular PLT for DF_BIND_NOW. */
3087 h
->plt
.offset
= (bfd_vma
) -1;
3089 /* Use the GOT PLT. */
3090 h
->got
.refcount
= 1;
3091 eh
->plt_got
.refcount
= 1;
3094 use_plt_got
= eh
->plt_got
.refcount
> 0;
3096 /* Make sure this symbol is output as a dynamic symbol.
3097 Undefined weak syms won't yet be marked as dynamic. */
3098 if (h
->dynindx
== -1
3100 && !resolved_to_zero
)
3102 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3106 if (bfd_link_pic (info
)
3107 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
3109 asection
*s
= htab
->elf
.splt
;
3110 asection
*bnd_s
= htab
->plt_bnd
;
3111 asection
*got_s
= htab
->plt_got
;
3113 /* If this is the first .plt entry, make room for the special
3114 first entry. The .plt section is used by prelink to undo
3115 prelinking for dynamic relocations. */
3117 s
->size
= plt_entry_size
;
3120 eh
->plt_got
.offset
= got_s
->size
;
3123 h
->plt
.offset
= s
->size
;
3125 eh
->plt_bnd
.offset
= bnd_s
->size
;
3128 /* If this symbol is not defined in a regular file, and we are
3129 not generating a shared library, then set the symbol to this
3130 location in the .plt. This is required to make function
3131 pointers compare as equal between the normal executable and
3132 the shared library. */
3133 if (! bfd_link_pic (info
)
3138 /* We need to make a call to the entry of the GOT PLT
3139 instead of regular PLT entry. */
3140 h
->root
.u
.def
.section
= got_s
;
3141 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
3147 /* We need to make a call to the entry of the second
3148 PLT instead of regular PLT entry. */
3149 h
->root
.u
.def
.section
= bnd_s
;
3150 h
->root
.u
.def
.value
= eh
->plt_bnd
.offset
;
3154 h
->root
.u
.def
.section
= s
;
3155 h
->root
.u
.def
.value
= h
->plt
.offset
;
3160 /* Make room for this entry. */
3162 got_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
3165 s
->size
+= plt_entry_size
;
3167 bnd_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
3169 /* We also need to make an entry in the .got.plt section,
3170 which will be placed in the .got section by the linker
3172 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
3174 /* There should be no PLT relocation against resolved
3175 undefined weak symbol in executable. */
3176 if (!resolved_to_zero
)
3178 /* We also need to make an entry in the .rela.plt
3180 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
3181 htab
->elf
.srelplt
->reloc_count
++;
3187 eh
->plt_got
.offset
= (bfd_vma
) -1;
3188 h
->plt
.offset
= (bfd_vma
) -1;
3194 eh
->plt_got
.offset
= (bfd_vma
) -1;
3195 h
->plt
.offset
= (bfd_vma
) -1;
3199 eh
->tlsdesc_got
= (bfd_vma
) -1;
3201 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
3202 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
3203 if (h
->got
.refcount
> 0
3204 && bfd_link_executable (info
)
3206 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
3208 h
->got
.offset
= (bfd_vma
) -1;
3210 else if (h
->got
.refcount
> 0)
3214 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
3216 /* Make sure this symbol is output as a dynamic symbol.
3217 Undefined weak syms won't yet be marked as dynamic. */
3218 if (h
->dynindx
== -1
3220 && !resolved_to_zero
)
3222 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3226 if (GOT_TLS_GDESC_P (tls_type
))
3228 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
3229 - elf_x86_64_compute_jump_table_size (htab
);
3230 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3231 h
->got
.offset
= (bfd_vma
) -2;
3233 if (! GOT_TLS_GDESC_P (tls_type
)
3234 || GOT_TLS_GD_P (tls_type
))
3237 h
->got
.offset
= s
->size
;
3238 s
->size
+= GOT_ENTRY_SIZE
;
3239 if (GOT_TLS_GD_P (tls_type
))
3240 s
->size
+= GOT_ENTRY_SIZE
;
3242 dyn
= htab
->elf
.dynamic_sections_created
;
3243 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
3244 and two if global. R_X86_64_GOTTPOFF needs one dynamic
3245 relocation. No dynamic relocation against resolved undefined
3246 weak symbol in executable. */
3247 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
3248 || tls_type
== GOT_TLS_IE
)
3249 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3250 else if (GOT_TLS_GD_P (tls_type
))
3251 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
3252 else if (! GOT_TLS_GDESC_P (tls_type
)
3253 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3254 && !resolved_to_zero
)
3255 || h
->root
.type
!= bfd_link_hash_undefweak
)
3256 && (bfd_link_pic (info
)
3257 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
3258 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3259 if (GOT_TLS_GDESC_P (tls_type
))
3261 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
3262 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3266 h
->got
.offset
= (bfd_vma
) -1;
3268 if (eh
->dyn_relocs
== NULL
)
3271 /* In the shared -Bsymbolic case, discard space allocated for
3272 dynamic pc-relative relocs against symbols which turn out to be
3273 defined in regular objects. For the normal shared case, discard
3274 space for pc-relative relocs that have become local due to symbol
3275 visibility changes. */
3277 if (bfd_link_pic (info
))
3279 /* Relocs that use pc_count are those that appear on a call
3280 insn, or certain REL relocs that can generated via assembly.
3281 We want calls to protected symbols to resolve directly to the
3282 function rather than going via the plt. If people want
3283 function pointer comparisons to work as expected then they
3284 should avoid writing weird assembly. */
3285 if (SYMBOL_CALLS_LOCAL (info
, h
))
3287 struct elf_dyn_relocs
**pp
;
3289 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3291 p
->count
-= p
->pc_count
;
3300 /* Also discard relocs on undefined weak syms with non-default
3301 visibility or in PIE. */
3302 if (eh
->dyn_relocs
!= NULL
)
3304 if (h
->root
.type
== bfd_link_hash_undefweak
)
3306 /* Undefined weak symbol is never bound locally in shared
3308 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3309 || resolved_to_zero
)
3310 eh
->dyn_relocs
= NULL
;
3311 else if (h
->dynindx
== -1
3312 && ! h
->forced_local
3313 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3316 /* For PIE, discard space for pc-relative relocs against
3317 symbols which turn out to need copy relocs. */
3318 else if (bfd_link_executable (info
)
3319 && (h
->needs_copy
|| eh
->needs_copy
)
3323 struct elf_dyn_relocs
**pp
;
3325 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3327 if (p
->pc_count
!= 0)
3335 else if (ELIMINATE_COPY_RELOCS
)
3337 /* For the non-shared case, discard space for relocs against
3338 symbols which turn out to need copy relocs or are not
3339 dynamic. Keep dynamic relocations for run-time function
3340 pointer initialization. */
3342 if ((!h
->non_got_ref
3343 || eh
->func_pointer_refcount
> 0
3344 || (h
->root
.type
== bfd_link_hash_undefweak
3345 && !resolved_to_zero
))
3348 || (htab
->elf
.dynamic_sections_created
3349 && (h
->root
.type
== bfd_link_hash_undefweak
3350 || h
->root
.type
== bfd_link_hash_undefined
))))
3352 /* Make sure this symbol is output as a dynamic symbol.
3353 Undefined weak syms won't yet be marked as dynamic. */
3354 if (h
->dynindx
== -1
3355 && ! h
->forced_local
3356 && ! resolved_to_zero
3357 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3360 /* If that succeeded, we know we'll be keeping all the
3362 if (h
->dynindx
!= -1)
3366 eh
->dyn_relocs
= NULL
;
3367 eh
->func_pointer_refcount
= 0;
3372 /* Finally, allocate space. */
3373 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3377 sreloc
= elf_section_data (p
->sec
)->sreloc
;
3379 BFD_ASSERT (sreloc
!= NULL
);
3381 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3387 /* Allocate space in .plt, .got and associated reloc sections for
3388 local dynamic relocs. */
3391 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
3393 struct elf_link_hash_entry
*h
3394 = (struct elf_link_hash_entry
*) *slot
;
3396 if (h
->type
!= STT_GNU_IFUNC
3400 || h
->root
.type
!= bfd_link_hash_defined
)
3403 return elf_x86_64_allocate_dynrelocs (h
, inf
);
3406 /* Find any dynamic relocs that apply to read-only sections. */
3409 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
3412 struct elf_x86_64_link_hash_entry
*eh
;
3413 struct elf_dyn_relocs
*p
;
3415 /* Skip local IFUNC symbols. */
3416 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
3419 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3420 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3422 asection
*s
= p
->sec
->output_section
;
3424 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
3426 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3428 info
->flags
|= DF_TEXTREL
;
3430 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3431 || info
->error_textrel
)
3432 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
3433 p
->sec
->owner
, h
->root
.root
.string
,
3436 /* Not an error, just cut short the traversal. */
3443 /* Convert load via the GOT slot to load immediate. */
3446 elf_x86_64_convert_load (bfd
*abfd
, asection
*sec
,
3447 struct bfd_link_info
*link_info
)
3449 Elf_Internal_Shdr
*symtab_hdr
;
3450 Elf_Internal_Rela
*internal_relocs
;
3451 Elf_Internal_Rela
*irel
, *irelend
;
3453 struct elf_x86_64_link_hash_table
*htab
;
3454 bfd_boolean changed
;
3455 bfd_signed_vma
*local_got_refcounts
;
3457 /* Don't even try to convert non-ELF outputs. */
3458 if (!is_elf_hash_table (link_info
->hash
))
3461 /* Nothing to do if there is no need or no output. */
3462 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
3463 || sec
->need_convert_load
== 0
3464 || bfd_is_abs_section (sec
->output_section
))
3467 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3469 /* Load the relocations for this section. */
3470 internal_relocs
= (_bfd_elf_link_read_relocs
3471 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
3472 link_info
->keep_memory
));
3473 if (internal_relocs
== NULL
)
3477 htab
= elf_x86_64_hash_table (link_info
);
3478 local_got_refcounts
= elf_local_got_refcounts (abfd
);
3480 /* Get the section contents. */
3481 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
3482 contents
= elf_section_data (sec
)->this_hdr
.contents
;
3485 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
3489 irelend
= internal_relocs
+ sec
->reloc_count
;
3490 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3492 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
3493 unsigned int r_symndx
;
3494 struct elf_link_hash_entry
*h
;
3495 bfd_boolean converted
;
3497 if (r_type
!= R_X86_64_GOTPCRELX
3498 && r_type
!= R_X86_64_REX_GOTPCRELX
3499 && r_type
!= R_X86_64_GOTPCREL
)
3502 r_symndx
= htab
->r_sym (irel
->r_info
);
3503 if (r_symndx
< symtab_hdr
->sh_info
)
3504 h
= elf_x86_64_get_local_sym_hash (htab
, sec
->owner
,
3505 (const Elf_Internal_Rela
*) irel
,
3509 h
= elf_sym_hashes (abfd
)[r_symndx
- symtab_hdr
->sh_info
];
3510 while (h
->root
.type
== bfd_link_hash_indirect
3511 || h
->root
.type
== bfd_link_hash_warning
)
3512 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3515 /* STT_GNU_IFUNC must keep GOTPCREL relocations. */
3516 if (h
!= NULL
&& h
->type
== STT_GNU_IFUNC
)
3520 if (!elf_x86_64_convert_load_reloc (abfd
, sec
, contents
, irel
, h
,
3521 &converted
, link_info
))
3526 changed
= converted
;
3529 if (h
->got
.refcount
> 0)
3530 h
->got
.refcount
-= 1;
3534 if (local_got_refcounts
!= NULL
3535 && local_got_refcounts
[r_symndx
] > 0)
3536 local_got_refcounts
[r_symndx
] -= 1;
3541 if (contents
!= NULL
3542 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3544 if (!changed
&& !link_info
->keep_memory
)
3548 /* Cache the section contents for elf_link_input_bfd. */
3549 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3553 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3556 free (internal_relocs
);
3558 elf_section_data (sec
)->relocs
= internal_relocs
;
3564 if (contents
!= NULL
3565 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3567 if (internal_relocs
!= NULL
3568 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3569 free (internal_relocs
);
3573 /* Set the sizes of the dynamic sections. */
3576 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
3577 struct bfd_link_info
*info
)
3579 struct elf_x86_64_link_hash_table
*htab
;
3584 const struct elf_backend_data
*bed
;
3586 htab
= elf_x86_64_hash_table (info
);
3589 bed
= get_elf_backend_data (output_bfd
);
3591 dynobj
= htab
->elf
.dynobj
;
3595 /* Set up .got offsets for local syms, and space for local dynamic
3597 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3599 bfd_signed_vma
*local_got
;
3600 bfd_signed_vma
*end_local_got
;
3601 char *local_tls_type
;
3602 bfd_vma
*local_tlsdesc_gotent
;
3603 bfd_size_type locsymcount
;
3604 Elf_Internal_Shdr
*symtab_hdr
;
3607 if (! is_x86_64_elf (ibfd
))
3610 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3612 struct elf_dyn_relocs
*p
;
3614 if (!elf_x86_64_convert_load (ibfd
, s
, info
))
3617 for (p
= (struct elf_dyn_relocs
*)
3618 (elf_section_data (s
)->local_dynrel
);
3622 if (!bfd_is_abs_section (p
->sec
)
3623 && bfd_is_abs_section (p
->sec
->output_section
))
3625 /* Input section has been discarded, either because
3626 it is a copy of a linkonce section or due to
3627 linker script /DISCARD/, so we'll be discarding
3630 else if (p
->count
!= 0)
3632 srel
= elf_section_data (p
->sec
)->sreloc
;
3633 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3634 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3635 && (info
->flags
& DF_TEXTREL
) == 0)
3637 info
->flags
|= DF_TEXTREL
;
3638 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3639 || info
->error_textrel
)
3640 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3641 p
->sec
->owner
, p
->sec
);
3647 local_got
= elf_local_got_refcounts (ibfd
);
3651 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3652 locsymcount
= symtab_hdr
->sh_info
;
3653 end_local_got
= local_got
+ locsymcount
;
3654 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
3655 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
3657 srel
= htab
->elf
.srelgot
;
3658 for (; local_got
< end_local_got
;
3659 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3661 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3664 if (GOT_TLS_GDESC_P (*local_tls_type
))
3666 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3667 - elf_x86_64_compute_jump_table_size (htab
);
3668 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3669 *local_got
= (bfd_vma
) -2;
3671 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3672 || GOT_TLS_GD_P (*local_tls_type
))
3674 *local_got
= s
->size
;
3675 s
->size
+= GOT_ENTRY_SIZE
;
3676 if (GOT_TLS_GD_P (*local_tls_type
))
3677 s
->size
+= GOT_ENTRY_SIZE
;
3679 if (bfd_link_pic (info
)
3680 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3681 || *local_tls_type
== GOT_TLS_IE
)
3683 if (GOT_TLS_GDESC_P (*local_tls_type
))
3685 htab
->elf
.srelplt
->size
3686 += bed
->s
->sizeof_rela
;
3687 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3689 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3690 || GOT_TLS_GD_P (*local_tls_type
))
3691 srel
->size
+= bed
->s
->sizeof_rela
;
3695 *local_got
= (bfd_vma
) -1;
3699 if (htab
->tls_ld_got
.refcount
> 0)
3701 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3703 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
3704 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
3705 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3708 htab
->tls_ld_got
.offset
= -1;
3710 /* Allocate global sym .plt and .got entries, and space for global
3711 sym dynamic relocs. */
3712 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
3715 /* Allocate .plt and .got entries, and space for local symbols. */
3716 htab_traverse (htab
->loc_hash_table
,
3717 elf_x86_64_allocate_local_dynrelocs
,
3720 /* For every jump slot reserved in the sgotplt, reloc_count is
3721 incremented. However, when we reserve space for TLS descriptors,
3722 it's not incremented, so in order to compute the space reserved
3723 for them, it suffices to multiply the reloc count by the jump
3726 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3727 so that R_X86_64_IRELATIVE entries come last. */
3728 if (htab
->elf
.srelplt
)
3730 htab
->sgotplt_jump_table_size
3731 = elf_x86_64_compute_jump_table_size (htab
);
3732 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3734 else if (htab
->elf
.irelplt
)
3735 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3737 if (htab
->tlsdesc_plt
)
3739 /* If we're not using lazy TLS relocations, don't generate the
3740 PLT and GOT entries they require. */
3741 if ((info
->flags
& DF_BIND_NOW
))
3742 htab
->tlsdesc_plt
= 0;
3745 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
3746 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
3747 /* Reserve room for the initial entry.
3748 FIXME: we could probably do away with it in this case. */
3749 if (htab
->elf
.splt
->size
== 0)
3750 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3751 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
3752 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3756 if (htab
->elf
.sgotplt
)
3758 /* Don't allocate .got.plt section if there are no GOT nor PLT
3759 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3760 if ((htab
->elf
.hgot
== NULL
3761 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3762 && (htab
->elf
.sgotplt
->size
3763 == get_elf_backend_data (output_bfd
)->got_header_size
)
3764 && (htab
->elf
.splt
== NULL
3765 || htab
->elf
.splt
->size
== 0)
3766 && (htab
->elf
.sgot
== NULL
3767 || htab
->elf
.sgot
->size
== 0)
3768 && (htab
->elf
.iplt
== NULL
3769 || htab
->elf
.iplt
->size
== 0)
3770 && (htab
->elf
.igotplt
== NULL
3771 || htab
->elf
.igotplt
->size
== 0))
3772 htab
->elf
.sgotplt
->size
= 0;
3775 if (htab
->plt_eh_frame
!= NULL
3776 && htab
->elf
.splt
!= NULL
3777 && htab
->elf
.splt
->size
!= 0
3778 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3779 && _bfd_elf_eh_frame_present (info
))
3781 const struct elf_x86_64_backend_data
*arch_data
3782 = get_elf_x86_64_arch_data (bed
);
3783 htab
->plt_eh_frame
->size
= arch_data
->eh_frame_plt_size
;
3786 /* We now have determined the sizes of the various dynamic sections.
3787 Allocate memory for them. */
3789 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3791 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3794 if (s
== htab
->elf
.splt
3795 || s
== htab
->elf
.sgot
3796 || s
== htab
->elf
.sgotplt
3797 || s
== htab
->elf
.iplt
3798 || s
== htab
->elf
.igotplt
3799 || s
== htab
->plt_bnd
3800 || s
== htab
->plt_got
3801 || s
== htab
->plt_eh_frame
3802 || s
== htab
->sdynbss
)
3804 /* Strip this section if we don't need it; see the
3807 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3809 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
3812 /* We use the reloc_count field as a counter if we need
3813 to copy relocs into the output file. */
3814 if (s
!= htab
->elf
.srelplt
)
3819 /* It's not one of our sections, so don't allocate space. */
3825 /* If we don't need this section, strip it from the
3826 output file. This is mostly to handle .rela.bss and
3827 .rela.plt. We must create both sections in
3828 create_dynamic_sections, because they must be created
3829 before the linker maps input sections to output
3830 sections. The linker does that before
3831 adjust_dynamic_symbol is called, and it is that
3832 function which decides whether anything needs to go
3833 into these sections. */
3835 s
->flags
|= SEC_EXCLUDE
;
3839 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3842 /* Allocate memory for the section contents. We use bfd_zalloc
3843 here in case unused entries are not reclaimed before the
3844 section's contents are written out. This should not happen,
3845 but this way if it does, we get a R_X86_64_NONE reloc instead
3847 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3848 if (s
->contents
== NULL
)
3852 if (htab
->plt_eh_frame
!= NULL
3853 && htab
->plt_eh_frame
->contents
!= NULL
)
3855 const struct elf_x86_64_backend_data
*arch_data
3856 = get_elf_x86_64_arch_data (bed
);
3858 memcpy (htab
->plt_eh_frame
->contents
,
3859 arch_data
->eh_frame_plt
, htab
->plt_eh_frame
->size
);
3860 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3861 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3864 if (htab
->elf
.dynamic_sections_created
)
3866 /* Add some entries to the .dynamic section. We fill in the
3867 values later, in elf_x86_64_finish_dynamic_sections, but we
3868 must add the entries now so that we get the correct size for
3869 the .dynamic section. The DT_DEBUG entry is filled in by the
3870 dynamic linker and used by the debugger. */
3871 #define add_dynamic_entry(TAG, VAL) \
3872 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3874 if (bfd_link_executable (info
))
3876 if (!add_dynamic_entry (DT_DEBUG
, 0))
3880 if (htab
->elf
.splt
->size
!= 0)
3882 /* DT_PLTGOT is used by prelink even if there is no PLT
3884 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3887 if (htab
->elf
.srelplt
->size
!= 0)
3889 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3890 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3891 || !add_dynamic_entry (DT_JMPREL
, 0))
3895 if (htab
->tlsdesc_plt
3896 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3897 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3903 if (!add_dynamic_entry (DT_RELA
, 0)
3904 || !add_dynamic_entry (DT_RELASZ
, 0)
3905 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3908 /* If any dynamic relocs apply to a read-only section,
3909 then we need a DT_TEXTREL entry. */
3910 if ((info
->flags
& DF_TEXTREL
) == 0)
3911 elf_link_hash_traverse (&htab
->elf
,
3912 elf_x86_64_readonly_dynrelocs
,
3915 if ((info
->flags
& DF_TEXTREL
) != 0)
3917 if (htab
->readonly_dynrelocs_against_ifunc
)
3919 info
->callbacks
->einfo
3920 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3921 bfd_set_error (bfd_error_bad_value
);
3925 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3930 #undef add_dynamic_entry
3936 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3937 struct bfd_link_info
*info
)
3939 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3943 struct elf_link_hash_entry
*tlsbase
;
3945 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3946 "_TLS_MODULE_BASE_",
3947 FALSE
, FALSE
, FALSE
);
3949 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3951 struct elf_x86_64_link_hash_table
*htab
;
3952 struct bfd_link_hash_entry
*bh
= NULL
;
3953 const struct elf_backend_data
*bed
3954 = get_elf_backend_data (output_bfd
);
3956 htab
= elf_x86_64_hash_table (info
);
3960 if (!(_bfd_generic_link_add_one_symbol
3961 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3962 tls_sec
, 0, NULL
, FALSE
,
3963 bed
->collect
, &bh
)))
3966 htab
->tls_module_base
= bh
;
3968 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3969 tlsbase
->def_regular
= 1;
3970 tlsbase
->other
= STV_HIDDEN
;
3971 tlsbase
->root
.linker_def
= 1;
3972 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3979 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3980 executables. Rather than setting it to the beginning of the TLS
3981 section, we have to set it to the end. This function may be called
3982 multiple times, it is idempotent. */
3985 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
3987 struct elf_x86_64_link_hash_table
*htab
;
3988 struct bfd_link_hash_entry
*base
;
3990 if (!bfd_link_executable (info
))
3993 htab
= elf_x86_64_hash_table (info
);
3997 base
= htab
->tls_module_base
;
4001 base
->u
.def
.value
= htab
->elf
.tls_size
;
4004 /* Return the base VMA address which should be subtracted from real addresses
4005 when resolving @dtpoff relocation.
4006 This is PT_TLS segment p_vaddr. */
4009 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
4011 /* If tls_sec is NULL, we should have signalled an error already. */
4012 if (elf_hash_table (info
)->tls_sec
== NULL
)
4014 return elf_hash_table (info
)->tls_sec
->vma
;
4017 /* Return the relocation value for @tpoff relocation
4018 if STT_TLS virtual address is ADDRESS. */
4021 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
4023 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
4024 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
4025 bfd_vma static_tls_size
;
4027 /* If tls_segment is NULL, we should have signalled an error already. */
4028 if (htab
->tls_sec
== NULL
)
4031 /* Consider special static TLS alignment requirements. */
4032 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
4033 return address
- static_tls_size
- htab
->tls_sec
->vma
;
4036 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
4040 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
4042 /* Opcode Instruction
4045 0x0f 0x8x conditional jump */
4047 && (contents
[offset
- 1] == 0xe8
4048 || contents
[offset
- 1] == 0xe9))
4050 && contents
[offset
- 2] == 0x0f
4051 && (contents
[offset
- 1] & 0xf0) == 0x80));
4054 /* Relocate an x86_64 ELF section. */
4057 elf_x86_64_relocate_section (bfd
*output_bfd
,
4058 struct bfd_link_info
*info
,
4060 asection
*input_section
,
4062 Elf_Internal_Rela
*relocs
,
4063 Elf_Internal_Sym
*local_syms
,
4064 asection
**local_sections
)
4066 struct elf_x86_64_link_hash_table
*htab
;
4067 Elf_Internal_Shdr
*symtab_hdr
;
4068 struct elf_link_hash_entry
**sym_hashes
;
4069 bfd_vma
*local_got_offsets
;
4070 bfd_vma
*local_tlsdesc_gotents
;
4071 Elf_Internal_Rela
*rel
;
4072 Elf_Internal_Rela
*wrel
;
4073 Elf_Internal_Rela
*relend
;
4074 const unsigned int plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
4076 BFD_ASSERT (is_x86_64_elf (input_bfd
));
4078 /* Skip if check_relocs failed. */
4079 if (input_section
->check_relocs_failed
)
4082 htab
= elf_x86_64_hash_table (info
);
4085 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
4086 sym_hashes
= elf_sym_hashes (input_bfd
);
4087 local_got_offsets
= elf_local_got_offsets (input_bfd
);
4088 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
4090 elf_x86_64_set_tls_module_base (info
);
4092 rel
= wrel
= relocs
;
4093 relend
= relocs
+ input_section
->reloc_count
;
4094 for (; rel
< relend
; wrel
++, rel
++)
4096 unsigned int r_type
;
4097 reloc_howto_type
*howto
;
4098 unsigned long r_symndx
;
4099 struct elf_link_hash_entry
*h
;
4100 struct elf_x86_64_link_hash_entry
*eh
;
4101 Elf_Internal_Sym
*sym
;
4103 bfd_vma off
, offplt
, plt_offset
;
4105 bfd_boolean unresolved_reloc
;
4106 bfd_reloc_status_type r
;
4108 asection
*base_got
, *resolved_plt
;
4110 bfd_boolean resolved_to_zero
;
4112 r_type
= ELF32_R_TYPE (rel
->r_info
);
4113 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
4114 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
4121 if (r_type
>= (int) R_X86_64_standard
)
4123 (*_bfd_error_handler
)
4124 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
4125 input_bfd
, input_section
, r_type
);
4126 bfd_set_error (bfd_error_bad_value
);
4130 if (r_type
!= (int) R_X86_64_32
4131 || ABI_64_P (output_bfd
))
4132 howto
= x86_64_elf_howto_table
+ r_type
;
4134 howto
= (x86_64_elf_howto_table
4135 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
4136 r_symndx
= htab
->r_sym (rel
->r_info
);
4140 unresolved_reloc
= FALSE
;
4141 if (r_symndx
< symtab_hdr
->sh_info
)
4143 sym
= local_syms
+ r_symndx
;
4144 sec
= local_sections
[r_symndx
];
4146 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
4148 st_size
= sym
->st_size
;
4150 /* Relocate against local STT_GNU_IFUNC symbol. */
4151 if (!bfd_link_relocatable (info
)
4152 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
4154 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
4159 /* Set STT_GNU_IFUNC symbol value. */
4160 h
->root
.u
.def
.value
= sym
->st_value
;
4161 h
->root
.u
.def
.section
= sec
;
4166 bfd_boolean warned ATTRIBUTE_UNUSED
;
4167 bfd_boolean ignored ATTRIBUTE_UNUSED
;
4169 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
4170 r_symndx
, symtab_hdr
, sym_hashes
,
4172 unresolved_reloc
, warned
, ignored
);
4176 if (sec
!= NULL
&& discarded_section (sec
))
4178 _bfd_clear_contents (howto
, input_bfd
, input_section
,
4179 contents
+ rel
->r_offset
);
4180 wrel
->r_offset
= rel
->r_offset
;
4184 /* For ld -r, remove relocations in debug sections against
4185 sections defined in discarded sections. Not done for
4186 eh_frame editing code expects to be present. */
4187 if (bfd_link_relocatable (info
)
4188 && (input_section
->flags
& SEC_DEBUGGING
))
4194 if (bfd_link_relocatable (info
))
4201 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
4203 if (r_type
== R_X86_64_64
)
4205 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
4206 zero-extend it to 64bit if addend is zero. */
4207 r_type
= R_X86_64_32
;
4208 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4210 else if (r_type
== R_X86_64_SIZE64
)
4212 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
4213 zero-extend it to 64bit if addend is zero. */
4214 r_type
= R_X86_64_SIZE32
;
4215 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4219 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
4221 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
4222 it here if it is defined in a non-shared object. */
4224 && h
->type
== STT_GNU_IFUNC
4230 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4232 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4233 sections because such sections are not SEC_ALLOC and
4234 thus ld.so will not process them. */
4235 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
4239 else if (h
->plt
.offset
== (bfd_vma
) -1)
4242 /* STT_GNU_IFUNC symbol must go through PLT. */
4243 if (htab
->elf
.splt
!= NULL
)
4245 if (htab
->plt_bnd
!= NULL
)
4247 resolved_plt
= htab
->plt_bnd
;
4248 plt_offset
= eh
->plt_bnd
.offset
;
4252 resolved_plt
= htab
->elf
.splt
;
4253 plt_offset
= h
->plt
.offset
;
4258 resolved_plt
= htab
->elf
.iplt
;
4259 plt_offset
= h
->plt
.offset
;
4262 relocation
= (resolved_plt
->output_section
->vma
4263 + resolved_plt
->output_offset
+ plt_offset
);
4268 if (h
->root
.root
.string
)
4269 name
= h
->root
.root
.string
;
4271 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4273 (*_bfd_error_handler
)
4274 (_("%B: relocation %s against STT_GNU_IFUNC "
4275 "symbol `%s' isn't handled by %s"), input_bfd
,
4276 howto
->name
, name
, __FUNCTION__
);
4277 bfd_set_error (bfd_error_bad_value
);
4281 if (bfd_link_pic (info
))
4286 if (ABI_64_P (output_bfd
))
4290 if (rel
->r_addend
!= 0)
4292 if (h
->root
.root
.string
)
4293 name
= h
->root
.root
.string
;
4295 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4297 (*_bfd_error_handler
)
4298 (_("%B: relocation %s against STT_GNU_IFUNC "
4299 "symbol `%s' has non-zero addend: %d"),
4300 input_bfd
, howto
->name
, name
, rel
->r_addend
);
4301 bfd_set_error (bfd_error_bad_value
);
4305 /* Generate dynamic relcoation only when there is a
4306 non-GOT reference in a shared object. */
4307 if (bfd_link_pic (info
) && h
->non_got_ref
)
4309 Elf_Internal_Rela outrel
;
4312 /* Need a dynamic relocation to get the real function
4314 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
4318 if (outrel
.r_offset
== (bfd_vma
) -1
4319 || outrel
.r_offset
== (bfd_vma
) -2)
4322 outrel
.r_offset
+= (input_section
->output_section
->vma
4323 + input_section
->output_offset
);
4325 if (h
->dynindx
== -1
4327 || bfd_link_executable (info
))
4329 /* This symbol is resolved locally. */
4330 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4331 outrel
.r_addend
= (h
->root
.u
.def
.value
4332 + h
->root
.u
.def
.section
->output_section
->vma
4333 + h
->root
.u
.def
.section
->output_offset
);
4337 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4338 outrel
.r_addend
= 0;
4341 sreloc
= htab
->elf
.irelifunc
;
4342 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4344 /* If this reloc is against an external symbol, we
4345 do not want to fiddle with the addend. Otherwise,
4346 we need to include the symbol value so that it
4347 becomes an addend for the dynamic reloc. For an
4348 internal symbol, we have updated addend. */
4353 case R_X86_64_PC32_BND
:
4355 case R_X86_64_PLT32
:
4356 case R_X86_64_PLT32_BND
:
4359 case R_X86_64_GOTPCREL
:
4360 case R_X86_64_GOTPCRELX
:
4361 case R_X86_64_REX_GOTPCRELX
:
4362 case R_X86_64_GOTPCREL64
:
4363 base_got
= htab
->elf
.sgot
;
4364 off
= h
->got
.offset
;
4366 if (base_got
== NULL
)
4369 if (off
== (bfd_vma
) -1)
4371 /* We can't use h->got.offset here to save state, or
4372 even just remember the offset, as finish_dynamic_symbol
4373 would use that as offset into .got. */
4375 if (htab
->elf
.splt
!= NULL
)
4377 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4378 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4379 base_got
= htab
->elf
.sgotplt
;
4383 plt_index
= h
->plt
.offset
/ plt_entry_size
;
4384 off
= plt_index
* GOT_ENTRY_SIZE
;
4385 base_got
= htab
->elf
.igotplt
;
4388 if (h
->dynindx
== -1
4392 /* This references the local defitionion. We must
4393 initialize this entry in the global offset table.
4394 Since the offset must always be a multiple of 8,
4395 we use the least significant bit to record
4396 whether we have initialized it already.
4398 When doing a dynamic link, we create a .rela.got
4399 relocation entry to initialize the value. This
4400 is done in the finish_dynamic_symbol routine. */
4405 bfd_put_64 (output_bfd
, relocation
,
4406 base_got
->contents
+ off
);
4407 /* Note that this is harmless for the GOTPLT64
4408 case, as -1 | 1 still is -1. */
4414 relocation
= (base_got
->output_section
->vma
4415 + base_got
->output_offset
+ off
);
4421 resolved_to_zero
= (eh
!= NULL
4422 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
4426 /* When generating a shared object, the relocations handled here are
4427 copied into the output file to be resolved at run time. */
4430 case R_X86_64_GOT32
:
4431 case R_X86_64_GOT64
:
4432 /* Relocation is to the entry for this symbol in the global
4434 case R_X86_64_GOTPCREL
:
4435 case R_X86_64_GOTPCRELX
:
4436 case R_X86_64_REX_GOTPCRELX
:
4437 case R_X86_64_GOTPCREL64
:
4438 /* Use global offset table entry as symbol value. */
4439 case R_X86_64_GOTPLT64
:
4440 /* This is obsolete and treated the the same as GOT64. */
4441 base_got
= htab
->elf
.sgot
;
4443 if (htab
->elf
.sgot
== NULL
)
4450 off
= h
->got
.offset
;
4452 && h
->plt
.offset
!= (bfd_vma
)-1
4453 && off
== (bfd_vma
)-1)
4455 /* We can't use h->got.offset here to save
4456 state, or even just remember the offset, as
4457 finish_dynamic_symbol would use that as offset into
4459 bfd_vma plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4460 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4461 base_got
= htab
->elf
.sgotplt
;
4464 dyn
= htab
->elf
.dynamic_sections_created
;
4466 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
4467 || (bfd_link_pic (info
)
4468 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4469 || (ELF_ST_VISIBILITY (h
->other
)
4470 && h
->root
.type
== bfd_link_hash_undefweak
))
4472 /* This is actually a static link, or it is a -Bsymbolic
4473 link and the symbol is defined locally, or the symbol
4474 was forced to be local because of a version file. We
4475 must initialize this entry in the global offset table.
4476 Since the offset must always be a multiple of 8, we
4477 use the least significant bit to record whether we
4478 have initialized it already.
4480 When doing a dynamic link, we create a .rela.got
4481 relocation entry to initialize the value. This is
4482 done in the finish_dynamic_symbol routine. */
4487 bfd_put_64 (output_bfd
, relocation
,
4488 base_got
->contents
+ off
);
4489 /* Note that this is harmless for the GOTPLT64 case,
4490 as -1 | 1 still is -1. */
4495 unresolved_reloc
= FALSE
;
4499 if (local_got_offsets
== NULL
)
4502 off
= local_got_offsets
[r_symndx
];
4504 /* The offset must always be a multiple of 8. We use
4505 the least significant bit to record whether we have
4506 already generated the necessary reloc. */
4511 bfd_put_64 (output_bfd
, relocation
,
4512 base_got
->contents
+ off
);
4514 if (bfd_link_pic (info
))
4517 Elf_Internal_Rela outrel
;
4519 /* We need to generate a R_X86_64_RELATIVE reloc
4520 for the dynamic linker. */
4521 s
= htab
->elf
.srelgot
;
4525 outrel
.r_offset
= (base_got
->output_section
->vma
4526 + base_got
->output_offset
4528 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4529 outrel
.r_addend
= relocation
;
4530 elf_append_rela (output_bfd
, s
, &outrel
);
4533 local_got_offsets
[r_symndx
] |= 1;
4537 if (off
>= (bfd_vma
) -2)
4540 relocation
= base_got
->output_section
->vma
4541 + base_got
->output_offset
+ off
;
4542 if (r_type
!= R_X86_64_GOTPCREL
4543 && r_type
!= R_X86_64_GOTPCRELX
4544 && r_type
!= R_X86_64_REX_GOTPCRELX
4545 && r_type
!= R_X86_64_GOTPCREL64
)
4546 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4547 - htab
->elf
.sgotplt
->output_offset
;
4551 case R_X86_64_GOTOFF64
:
4552 /* Relocation is relative to the start of the global offset
4555 /* Check to make sure it isn't a protected function or data
4556 symbol for shared library since it may not be local when
4557 used as function address or with copy relocation. We also
4558 need to make sure that a symbol is referenced locally. */
4559 if (bfd_link_pic (info
) && h
)
4561 if (!h
->def_regular
)
4565 switch (ELF_ST_VISIBILITY (h
->other
))
4568 v
= _("hidden symbol");
4571 v
= _("internal symbol");
4574 v
= _("protected symbol");
4581 (*_bfd_error_handler
)
4582 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s `%s' can not be used when making a shared object"),
4583 input_bfd
, v
, h
->root
.root
.string
);
4584 bfd_set_error (bfd_error_bad_value
);
4587 else if (!bfd_link_executable (info
)
4588 && !SYMBOL_REFERENCES_LOCAL (info
, h
)
4589 && (h
->type
== STT_FUNC
4590 || h
->type
== STT_OBJECT
)
4591 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4593 (*_bfd_error_handler
)
4594 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s `%s' can not be used when making a shared object"),
4596 h
->type
== STT_FUNC
? "function" : "data",
4597 h
->root
.root
.string
);
4598 bfd_set_error (bfd_error_bad_value
);
4603 /* Note that sgot is not involved in this
4604 calculation. We always want the start of .got.plt. If we
4605 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4606 permitted by the ABI, we might have to change this
4608 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4609 + htab
->elf
.sgotplt
->output_offset
;
4612 case R_X86_64_GOTPC32
:
4613 case R_X86_64_GOTPC64
:
4614 /* Use global offset table as symbol value. */
4615 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4616 + htab
->elf
.sgotplt
->output_offset
;
4617 unresolved_reloc
= FALSE
;
4620 case R_X86_64_PLTOFF64
:
4621 /* Relocation is PLT entry relative to GOT. For local
4622 symbols it's the symbol itself relative to GOT. */
4624 /* See PLT32 handling. */
4625 && h
->plt
.offset
!= (bfd_vma
) -1
4626 && htab
->elf
.splt
!= NULL
)
4628 if (htab
->plt_bnd
!= NULL
)
4630 resolved_plt
= htab
->plt_bnd
;
4631 plt_offset
= eh
->plt_bnd
.offset
;
4635 resolved_plt
= htab
->elf
.splt
;
4636 plt_offset
= h
->plt
.offset
;
4639 relocation
= (resolved_plt
->output_section
->vma
4640 + resolved_plt
->output_offset
4642 unresolved_reloc
= FALSE
;
4645 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4646 + htab
->elf
.sgotplt
->output_offset
;
4649 case R_X86_64_PLT32
:
4650 case R_X86_64_PLT32_BND
:
4651 /* Relocation is to the entry for this symbol in the
4652 procedure linkage table. */
4654 /* Resolve a PLT32 reloc against a local symbol directly,
4655 without using the procedure linkage table. */
4659 if ((h
->plt
.offset
== (bfd_vma
) -1
4660 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4661 || htab
->elf
.splt
== NULL
)
4663 /* We didn't make a PLT entry for this symbol. This
4664 happens when statically linking PIC code, or when
4665 using -Bsymbolic. */
4669 if (h
->plt
.offset
!= (bfd_vma
) -1)
4671 if (htab
->plt_bnd
!= NULL
)
4673 resolved_plt
= htab
->plt_bnd
;
4674 plt_offset
= eh
->plt_bnd
.offset
;
4678 resolved_plt
= htab
->elf
.splt
;
4679 plt_offset
= h
->plt
.offset
;
4684 /* Use the GOT PLT. */
4685 resolved_plt
= htab
->plt_got
;
4686 plt_offset
= eh
->plt_got
.offset
;
4689 relocation
= (resolved_plt
->output_section
->vma
4690 + resolved_plt
->output_offset
4692 unresolved_reloc
= FALSE
;
4695 case R_X86_64_SIZE32
:
4696 case R_X86_64_SIZE64
:
4697 /* Set to symbol size. */
4698 relocation
= st_size
;
4704 case R_X86_64_PC32_BND
:
4705 /* Don't complain about -fPIC if the symbol is undefined when
4706 building executable unless it is unresolved weak symbol. */
4707 if ((input_section
->flags
& SEC_ALLOC
) != 0
4708 && (input_section
->flags
& SEC_READONLY
) != 0
4710 && ((bfd_link_executable (info
)
4711 && h
->root
.type
== bfd_link_hash_undefweak
4712 && !resolved_to_zero
)
4713 || (bfd_link_pic (info
)
4714 && !(bfd_link_pie (info
)
4715 && h
->root
.type
== bfd_link_hash_undefined
))))
4717 bfd_boolean fail
= FALSE
;
4719 = ((r_type
== R_X86_64_PC32
4720 || r_type
== R_X86_64_PC32_BND
)
4721 && is_32bit_relative_branch (contents
, rel
->r_offset
));
4723 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
4725 /* Symbol is referenced locally. Make sure it is
4726 defined locally or for a branch. */
4727 fail
= !h
->def_regular
&& !branch
;
4729 else if (!(bfd_link_pie (info
)
4730 && (h
->needs_copy
|| eh
->needs_copy
)))
4732 /* Symbol doesn't need copy reloc and isn't referenced
4733 locally. We only allow branch to symbol with
4734 non-default visibility. */
4736 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
4740 return elf_x86_64_need_pic (input_bfd
, input_section
,
4741 h
, NULL
, NULL
, howto
);
4750 /* FIXME: The ABI says the linker should make sure the value is
4751 the same when it's zeroextended to 64 bit. */
4754 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4757 /* Don't copy a pc-relative relocation into the output file
4758 if the symbol needs copy reloc or the symbol is undefined
4759 when building executable. Copy dynamic function pointer
4760 relocations. Don't generate dynamic relocations against
4761 resolved undefined weak symbols in PIE. */
4762 if ((bfd_link_pic (info
)
4763 && !(bfd_link_pie (info
)
4767 || h
->root
.type
== bfd_link_hash_undefined
)
4768 && IS_X86_64_PCREL_TYPE (r_type
))
4770 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4771 && !resolved_to_zero
)
4772 || h
->root
.type
!= bfd_link_hash_undefweak
))
4773 && ((! IS_X86_64_PCREL_TYPE (r_type
)
4774 && r_type
!= R_X86_64_SIZE32
4775 && r_type
!= R_X86_64_SIZE64
)
4776 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
4777 || (ELIMINATE_COPY_RELOCS
4778 && !bfd_link_pic (info
)
4782 || eh
->func_pointer_refcount
> 0
4783 || (h
->root
.type
== bfd_link_hash_undefweak
4784 && !resolved_to_zero
))
4785 && ((h
->def_dynamic
&& !h
->def_regular
)
4786 /* Undefined weak symbol is bound locally when
4788 || h
->root
.type
== bfd_link_hash_undefined
)))
4790 Elf_Internal_Rela outrel
;
4791 bfd_boolean skip
, relocate
;
4794 /* When generating a shared object, these relocations
4795 are copied into the output file to be resolved at run
4801 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4803 if (outrel
.r_offset
== (bfd_vma
) -1)
4805 else if (outrel
.r_offset
== (bfd_vma
) -2)
4806 skip
= TRUE
, relocate
= TRUE
;
4808 outrel
.r_offset
+= (input_section
->output_section
->vma
4809 + input_section
->output_offset
);
4812 memset (&outrel
, 0, sizeof outrel
);
4814 /* h->dynindx may be -1 if this symbol was marked to
4818 && (IS_X86_64_PCREL_TYPE (r_type
)
4819 || !(bfd_link_executable (info
)
4820 || SYMBOLIC_BIND (info
, h
))
4821 || ! h
->def_regular
))
4823 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4824 outrel
.r_addend
= rel
->r_addend
;
4828 /* This symbol is local, or marked to become local.
4829 When relocation overflow check is disabled, we
4830 convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */
4831 if (r_type
== htab
->pointer_r_type
4832 || (r_type
== R_X86_64_32
4833 && info
->no_reloc_overflow_check
))
4836 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4837 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4839 else if (r_type
== R_X86_64_64
4840 && !ABI_64_P (output_bfd
))
4843 outrel
.r_info
= htab
->r_info (0,
4844 R_X86_64_RELATIVE64
);
4845 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4846 /* Check addend overflow. */
4847 if ((outrel
.r_addend
& 0x80000000)
4848 != (rel
->r_addend
& 0x80000000))
4851 int addend
= rel
->r_addend
;
4852 if (h
&& h
->root
.root
.string
)
4853 name
= h
->root
.root
.string
;
4855 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4858 (*_bfd_error_handler
)
4859 (_("%B: addend -0x%x in relocation %s against "
4860 "symbol `%s' at 0x%lx in section `%A' is "
4862 input_bfd
, input_section
, addend
,
4864 (unsigned long) rel
->r_offset
);
4866 (*_bfd_error_handler
)
4867 (_("%B: addend 0x%x in relocation %s against "
4868 "symbol `%s' at 0x%lx in section `%A' is "
4870 input_bfd
, input_section
, addend
,
4872 (unsigned long) rel
->r_offset
);
4873 bfd_set_error (bfd_error_bad_value
);
4881 if (bfd_is_abs_section (sec
))
4883 else if (sec
== NULL
|| sec
->owner
== NULL
)
4885 bfd_set_error (bfd_error_bad_value
);
4892 /* We are turning this relocation into one
4893 against a section symbol. It would be
4894 proper to subtract the symbol's value,
4895 osec->vma, from the emitted reloc addend,
4896 but ld.so expects buggy relocs. */
4897 osec
= sec
->output_section
;
4898 sindx
= elf_section_data (osec
)->dynindx
;
4901 asection
*oi
= htab
->elf
.text_index_section
;
4902 sindx
= elf_section_data (oi
)->dynindx
;
4904 BFD_ASSERT (sindx
!= 0);
4907 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
4908 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4912 sreloc
= elf_section_data (input_section
)->sreloc
;
4914 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4916 r
= bfd_reloc_notsupported
;
4917 goto check_relocation_error
;
4920 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4922 /* If this reloc is against an external symbol, we do
4923 not want to fiddle with the addend. Otherwise, we
4924 need to include the symbol value so that it becomes
4925 an addend for the dynamic reloc. */
4932 case R_X86_64_TLSGD
:
4933 case R_X86_64_GOTPC32_TLSDESC
:
4934 case R_X86_64_TLSDESC_CALL
:
4935 case R_X86_64_GOTTPOFF
:
4936 tls_type
= GOT_UNKNOWN
;
4937 if (h
== NULL
&& local_got_offsets
)
4938 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
4940 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
4942 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4943 input_section
, contents
,
4944 symtab_hdr
, sym_hashes
,
4945 &r_type
, tls_type
, rel
,
4946 relend
, h
, r_symndx
, TRUE
))
4949 if (r_type
== R_X86_64_TPOFF32
)
4951 bfd_vma roff
= rel
->r_offset
;
4953 BFD_ASSERT (! unresolved_reloc
);
4955 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4957 /* GD->LE transition. For 64bit, change
4958 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4959 .word 0x6666; rex64; call __tls_get_addr@PLT
4961 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4963 call *__tls_get_addr@GOTPCREL(%rip)
4964 which may be converted to
4965 addr32 call __tls_get_addr
4968 leaq foo@tpoff(%rax), %rax
4970 leaq foo@tlsgd(%rip), %rdi
4971 .word 0x6666; rex64; call __tls_get_addr@PLT
4973 leaq foo@tlsgd(%rip), %rdi
4975 call *__tls_get_addr@GOTPCREL(%rip)
4976 which may be converted to
4977 addr32 call __tls_get_addr
4980 leaq foo@tpoff(%rax), %rax
4981 For largepic, change:
4982 leaq foo@tlsgd(%rip), %rdi
4983 movabsq $__tls_get_addr@pltoff, %rax
4988 leaq foo@tpoff(%rax), %rax
4989 nopw 0x0(%rax,%rax,1) */
4991 if (ABI_64_P (output_bfd
))
4993 if (contents
[roff
+ 5] == 0xb8)
4995 memcpy (contents
+ roff
- 3,
4996 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
4997 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5001 memcpy (contents
+ roff
- 4,
5002 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5006 memcpy (contents
+ roff
- 3,
5007 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5009 bfd_put_32 (output_bfd
,
5010 elf_x86_64_tpoff (info
, relocation
),
5011 contents
+ roff
+ 8 + largepic
);
5012 /* Skip R_X86_64_PC32, R_X86_64_PLT32,
5013 R_X86_64_GOTPCRELX and R_X86_64_PLTOFF64. */
5018 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5020 /* GDesc -> LE transition.
5021 It's originally something like:
5022 leaq x@tlsdesc(%rip), %rax
5025 movl $x@tpoff, %rax. */
5027 unsigned int val
, type
;
5029 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5030 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5031 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
5032 contents
+ roff
- 3);
5033 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
5034 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
5035 contents
+ roff
- 1);
5036 bfd_put_32 (output_bfd
,
5037 elf_x86_64_tpoff (info
, relocation
),
5041 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5043 /* GDesc -> LE transition.
5048 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5049 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5052 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
5054 /* IE->LE transition:
5055 For 64bit, originally it can be one of:
5056 movq foo@gottpoff(%rip), %reg
5057 addq foo@gottpoff(%rip), %reg
5060 leaq foo(%reg), %reg
5062 For 32bit, originally it can be one of:
5063 movq foo@gottpoff(%rip), %reg
5064 addl foo@gottpoff(%rip), %reg
5067 leal foo(%reg), %reg
5070 unsigned int val
, type
, reg
;
5073 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5076 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
5077 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5083 bfd_put_8 (output_bfd
, 0x49,
5084 contents
+ roff
- 3);
5085 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5086 bfd_put_8 (output_bfd
, 0x41,
5087 contents
+ roff
- 3);
5088 bfd_put_8 (output_bfd
, 0xc7,
5089 contents
+ roff
- 2);
5090 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5091 contents
+ roff
- 1);
5095 /* addq/addl -> addq/addl - addressing with %rsp/%r12
5098 bfd_put_8 (output_bfd
, 0x49,
5099 contents
+ roff
- 3);
5100 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5101 bfd_put_8 (output_bfd
, 0x41,
5102 contents
+ roff
- 3);
5103 bfd_put_8 (output_bfd
, 0x81,
5104 contents
+ roff
- 2);
5105 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5106 contents
+ roff
- 1);
5110 /* addq/addl -> leaq/leal */
5112 bfd_put_8 (output_bfd
, 0x4d,
5113 contents
+ roff
- 3);
5114 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5115 bfd_put_8 (output_bfd
, 0x45,
5116 contents
+ roff
- 3);
5117 bfd_put_8 (output_bfd
, 0x8d,
5118 contents
+ roff
- 2);
5119 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
5120 contents
+ roff
- 1);
5122 bfd_put_32 (output_bfd
,
5123 elf_x86_64_tpoff (info
, relocation
),
5131 if (htab
->elf
.sgot
== NULL
)
5136 off
= h
->got
.offset
;
5137 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
5141 if (local_got_offsets
== NULL
)
5144 off
= local_got_offsets
[r_symndx
];
5145 offplt
= local_tlsdesc_gotents
[r_symndx
];
5152 Elf_Internal_Rela outrel
;
5156 if (htab
->elf
.srelgot
== NULL
)
5159 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
5161 if (GOT_TLS_GDESC_P (tls_type
))
5163 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
5164 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
5165 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
5166 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5167 + htab
->elf
.sgotplt
->output_offset
5169 + htab
->sgotplt_jump_table_size
);
5170 sreloc
= htab
->elf
.srelplt
;
5172 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5174 outrel
.r_addend
= 0;
5175 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5178 sreloc
= htab
->elf
.srelgot
;
5180 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5181 + htab
->elf
.sgot
->output_offset
+ off
);
5183 if (GOT_TLS_GD_P (tls_type
))
5184 dr_type
= R_X86_64_DTPMOD64
;
5185 else if (GOT_TLS_GDESC_P (tls_type
))
5188 dr_type
= R_X86_64_TPOFF64
;
5190 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
5191 outrel
.r_addend
= 0;
5192 if ((dr_type
== R_X86_64_TPOFF64
5193 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
5194 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5195 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
5197 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5199 if (GOT_TLS_GD_P (tls_type
))
5203 BFD_ASSERT (! unresolved_reloc
);
5204 bfd_put_64 (output_bfd
,
5205 relocation
- elf_x86_64_dtpoff_base (info
),
5206 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5210 bfd_put_64 (output_bfd
, 0,
5211 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5212 outrel
.r_info
= htab
->r_info (indx
,
5214 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
5215 elf_append_rela (output_bfd
, sreloc
,
5224 local_got_offsets
[r_symndx
] |= 1;
5227 if (off
>= (bfd_vma
) -2
5228 && ! GOT_TLS_GDESC_P (tls_type
))
5230 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
5232 if (r_type
== R_X86_64_GOTPC32_TLSDESC
5233 || r_type
== R_X86_64_TLSDESC_CALL
)
5234 relocation
= htab
->elf
.sgotplt
->output_section
->vma
5235 + htab
->elf
.sgotplt
->output_offset
5236 + offplt
+ htab
->sgotplt_jump_table_size
;
5238 relocation
= htab
->elf
.sgot
->output_section
->vma
5239 + htab
->elf
.sgot
->output_offset
+ off
;
5240 unresolved_reloc
= FALSE
;
5244 bfd_vma roff
= rel
->r_offset
;
5246 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5248 /* GD->IE transition. For 64bit, change
5249 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5250 .word 0x6666; rex64; call __tls_get_addr@PLT
5252 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5254 call *__tls_get_addr@GOTPCREL(%rip
5255 which may be converted to
5256 addr32 call __tls_get_addr
5259 addq foo@gottpoff(%rip), %rax
5261 leaq foo@tlsgd(%rip), %rdi
5262 .word 0x6666; rex64; call __tls_get_addr@PLT
5264 leaq foo@tlsgd(%rip), %rdi
5266 call *__tls_get_addr@GOTPCREL(%rip)
5267 which may be converted to
5268 addr32 call __tls_get_addr
5271 addq foo@gottpoff(%rip), %rax
5272 For largepic, change:
5273 leaq foo@tlsgd(%rip), %rdi
5274 movabsq $__tls_get_addr@pltoff, %rax
5279 addq foo@gottpoff(%rax), %rax
5280 nopw 0x0(%rax,%rax,1) */
5282 if (ABI_64_P (output_bfd
))
5284 if (contents
[roff
+ 5] == 0xb8)
5286 memcpy (contents
+ roff
- 3,
5287 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
5288 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5292 memcpy (contents
+ roff
- 4,
5293 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5297 memcpy (contents
+ roff
- 3,
5298 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5301 relocation
= (htab
->elf
.sgot
->output_section
->vma
5302 + htab
->elf
.sgot
->output_offset
+ off
5305 - input_section
->output_section
->vma
5306 - input_section
->output_offset
5308 bfd_put_32 (output_bfd
, relocation
,
5309 contents
+ roff
+ 8 + largepic
);
5310 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5315 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5317 /* GDesc -> IE transition.
5318 It's originally something like:
5319 leaq x@tlsdesc(%rip), %rax
5322 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
5324 /* Now modify the instruction as appropriate. To
5325 turn a leaq into a movq in the form we use it, it
5326 suffices to change the second byte from 0x8d to
5328 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
5330 bfd_put_32 (output_bfd
,
5331 htab
->elf
.sgot
->output_section
->vma
5332 + htab
->elf
.sgot
->output_offset
+ off
5334 - input_section
->output_section
->vma
5335 - input_section
->output_offset
5340 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5342 /* GDesc -> IE transition.
5349 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5350 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5358 case R_X86_64_TLSLD
:
5359 if (! elf_x86_64_tls_transition (info
, input_bfd
,
5360 input_section
, contents
,
5361 symtab_hdr
, sym_hashes
,
5362 &r_type
, GOT_UNKNOWN
, rel
,
5363 relend
, h
, r_symndx
, TRUE
))
5366 if (r_type
!= R_X86_64_TLSLD
)
5368 /* LD->LE transition:
5369 leaq foo@tlsld(%rip), %rdi
5370 call __tls_get_addr@PLT
5371 For 64bit, we change it into:
5372 .word 0x6666; .byte 0x66; movq %fs:0, %rax
5373 For 32bit, we change it into:
5374 nopl 0x0(%rax); movl %fs:0, %eax
5376 leaq foo@tlsld(%rip), %rdi;
5377 call *__tls_get_addr@GOTPCREL(%rip)
5378 which may be converted to
5379 addr32 call __tls_get_addr
5380 For 64bit, we change it into:
5381 .word 0x6666; .word 0x6666; movq %fs:0, %rax
5382 For 32bit, we change it into:
5383 nopw 0x0(%rax); movl %fs:0, %eax
5384 For largepic, change:
5385 leaq foo@tlsgd(%rip), %rdi
5386 movabsq $__tls_get_addr@pltoff, %rax
5390 data16 data16 data16 nopw %cs:0x0(%rax,%rax,1)
5393 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
5394 if (ABI_64_P (output_bfd
))
5396 if (contents
[rel
->r_offset
+ 5] == 0xb8)
5397 memcpy (contents
+ rel
->r_offset
- 3,
5398 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
5399 "\x64\x48\x8b\x04\x25\0\0\0", 22);
5400 else if (contents
[rel
->r_offset
+ 4] == 0xff
5401 || contents
[rel
->r_offset
+ 4] == 0x67)
5402 memcpy (contents
+ rel
->r_offset
- 3,
5403 "\x66\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0",
5406 memcpy (contents
+ rel
->r_offset
- 3,
5407 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
5411 if (contents
[rel
->r_offset
+ 4] == 0xff)
5412 memcpy (contents
+ rel
->r_offset
- 3,
5413 "\x66\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0",
5416 memcpy (contents
+ rel
->r_offset
- 3,
5417 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
5419 /* Skip R_X86_64_PC32, R_X86_64_PLT32, R_X86_64_GOTPCRELX
5420 and R_X86_64_PLTOFF64. */
5426 if (htab
->elf
.sgot
== NULL
)
5429 off
= htab
->tls_ld_got
.offset
;
5434 Elf_Internal_Rela outrel
;
5436 if (htab
->elf
.srelgot
== NULL
)
5439 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5440 + htab
->elf
.sgot
->output_offset
+ off
);
5442 bfd_put_64 (output_bfd
, 0,
5443 htab
->elf
.sgot
->contents
+ off
);
5444 bfd_put_64 (output_bfd
, 0,
5445 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5446 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
5447 outrel
.r_addend
= 0;
5448 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
5450 htab
->tls_ld_got
.offset
|= 1;
5452 relocation
= htab
->elf
.sgot
->output_section
->vma
5453 + htab
->elf
.sgot
->output_offset
+ off
;
5454 unresolved_reloc
= FALSE
;
5457 case R_X86_64_DTPOFF32
:
5458 if (!bfd_link_executable (info
)
5459 || (input_section
->flags
& SEC_CODE
) == 0)
5460 relocation
-= elf_x86_64_dtpoff_base (info
);
5462 relocation
= elf_x86_64_tpoff (info
, relocation
);
5465 case R_X86_64_TPOFF32
:
5466 case R_X86_64_TPOFF64
:
5467 BFD_ASSERT (bfd_link_executable (info
));
5468 relocation
= elf_x86_64_tpoff (info
, relocation
);
5471 case R_X86_64_DTPOFF64
:
5472 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
5473 relocation
-= elf_x86_64_dtpoff_base (info
);
5480 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5481 because such sections are not SEC_ALLOC and thus ld.so will
5482 not process them. */
5483 if (unresolved_reloc
5484 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
5486 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5487 rel
->r_offset
) != (bfd_vma
) -1)
5489 (*_bfd_error_handler
)
5490 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5493 (long) rel
->r_offset
,
5495 h
->root
.root
.string
);
5500 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5501 contents
, rel
->r_offset
,
5502 relocation
, rel
->r_addend
);
5504 check_relocation_error
:
5505 if (r
!= bfd_reloc_ok
)
5510 name
= h
->root
.root
.string
;
5513 name
= bfd_elf_string_from_elf_section (input_bfd
,
5514 symtab_hdr
->sh_link
,
5519 name
= bfd_section_name (input_bfd
, sec
);
5522 if (r
== bfd_reloc_overflow
)
5523 (*info
->callbacks
->reloc_overflow
)
5524 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5525 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
5528 (*_bfd_error_handler
)
5529 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5530 input_bfd
, input_section
,
5531 (long) rel
->r_offset
, name
, (int) r
);
5542 Elf_Internal_Shdr
*rel_hdr
;
5543 size_t deleted
= rel
- wrel
;
5545 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
5546 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5547 if (rel_hdr
->sh_size
== 0)
5549 /* It is too late to remove an empty reloc section. Leave
5551 ??? What is wrong with an empty section??? */
5552 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
5555 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5556 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5557 input_section
->reloc_count
-= deleted
;
5563 /* Finish up dynamic symbol handling. We set the contents of various
5564 dynamic sections here. */
5567 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
5568 struct bfd_link_info
*info
,
5569 struct elf_link_hash_entry
*h
,
5570 Elf_Internal_Sym
*sym
)
5572 struct elf_x86_64_link_hash_table
*htab
;
5573 const struct elf_x86_64_backend_data
*abed
;
5574 bfd_boolean use_plt_bnd
;
5575 struct elf_x86_64_link_hash_entry
*eh
;
5576 bfd_boolean local_undefweak
;
5578 htab
= elf_x86_64_hash_table (info
);
5582 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5583 section only if there is .plt section. */
5584 use_plt_bnd
= htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
;
5586 ? &elf_x86_64_bnd_arch_bed
5587 : get_elf_x86_64_backend_data (output_bfd
));
5589 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
5591 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5592 resolved undefined weak symbols in executable so that their
5593 references have value 0 at run-time. */
5594 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
5598 if (h
->plt
.offset
!= (bfd_vma
) -1)
5601 bfd_vma got_offset
, plt_offset
, plt_plt_offset
, plt_got_offset
;
5602 bfd_vma plt_plt_insn_end
, plt_got_insn_size
;
5603 Elf_Internal_Rela rela
;
5605 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
5606 const struct elf_backend_data
*bed
;
5607 bfd_vma plt_got_pcrel_offset
;
5609 /* When building a static executable, use .iplt, .igot.plt and
5610 .rela.iplt sections for STT_GNU_IFUNC symbols. */
5611 if (htab
->elf
.splt
!= NULL
)
5613 plt
= htab
->elf
.splt
;
5614 gotplt
= htab
->elf
.sgotplt
;
5615 relplt
= htab
->elf
.srelplt
;
5619 plt
= htab
->elf
.iplt
;
5620 gotplt
= htab
->elf
.igotplt
;
5621 relplt
= htab
->elf
.irelplt
;
5624 /* This symbol has an entry in the procedure linkage table. Set
5626 if ((h
->dynindx
== -1
5628 && !((h
->forced_local
|| bfd_link_executable (info
))
5630 && h
->type
== STT_GNU_IFUNC
))
5636 /* Get the index in the procedure linkage table which
5637 corresponds to this symbol. This is the index of this symbol
5638 in all the symbols for which we are making plt entries. The
5639 first entry in the procedure linkage table is reserved.
5641 Get the offset into the .got table of the entry that
5642 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
5643 bytes. The first three are reserved for the dynamic linker.
5645 For static executables, we don't reserve anything. */
5647 if (plt
== htab
->elf
.splt
)
5649 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
5650 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
5654 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
5655 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
5658 plt_plt_insn_end
= abed
->plt_plt_insn_end
;
5659 plt_plt_offset
= abed
->plt_plt_offset
;
5660 plt_got_insn_size
= abed
->plt_got_insn_size
;
5661 plt_got_offset
= abed
->plt_got_offset
;
5664 /* Use the second PLT with BND relocations. */
5665 const bfd_byte
*plt_entry
, *plt2_entry
;
5667 if (eh
->has_bnd_reloc
)
5669 plt_entry
= elf_x86_64_bnd_plt_entry
;
5670 plt2_entry
= elf_x86_64_bnd_plt2_entry
;
5674 plt_entry
= elf_x86_64_legacy_plt_entry
;
5675 plt2_entry
= elf_x86_64_legacy_plt2_entry
;
5677 /* Subtract 1 since there is no BND prefix. */
5678 plt_plt_insn_end
-= 1;
5679 plt_plt_offset
-= 1;
5680 plt_got_insn_size
-= 1;
5681 plt_got_offset
-= 1;
5684 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry
)
5685 == sizeof (elf_x86_64_legacy_plt_entry
));
5687 /* Fill in the entry in the procedure linkage table. */
5688 memcpy (plt
->contents
+ h
->plt
.offset
,
5689 plt_entry
, sizeof (elf_x86_64_legacy_plt_entry
));
5690 /* Fill in the entry in the second PLT. */
5691 memcpy (htab
->plt_bnd
->contents
+ eh
->plt_bnd
.offset
,
5692 plt2_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5694 resolved_plt
= htab
->plt_bnd
;
5695 plt_offset
= eh
->plt_bnd
.offset
;
5699 /* Fill in the entry in the procedure linkage table. */
5700 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
5701 abed
->plt_entry_size
);
5704 plt_offset
= h
->plt
.offset
;
5707 /* Insert the relocation positions of the plt section. */
5709 /* Put offset the PC-relative instruction referring to the GOT entry,
5710 subtracting the size of that instruction. */
5711 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
5712 + gotplt
->output_offset
5714 - resolved_plt
->output_section
->vma
5715 - resolved_plt
->output_offset
5717 - plt_got_insn_size
);
5719 /* Check PC-relative offset overflow in PLT entry. */
5720 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
5721 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5722 output_bfd
, h
->root
.root
.string
);
5724 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
5725 resolved_plt
->contents
+ plt_offset
+ plt_got_offset
);
5727 /* Fill in the entry in the global offset table, initially this
5728 points to the second part of the PLT entry. Leave the entry
5729 as zero for undefined weak symbol in PIE. No PLT relocation
5730 against undefined weak symbol in PIE. */
5731 if (!local_undefweak
)
5733 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5734 + plt
->output_offset
5736 + abed
->plt_lazy_offset
),
5737 gotplt
->contents
+ got_offset
);
5739 /* Fill in the entry in the .rela.plt section. */
5740 rela
.r_offset
= (gotplt
->output_section
->vma
5741 + gotplt
->output_offset
5743 if (h
->dynindx
== -1
5744 || ((bfd_link_executable (info
)
5745 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5747 && h
->type
== STT_GNU_IFUNC
))
5749 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5750 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
5751 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
5752 rela
.r_addend
= (h
->root
.u
.def
.value
5753 + h
->root
.u
.def
.section
->output_section
->vma
5754 + h
->root
.u
.def
.section
->output_offset
);
5755 /* R_X86_64_IRELATIVE comes last. */
5756 plt_index
= htab
->next_irelative_index
--;
5760 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
5762 plt_index
= htab
->next_jump_slot_index
++;
5765 /* Don't fill PLT entry for static executables. */
5766 if (plt
== htab
->elf
.splt
)
5768 bfd_vma plt0_offset
= h
->plt
.offset
+ plt_plt_insn_end
;
5770 /* Put relocation index. */
5771 bfd_put_32 (output_bfd
, plt_index
,
5772 (plt
->contents
+ h
->plt
.offset
5773 + abed
->plt_reloc_offset
));
5775 /* Put offset for jmp .PLT0 and check for overflow. We don't
5776 check relocation index for overflow since branch displacement
5777 will overflow first. */
5778 if (plt0_offset
> 0x80000000)
5779 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5780 output_bfd
, h
->root
.root
.string
);
5781 bfd_put_32 (output_bfd
, - plt0_offset
,
5782 plt
->contents
+ h
->plt
.offset
+ plt_plt_offset
);
5785 bed
= get_elf_backend_data (output_bfd
);
5786 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
5787 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
5790 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5792 bfd_vma got_offset
, plt_offset
, plt_got_offset
, plt_got_insn_size
;
5793 asection
*plt
, *got
;
5794 bfd_boolean got_after_plt
;
5795 int32_t got_pcrel_offset
;
5796 const bfd_byte
*got_plt_entry
;
5798 /* Set the entry in the GOT procedure linkage table. */
5799 plt
= htab
->plt_got
;
5800 got
= htab
->elf
.sgot
;
5801 got_offset
= h
->got
.offset
;
5803 if (got_offset
== (bfd_vma
) -1
5804 || h
->type
== STT_GNU_IFUNC
5809 /* Use the second PLT entry template for the GOT PLT since they
5810 are the identical. */
5811 plt_got_insn_size
= elf_x86_64_bnd_arch_bed
.plt_got_insn_size
;
5812 plt_got_offset
= elf_x86_64_bnd_arch_bed
.plt_got_offset
;
5813 if (eh
->has_bnd_reloc
)
5814 got_plt_entry
= elf_x86_64_bnd_plt2_entry
;
5817 got_plt_entry
= elf_x86_64_legacy_plt2_entry
;
5819 /* Subtract 1 since there is no BND prefix. */
5820 plt_got_insn_size
-= 1;
5821 plt_got_offset
-= 1;
5824 /* Fill in the entry in the GOT procedure linkage table. */
5825 plt_offset
= eh
->plt_got
.offset
;
5826 memcpy (plt
->contents
+ plt_offset
,
5827 got_plt_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5829 /* Put offset the PC-relative instruction referring to the GOT
5830 entry, subtracting the size of that instruction. */
5831 got_pcrel_offset
= (got
->output_section
->vma
5832 + got
->output_offset
5834 - plt
->output_section
->vma
5835 - plt
->output_offset
5837 - plt_got_insn_size
);
5839 /* Check PC-relative offset overflow in GOT PLT entry. */
5840 got_after_plt
= got
->output_section
->vma
> plt
->output_section
->vma
;
5841 if ((got_after_plt
&& got_pcrel_offset
< 0)
5842 || (!got_after_plt
&& got_pcrel_offset
> 0))
5843 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
5844 output_bfd
, h
->root
.root
.string
);
5846 bfd_put_32 (output_bfd
, got_pcrel_offset
,
5847 plt
->contents
+ plt_offset
+ plt_got_offset
);
5850 if (!local_undefweak
5852 && (h
->plt
.offset
!= (bfd_vma
) -1
5853 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5855 /* Mark the symbol as undefined, rather than as defined in
5856 the .plt section. Leave the value if there were any
5857 relocations where pointer equality matters (this is a clue
5858 for the dynamic linker, to make function pointer
5859 comparisons work between an application and shared
5860 library), otherwise set it to zero. If a function is only
5861 called from a binary, there is no need to slow down
5862 shared libraries because of that. */
5863 sym
->st_shndx
= SHN_UNDEF
;
5864 if (!h
->pointer_equality_needed
)
5868 /* Don't generate dynamic GOT relocation against undefined weak
5869 symbol in executable. */
5870 if (h
->got
.offset
!= (bfd_vma
) -1
5871 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
5872 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
5873 && !local_undefweak
)
5875 Elf_Internal_Rela rela
;
5877 /* This symbol has an entry in the global offset table. Set it
5879 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5882 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5883 + htab
->elf
.sgot
->output_offset
5884 + (h
->got
.offset
&~ (bfd_vma
) 1));
5886 /* If this is a static link, or it is a -Bsymbolic link and the
5887 symbol is defined locally or was forced to be local because
5888 of a version file, we just want to emit a RELATIVE reloc.
5889 The entry in the global offset table will already have been
5890 initialized in the relocate_section function. */
5892 && h
->type
== STT_GNU_IFUNC
)
5894 if (bfd_link_pic (info
))
5896 /* Generate R_X86_64_GLOB_DAT. */
5903 if (!h
->pointer_equality_needed
)
5906 /* For non-shared object, we can't use .got.plt, which
5907 contains the real function addres if we need pointer
5908 equality. We load the GOT entry with the PLT entry. */
5909 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5910 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5911 + plt
->output_offset
5913 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5917 else if (bfd_link_pic (info
)
5918 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5920 if (!h
->def_regular
)
5922 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5923 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
5924 rela
.r_addend
= (h
->root
.u
.def
.value
5925 + h
->root
.u
.def
.section
->output_section
->vma
5926 + h
->root
.u
.def
.section
->output_offset
);
5930 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5932 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5933 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5934 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
5938 elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &rela
);
5943 Elf_Internal_Rela rela
;
5945 /* This symbol needs a copy reloc. Set it up. */
5947 if (h
->dynindx
== -1
5948 || (h
->root
.type
!= bfd_link_hash_defined
5949 && h
->root
.type
!= bfd_link_hash_defweak
)
5950 || htab
->srelbss
== NULL
)
5953 rela
.r_offset
= (h
->root
.u
.def
.value
5954 + h
->root
.u
.def
.section
->output_section
->vma
5955 + h
->root
.u
.def
.section
->output_offset
);
5956 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
5958 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
5964 /* Finish up local dynamic symbol handling. We set the contents of
5965 various dynamic sections here. */
5968 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
5970 struct elf_link_hash_entry
*h
5971 = (struct elf_link_hash_entry
*) *slot
;
5972 struct bfd_link_info
*info
5973 = (struct bfd_link_info
*) inf
;
5975 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5979 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5980 here since undefined weak symbol may not be dynamic and may not be
5981 called for elf_x86_64_finish_dynamic_symbol. */
5984 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
5987 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
5988 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5990 if (h
->root
.type
!= bfd_link_hash_undefweak
5991 || h
->dynindx
!= -1)
5994 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5998 /* Used to decide how to sort relocs in an optimal manner for the
5999 dynamic linker, before writing them out. */
6001 static enum elf_reloc_type_class
6002 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info
,
6003 const asection
*rel_sec ATTRIBUTE_UNUSED
,
6004 const Elf_Internal_Rela
*rela
)
6006 bfd
*abfd
= info
->output_bfd
;
6007 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6008 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
6010 if (htab
->elf
.dynsym
!= NULL
6011 && htab
->elf
.dynsym
->contents
!= NULL
)
6013 /* Check relocation against STT_GNU_IFUNC symbol if there are
6015 unsigned long r_symndx
= htab
->r_sym (rela
->r_info
);
6016 if (r_symndx
!= STN_UNDEF
)
6018 Elf_Internal_Sym sym
;
6019 if (!bed
->s
->swap_symbol_in (abfd
,
6020 (htab
->elf
.dynsym
->contents
6021 + r_symndx
* bed
->s
->sizeof_sym
),
6025 if (ELF_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
6026 return reloc_class_ifunc
;
6030 switch ((int) ELF32_R_TYPE (rela
->r_info
))
6032 case R_X86_64_IRELATIVE
:
6033 return reloc_class_ifunc
;
6034 case R_X86_64_RELATIVE
:
6035 case R_X86_64_RELATIVE64
:
6036 return reloc_class_relative
;
6037 case R_X86_64_JUMP_SLOT
:
6038 return reloc_class_plt
;
6040 return reloc_class_copy
;
6042 return reloc_class_normal
;
6046 /* Finish up the dynamic sections. */
6049 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
6050 struct bfd_link_info
*info
)
6052 struct elf_x86_64_link_hash_table
*htab
;
6055 const struct elf_x86_64_backend_data
*abed
;
6057 htab
= elf_x86_64_hash_table (info
);
6061 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
6062 section only if there is .plt section. */
6063 abed
= (htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
6064 ? &elf_x86_64_bnd_arch_bed
6065 : get_elf_x86_64_backend_data (output_bfd
));
6067 dynobj
= htab
->elf
.dynobj
;
6068 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
6070 if (htab
->elf
.dynamic_sections_created
)
6072 bfd_byte
*dyncon
, *dynconend
;
6073 const struct elf_backend_data
*bed
;
6074 bfd_size_type sizeof_dyn
;
6076 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
6079 bed
= get_elf_backend_data (dynobj
);
6080 sizeof_dyn
= bed
->s
->sizeof_dyn
;
6081 dyncon
= sdyn
->contents
;
6082 dynconend
= sdyn
->contents
+ sdyn
->size
;
6083 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
6085 Elf_Internal_Dyn dyn
;
6088 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
6096 s
= htab
->elf
.sgotplt
;
6097 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
6101 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
6105 s
= htab
->elf
.srelplt
->output_section
;
6106 dyn
.d_un
.d_val
= s
->size
;
6110 /* The procedure linkage table relocs (DT_JMPREL) should
6111 not be included in the overall relocs (DT_RELA).
6112 Therefore, we override the DT_RELASZ entry here to
6113 make it not include the JMPREL relocs. Since the
6114 linker script arranges for .rela.plt to follow all
6115 other relocation sections, we don't have to worry
6116 about changing the DT_RELA entry. */
6117 if (htab
->elf
.srelplt
!= NULL
)
6119 s
= htab
->elf
.srelplt
->output_section
;
6120 dyn
.d_un
.d_val
-= s
->size
;
6124 case DT_TLSDESC_PLT
:
6126 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6127 + htab
->tlsdesc_plt
;
6130 case DT_TLSDESC_GOT
:
6132 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6133 + htab
->tlsdesc_got
;
6137 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
6140 /* Fill in the special first entry in the procedure linkage table. */
6141 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
6143 /* Fill in the first entry in the procedure linkage table. */
6144 memcpy (htab
->elf
.splt
->contents
,
6145 abed
->plt0_entry
, abed
->plt_entry_size
);
6146 /* Add offset for pushq GOT+8(%rip), since the instruction
6147 uses 6 bytes subtract this value. */
6148 bfd_put_32 (output_bfd
,
6149 (htab
->elf
.sgotplt
->output_section
->vma
6150 + htab
->elf
.sgotplt
->output_offset
6152 - htab
->elf
.splt
->output_section
->vma
6153 - htab
->elf
.splt
->output_offset
6155 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
6156 /* Add offset for the PC-relative instruction accessing GOT+16,
6157 subtracting the offset to the end of that instruction. */
6158 bfd_put_32 (output_bfd
,
6159 (htab
->elf
.sgotplt
->output_section
->vma
6160 + htab
->elf
.sgotplt
->output_offset
6162 - htab
->elf
.splt
->output_section
->vma
6163 - htab
->elf
.splt
->output_offset
6164 - abed
->plt0_got2_insn_end
),
6165 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
6167 elf_section_data (htab
->elf
.splt
->output_section
)
6168 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
6170 if (htab
->tlsdesc_plt
)
6172 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6173 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
6175 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
6176 abed
->plt0_entry
, abed
->plt_entry_size
);
6178 /* Add offset for pushq GOT+8(%rip), since the
6179 instruction uses 6 bytes subtract this value. */
6180 bfd_put_32 (output_bfd
,
6181 (htab
->elf
.sgotplt
->output_section
->vma
6182 + htab
->elf
.sgotplt
->output_offset
6184 - htab
->elf
.splt
->output_section
->vma
6185 - htab
->elf
.splt
->output_offset
6188 htab
->elf
.splt
->contents
6189 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
6190 /* Add offset for the PC-relative instruction accessing GOT+TDG,
6191 where TGD stands for htab->tlsdesc_got, subtracting the offset
6192 to the end of that instruction. */
6193 bfd_put_32 (output_bfd
,
6194 (htab
->elf
.sgot
->output_section
->vma
6195 + htab
->elf
.sgot
->output_offset
6197 - htab
->elf
.splt
->output_section
->vma
6198 - htab
->elf
.splt
->output_offset
6200 - abed
->plt0_got2_insn_end
),
6201 htab
->elf
.splt
->contents
6202 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
6207 if (htab
->plt_bnd
!= NULL
)
6208 elf_section_data (htab
->plt_bnd
->output_section
)
6209 ->this_hdr
.sh_entsize
= sizeof (elf_x86_64_bnd_plt2_entry
);
6211 if (htab
->elf
.sgotplt
)
6213 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
6215 (*_bfd_error_handler
)
6216 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
6220 /* Fill in the first three entries in the global offset table. */
6221 if (htab
->elf
.sgotplt
->size
> 0)
6223 /* Set the first entry in the global offset table to the address of
6224 the dynamic section. */
6226 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
6228 bfd_put_64 (output_bfd
,
6229 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
6230 htab
->elf
.sgotplt
->contents
);
6231 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
6232 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
6233 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
6236 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
6240 /* Adjust .eh_frame for .plt section. */
6241 if (htab
->plt_eh_frame
!= NULL
6242 && htab
->plt_eh_frame
->contents
!= NULL
)
6244 if (htab
->elf
.splt
!= NULL
6245 && htab
->elf
.splt
->size
!= 0
6246 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
6247 && htab
->elf
.splt
->output_section
!= NULL
6248 && htab
->plt_eh_frame
->output_section
!= NULL
)
6250 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
6251 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
6252 + htab
->plt_eh_frame
->output_offset
6253 + PLT_FDE_START_OFFSET
;
6254 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6255 htab
->plt_eh_frame
->contents
6256 + PLT_FDE_START_OFFSET
);
6258 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
6260 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6262 htab
->plt_eh_frame
->contents
))
6267 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
6268 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
6271 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
6272 htab_traverse (htab
->loc_hash_table
,
6273 elf_x86_64_finish_local_dynamic_symbol
,
6276 /* Fill PLT entries for undefined weak symbols in PIE. */
6277 if (bfd_link_pie (info
))
6278 bfd_hash_traverse (&info
->hash
->table
,
6279 elf_x86_64_pie_finish_undefweak_symbol
,
6285 /* Return an array of PLT entry symbol values. */
6288 elf_x86_64_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
6291 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
6294 bfd_vma
*plt_sym_val
;
6296 bfd_byte
*plt_contents
;
6297 const struct elf_x86_64_backend_data
*bed
;
6298 Elf_Internal_Shdr
*hdr
;
6301 /* Get the .plt section contents. PLT passed down may point to the
6302 .plt.bnd section. Make sure that PLT always points to the .plt
6304 plt_bnd
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6309 plt
= bfd_get_section_by_name (abfd
, ".plt");
6312 bed
= &elf_x86_64_bnd_arch_bed
;
6315 bed
= get_elf_x86_64_backend_data (abfd
);
6317 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
6318 if (plt_contents
== NULL
)
6320 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
6321 plt_contents
, 0, plt
->size
))
6324 free (plt_contents
);
6328 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
6329 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
6332 hdr
= &elf_section_data (relplt
)->this_hdr
;
6333 count
= relplt
->size
/ hdr
->sh_entsize
;
6335 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
6336 if (plt_sym_val
== NULL
)
6339 for (i
= 0; i
< count
; i
++)
6340 plt_sym_val
[i
] = -1;
6342 plt_offset
= bed
->plt_entry_size
;
6343 p
= relplt
->relocation
;
6344 for (i
= 0; i
< count
; i
++, p
++)
6348 /* Skip unknown relocation. */
6349 if (p
->howto
== NULL
)
6352 if (p
->howto
->type
!= R_X86_64_JUMP_SLOT
6353 && p
->howto
->type
!= R_X86_64_IRELATIVE
)
6356 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
6357 + bed
->plt_reloc_offset
));
6358 if (reloc_index
< count
)
6362 /* This is the index in .plt section. */
6363 long plt_index
= plt_offset
/ bed
->plt_entry_size
;
6364 /* Store VMA + the offset in .plt.bnd section. */
6365 plt_sym_val
[reloc_index
] =
6367 + (plt_index
- 1) * sizeof (elf_x86_64_legacy_plt2_entry
));
6370 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
6372 plt_offset
+= bed
->plt_entry_size
;
6374 /* PR binutils/18437: Skip extra relocations in the .rela.plt
6376 if (plt_offset
>= plt
->size
)
6380 free (plt_contents
);
6385 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
6389 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
6396 /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
6397 as PLT if it exists. */
6398 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6400 plt
= bfd_get_section_by_name (abfd
, ".plt");
6401 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
6402 dynsymcount
, dynsyms
, ret
,
6404 elf_x86_64_get_plt_sym_val
);
6407 /* Handle an x86-64 specific section when reading an object file. This
6408 is called when elfcode.h finds a section with an unknown type. */
6411 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
6412 const char *name
, int shindex
)
6414 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
6417 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
6423 /* Hook called by the linker routine which adds symbols from an object
6424 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
6428 elf_x86_64_add_symbol_hook (bfd
*abfd
,
6429 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6430 Elf_Internal_Sym
*sym
,
6431 const char **namep ATTRIBUTE_UNUSED
,
6432 flagword
*flagsp ATTRIBUTE_UNUSED
,
6438 switch (sym
->st_shndx
)
6440 case SHN_X86_64_LCOMMON
:
6441 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
6444 lcomm
= bfd_make_section_with_flags (abfd
,
6448 | SEC_LINKER_CREATED
));
6451 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
6454 *valp
= sym
->st_size
;
6462 /* Given a BFD section, try to locate the corresponding ELF section
6466 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
6467 asection
*sec
, int *index_return
)
6469 if (sec
== &_bfd_elf_large_com_section
)
6471 *index_return
= SHN_X86_64_LCOMMON
;
6477 /* Process a symbol. */
6480 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
6483 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
6485 switch (elfsym
->internal_elf_sym
.st_shndx
)
6487 case SHN_X86_64_LCOMMON
:
6488 asym
->section
= &_bfd_elf_large_com_section
;
6489 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
6490 /* Common symbol doesn't set BSF_GLOBAL. */
6491 asym
->flags
&= ~BSF_GLOBAL
;
6497 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
6499 return (sym
->st_shndx
== SHN_COMMON
6500 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
6504 elf_x86_64_common_section_index (asection
*sec
)
6506 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6509 return SHN_X86_64_LCOMMON
;
6513 elf_x86_64_common_section (asection
*sec
)
6515 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6516 return bfd_com_section_ptr
;
6518 return &_bfd_elf_large_com_section
;
6522 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
6523 const Elf_Internal_Sym
*sym
,
6528 const asection
*oldsec
)
6530 /* A normal common symbol and a large common symbol result in a
6531 normal common symbol. We turn the large common symbol into a
6534 && h
->root
.type
== bfd_link_hash_common
6536 && bfd_is_com_section (*psec
)
6539 if (sym
->st_shndx
== SHN_COMMON
6540 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
6542 h
->root
.u
.c
.p
->section
6543 = bfd_make_section_old_way (oldbfd
, "COMMON");
6544 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
6546 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
6547 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
6548 *psec
= bfd_com_section_ptr
;
6555 elf_x86_64_additional_program_headers (bfd
*abfd
,
6556 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6561 /* Check to see if we need a large readonly segment. */
6562 s
= bfd_get_section_by_name (abfd
, ".lrodata");
6563 if (s
&& (s
->flags
& SEC_LOAD
))
6566 /* Check to see if we need a large data segment. Since .lbss sections
6567 is placed right after the .bss section, there should be no need for
6568 a large data segment just because of .lbss. */
6569 s
= bfd_get_section_by_name (abfd
, ".ldata");
6570 if (s
&& (s
->flags
& SEC_LOAD
))
6576 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6579 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
6581 if (h
->plt
.offset
!= (bfd_vma
) -1
6583 && !h
->pointer_equality_needed
)
6586 return _bfd_elf_hash_symbol (h
);
6589 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
6592 elf_x86_64_relocs_compatible (const bfd_target
*input
,
6593 const bfd_target
*output
)
6595 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
6596 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
6597 && _bfd_elf_relocs_compatible (input
, output
));
6600 static const struct bfd_elf_special_section
6601 elf_x86_64_special_sections
[]=
6603 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6604 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6605 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
6606 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6607 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6608 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6609 { NULL
, 0, 0, 0, 0 }
6612 #define TARGET_LITTLE_SYM x86_64_elf64_vec
6613 #define TARGET_LITTLE_NAME "elf64-x86-64"
6614 #define ELF_ARCH bfd_arch_i386
6615 #define ELF_TARGET_ID X86_64_ELF_DATA
6616 #define ELF_MACHINE_CODE EM_X86_64
6617 #define ELF_MAXPAGESIZE 0x200000
6618 #define ELF_MINPAGESIZE 0x1000
6619 #define ELF_COMMONPAGESIZE 0x1000
6621 #define elf_backend_can_gc_sections 1
6622 #define elf_backend_can_refcount 1
6623 #define elf_backend_want_got_plt 1
6624 #define elf_backend_plt_readonly 1
6625 #define elf_backend_want_plt_sym 0
6626 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
6627 #define elf_backend_rela_normal 1
6628 #define elf_backend_plt_alignment 4
6629 #define elf_backend_extern_protected_data 1
6630 #define elf_backend_caches_rawsize 1
6632 #define elf_info_to_howto elf_x86_64_info_to_howto
6634 #define bfd_elf64_bfd_link_hash_table_create \
6635 elf_x86_64_link_hash_table_create
6636 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
6637 #define bfd_elf64_bfd_reloc_name_lookup \
6638 elf_x86_64_reloc_name_lookup
6640 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
6641 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
6642 #define elf_backend_check_relocs elf_x86_64_check_relocs
6643 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
6644 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
6645 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
6646 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
6647 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
6648 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
6649 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
6651 #define elf_backend_write_core_note elf_x86_64_write_core_note
6653 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
6654 #define elf_backend_relocate_section elf_x86_64_relocate_section
6655 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
6656 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
6657 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
6658 #define elf_backend_object_p elf64_x86_64_elf_object_p
6659 #define bfd_elf64_mkobject elf_x86_64_mkobject
6660 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
6662 #define elf_backend_section_from_shdr \
6663 elf_x86_64_section_from_shdr
6665 #define elf_backend_section_from_bfd_section \
6666 elf_x86_64_elf_section_from_bfd_section
6667 #define elf_backend_add_symbol_hook \
6668 elf_x86_64_add_symbol_hook
6669 #define elf_backend_symbol_processing \
6670 elf_x86_64_symbol_processing
6671 #define elf_backend_common_section_index \
6672 elf_x86_64_common_section_index
6673 #define elf_backend_common_section \
6674 elf_x86_64_common_section
6675 #define elf_backend_common_definition \
6676 elf_x86_64_common_definition
6677 #define elf_backend_merge_symbol \
6678 elf_x86_64_merge_symbol
6679 #define elf_backend_special_sections \
6680 elf_x86_64_special_sections
6681 #define elf_backend_additional_program_headers \
6682 elf_x86_64_additional_program_headers
6683 #define elf_backend_hash_symbol \
6684 elf_x86_64_hash_symbol
6685 #define elf_backend_omit_section_dynsym \
6686 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6687 #define elf_backend_fixup_symbol \
6688 elf_x86_64_fixup_symbol
6690 #include "elf64-target.h"
6692 /* CloudABI support. */
6694 #undef TARGET_LITTLE_SYM
6695 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
6696 #undef TARGET_LITTLE_NAME
6697 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
6700 #define ELF_OSABI ELFOSABI_CLOUDABI
6703 #define elf64_bed elf64_x86_64_cloudabi_bed
6705 #include "elf64-target.h"
6707 /* FreeBSD support. */
6709 #undef TARGET_LITTLE_SYM
6710 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
6711 #undef TARGET_LITTLE_NAME
6712 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
6715 #define ELF_OSABI ELFOSABI_FREEBSD
6718 #define elf64_bed elf64_x86_64_fbsd_bed
6720 #include "elf64-target.h"
6722 /* Solaris 2 support. */
6724 #undef TARGET_LITTLE_SYM
6725 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
6726 #undef TARGET_LITTLE_NAME
6727 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
6729 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6730 objects won't be recognized. */
6734 #define elf64_bed elf64_x86_64_sol2_bed
6736 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
6738 #undef elf_backend_static_tls_alignment
6739 #define elf_backend_static_tls_alignment 16
6741 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6743 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6745 #undef elf_backend_want_plt_sym
6746 #define elf_backend_want_plt_sym 1
6748 #undef elf_backend_strtab_flags
6749 #define elf_backend_strtab_flags SHF_STRINGS
6752 elf64_x86_64_copy_solaris_special_section_fields (const bfd
*ibfd ATTRIBUTE_UNUSED
,
6753 bfd
*obfd ATTRIBUTE_UNUSED
,
6754 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
6755 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
6757 /* PR 19938: FIXME: Need to add code for setting the sh_info
6758 and sh_link fields of Solaris specific section types. */
6762 #undef elf_backend_copy_special_section_fields
6763 #define elf_backend_copy_special_section_fields elf64_x86_64_copy_solaris_special_section_fields
6765 #include "elf64-target.h"
6767 /* Native Client support. */
6770 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
6772 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
6773 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
6777 #undef TARGET_LITTLE_SYM
6778 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
6779 #undef TARGET_LITTLE_NAME
6780 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
6782 #define elf64_bed elf64_x86_64_nacl_bed
6784 #undef ELF_MAXPAGESIZE
6785 #undef ELF_MINPAGESIZE
6786 #undef ELF_COMMONPAGESIZE
6787 #define ELF_MAXPAGESIZE 0x10000
6788 #define ELF_MINPAGESIZE 0x10000
6789 #define ELF_COMMONPAGESIZE 0x10000
6791 /* Restore defaults. */
6793 #undef elf_backend_static_tls_alignment
6794 #undef elf_backend_want_plt_sym
6795 #define elf_backend_want_plt_sym 0
6796 #undef elf_backend_strtab_flags
6797 #undef elf_backend_copy_special_section_fields
6799 /* NaCl uses substantially different PLT entries for the same effects. */
6801 #undef elf_backend_plt_alignment
6802 #define elf_backend_plt_alignment 5
6803 #define NACL_PLT_ENTRY_SIZE 64
6804 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6806 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
6808 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
6809 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
6810 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6811 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6812 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6814 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
6815 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
6817 /* 32 bytes of nop to pad out to the standard size. */
6818 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6819 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6820 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6821 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6822 0x66, /* excess data16 prefix */
6826 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6828 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
6829 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6830 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6831 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6833 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
6834 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6835 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6837 /* Lazy GOT entries point here (32-byte aligned). */
6838 0x68, /* pushq immediate */
6839 0, 0, 0, 0, /* replaced with index into relocation table. */
6840 0xe9, /* jmp relative */
6841 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
6843 /* 22 bytes of nop to pad out to the standard size. */
6844 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6845 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6846 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
6849 /* .eh_frame covering the .plt section. */
6851 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
6853 #if (PLT_CIE_LENGTH != 20 \
6854 || PLT_FDE_LENGTH != 36 \
6855 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6856 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6857 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
6859 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6860 0, 0, 0, 0, /* CIE ID */
6861 1, /* CIE version */
6862 'z', 'R', 0, /* Augmentation string */
6863 1, /* Code alignment factor */
6864 0x78, /* Data alignment factor */
6865 16, /* Return address column */
6866 1, /* Augmentation size */
6867 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6868 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
6869 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
6870 DW_CFA_nop
, DW_CFA_nop
,
6872 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6873 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
6874 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
6875 0, 0, 0, 0, /* .plt size goes here */
6876 0, /* Augmentation size */
6877 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
6878 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6879 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
6880 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6881 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6882 13, /* Block length */
6883 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
6884 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
6885 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6886 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
6887 DW_CFA_nop
, DW_CFA_nop
6890 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
6892 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
6893 elf_x86_64_nacl_plt_entry
, /* plt_entry */
6894 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6895 2, /* plt0_got1_offset */
6896 9, /* plt0_got2_offset */
6897 13, /* plt0_got2_insn_end */
6898 3, /* plt_got_offset */
6899 33, /* plt_reloc_offset */
6900 38, /* plt_plt_offset */
6901 7, /* plt_got_insn_size */
6902 42, /* plt_plt_insn_end */
6903 32, /* plt_lazy_offset */
6904 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
6905 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
6908 #undef elf_backend_arch_data
6909 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
6911 #undef elf_backend_object_p
6912 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
6913 #undef elf_backend_modify_segment_map
6914 #define elf_backend_modify_segment_map nacl_modify_segment_map
6915 #undef elf_backend_modify_program_headers
6916 #define elf_backend_modify_program_headers nacl_modify_program_headers
6917 #undef elf_backend_final_write_processing
6918 #define elf_backend_final_write_processing nacl_final_write_processing
6920 #include "elf64-target.h"
6922 /* Native Client x32 support. */
6925 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
6927 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
6928 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
6932 #undef TARGET_LITTLE_SYM
6933 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
6934 #undef TARGET_LITTLE_NAME
6935 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
6937 #define elf32_bed elf32_x86_64_nacl_bed
6939 #define bfd_elf32_bfd_link_hash_table_create \
6940 elf_x86_64_link_hash_table_create
6941 #define bfd_elf32_bfd_reloc_type_lookup \
6942 elf_x86_64_reloc_type_lookup
6943 #define bfd_elf32_bfd_reloc_name_lookup \
6944 elf_x86_64_reloc_name_lookup
6945 #define bfd_elf32_mkobject \
6947 #define bfd_elf32_get_synthetic_symtab \
6948 elf_x86_64_get_synthetic_symtab
6950 #undef elf_backend_object_p
6951 #define elf_backend_object_p \
6952 elf32_x86_64_nacl_elf_object_p
6954 #undef elf_backend_bfd_from_remote_memory
6955 #define elf_backend_bfd_from_remote_memory \
6956 _bfd_elf32_bfd_from_remote_memory
6958 #undef elf_backend_size_info
6959 #define elf_backend_size_info \
6960 _bfd_elf32_size_info
6962 #include "elf32-target.h"
6964 /* Restore defaults. */
6965 #undef elf_backend_object_p
6966 #define elf_backend_object_p elf64_x86_64_elf_object_p
6967 #undef elf_backend_bfd_from_remote_memory
6968 #undef elf_backend_size_info
6969 #undef elf_backend_modify_segment_map
6970 #undef elf_backend_modify_program_headers
6971 #undef elf_backend_final_write_processing
6973 /* Intel L1OM support. */
6976 elf64_l1om_elf_object_p (bfd
*abfd
)
6978 /* Set the right machine number for an L1OM elf64 file. */
6979 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
6983 #undef TARGET_LITTLE_SYM
6984 #define TARGET_LITTLE_SYM l1om_elf64_vec
6985 #undef TARGET_LITTLE_NAME
6986 #define TARGET_LITTLE_NAME "elf64-l1om"
6988 #define ELF_ARCH bfd_arch_l1om
6990 #undef ELF_MACHINE_CODE
6991 #define ELF_MACHINE_CODE EM_L1OM
6996 #define elf64_bed elf64_l1om_bed
6998 #undef elf_backend_object_p
6999 #define elf_backend_object_p elf64_l1om_elf_object_p
7001 /* Restore defaults. */
7002 #undef ELF_MAXPAGESIZE
7003 #undef ELF_MINPAGESIZE
7004 #undef ELF_COMMONPAGESIZE
7005 #define ELF_MAXPAGESIZE 0x200000
7006 #define ELF_MINPAGESIZE 0x1000
7007 #define ELF_COMMONPAGESIZE 0x1000
7008 #undef elf_backend_plt_alignment
7009 #define elf_backend_plt_alignment 4
7010 #undef elf_backend_arch_data
7011 #define elf_backend_arch_data &elf_x86_64_arch_bed
7013 #include "elf64-target.h"
7015 /* FreeBSD L1OM support. */
7017 #undef TARGET_LITTLE_SYM
7018 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
7019 #undef TARGET_LITTLE_NAME
7020 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
7023 #define ELF_OSABI ELFOSABI_FREEBSD
7026 #define elf64_bed elf64_l1om_fbsd_bed
7028 #include "elf64-target.h"
7030 /* Intel K1OM support. */
7033 elf64_k1om_elf_object_p (bfd
*abfd
)
7035 /* Set the right machine number for an K1OM elf64 file. */
7036 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
7040 #undef TARGET_LITTLE_SYM
7041 #define TARGET_LITTLE_SYM k1om_elf64_vec
7042 #undef TARGET_LITTLE_NAME
7043 #define TARGET_LITTLE_NAME "elf64-k1om"
7045 #define ELF_ARCH bfd_arch_k1om
7047 #undef ELF_MACHINE_CODE
7048 #define ELF_MACHINE_CODE EM_K1OM
7053 #define elf64_bed elf64_k1om_bed
7055 #undef elf_backend_object_p
7056 #define elf_backend_object_p elf64_k1om_elf_object_p
7058 #undef elf_backend_static_tls_alignment
7060 #undef elf_backend_want_plt_sym
7061 #define elf_backend_want_plt_sym 0
7063 #include "elf64-target.h"
7065 /* FreeBSD K1OM support. */
7067 #undef TARGET_LITTLE_SYM
7068 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
7069 #undef TARGET_LITTLE_NAME
7070 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
7073 #define ELF_OSABI ELFOSABI_FREEBSD
7076 #define elf64_bed elf64_k1om_fbsd_bed
7078 #include "elf64-target.h"
7080 /* 32bit x86-64 support. */
7082 #undef TARGET_LITTLE_SYM
7083 #define TARGET_LITTLE_SYM x86_64_elf32_vec
7084 #undef TARGET_LITTLE_NAME
7085 #define TARGET_LITTLE_NAME "elf32-x86-64"
7089 #define ELF_ARCH bfd_arch_i386
7091 #undef ELF_MACHINE_CODE
7092 #define ELF_MACHINE_CODE EM_X86_64
7096 #undef elf_backend_object_p
7097 #define elf_backend_object_p \
7098 elf32_x86_64_elf_object_p
7100 #undef elf_backend_bfd_from_remote_memory
7101 #define elf_backend_bfd_from_remote_memory \
7102 _bfd_elf32_bfd_from_remote_memory
7104 #undef elf_backend_size_info
7105 #define elf_backend_size_info \
7106 _bfd_elf32_size_info
7108 #include "elf32-target.h"