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))
1166 /* Align .got section to its entry size. */
1167 if (htab
->elf
.sgot
!= NULL
1168 && !bfd_set_section_alignment (dynobj
, htab
->elf
.sgot
, 3))
1171 /* Align .got.plt section to its entry size. */
1172 if (htab
->elf
.sgotplt
!= NULL
1173 && !bfd_set_section_alignment (dynobj
, htab
->elf
.sgotplt
, 3))
1179 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1182 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
1183 struct elf_link_hash_entry
*dir
,
1184 struct elf_link_hash_entry
*ind
)
1186 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
1188 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
1189 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
1191 if (!edir
->has_bnd_reloc
)
1192 edir
->has_bnd_reloc
= eind
->has_bnd_reloc
;
1194 if (!edir
->has_got_reloc
)
1195 edir
->has_got_reloc
= eind
->has_got_reloc
;
1197 if (!edir
->has_non_got_reloc
)
1198 edir
->has_non_got_reloc
= eind
->has_non_got_reloc
;
1200 if (eind
->dyn_relocs
!= NULL
)
1202 if (edir
->dyn_relocs
!= NULL
)
1204 struct elf_dyn_relocs
**pp
;
1205 struct elf_dyn_relocs
*p
;
1207 /* Add reloc counts against the indirect sym to the direct sym
1208 list. Merge any entries against the same section. */
1209 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1211 struct elf_dyn_relocs
*q
;
1213 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1214 if (q
->sec
== p
->sec
)
1216 q
->pc_count
+= p
->pc_count
;
1217 q
->count
+= p
->count
;
1224 *pp
= edir
->dyn_relocs
;
1227 edir
->dyn_relocs
= eind
->dyn_relocs
;
1228 eind
->dyn_relocs
= NULL
;
1231 if (ind
->root
.type
== bfd_link_hash_indirect
1232 && dir
->got
.refcount
<= 0)
1234 edir
->tls_type
= eind
->tls_type
;
1235 eind
->tls_type
= GOT_UNKNOWN
;
1238 if (ELIMINATE_COPY_RELOCS
1239 && ind
->root
.type
!= bfd_link_hash_indirect
1240 && dir
->dynamic_adjusted
)
1242 /* If called to transfer flags for a weakdef during processing
1243 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1244 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1245 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1246 dir
->ref_regular
|= ind
->ref_regular
;
1247 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1248 dir
->needs_plt
|= ind
->needs_plt
;
1249 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1253 if (eind
->func_pointer_refcount
> 0)
1255 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1256 eind
->func_pointer_refcount
= 0;
1259 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1264 elf64_x86_64_elf_object_p (bfd
*abfd
)
1266 /* Set the right machine number for an x86-64 elf64 file. */
1267 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
1272 elf32_x86_64_elf_object_p (bfd
*abfd
)
1274 /* Set the right machine number for an x86-64 elf32 file. */
1275 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
1279 /* Return TRUE if the TLS access code sequence support transition
1283 elf_x86_64_check_tls_transition (bfd
*abfd
,
1284 struct bfd_link_info
*info
,
1287 Elf_Internal_Shdr
*symtab_hdr
,
1288 struct elf_link_hash_entry
**sym_hashes
,
1289 unsigned int r_type
,
1290 const Elf_Internal_Rela
*rel
,
1291 const Elf_Internal_Rela
*relend
)
1294 unsigned long r_symndx
;
1295 bfd_boolean largepic
= FALSE
;
1296 struct elf_link_hash_entry
*h
;
1298 struct elf_x86_64_link_hash_table
*htab
;
1300 bfd_boolean indirect_call
, tls_get_addr
;
1302 htab
= elf_x86_64_hash_table (info
);
1303 offset
= rel
->r_offset
;
1306 case R_X86_64_TLSGD
:
1307 case R_X86_64_TLSLD
:
1308 if ((rel
+ 1) >= relend
)
1311 if (r_type
== R_X86_64_TLSGD
)
1313 /* Check transition from GD access model. For 64bit, only
1314 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1315 .word 0x6666; rex64; call __tls_get_addr@PLT
1317 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1319 call *__tls_get_addr@GOTPCREL(%rip)
1320 which may be converted to
1321 addr32 call __tls_get_addr
1322 can transit to different access model. For 32bit, only
1323 leaq foo@tlsgd(%rip), %rdi
1324 .word 0x6666; rex64; call __tls_get_addr@PLT
1326 leaq foo@tlsgd(%rip), %rdi
1328 call *__tls_get_addr@GOTPCREL(%rip)
1329 which may be converted to
1330 addr32 call __tls_get_addr
1331 can transit to different access model. For largepic,
1333 leaq foo@tlsgd(%rip), %rdi
1334 movabsq $__tls_get_addr@pltoff, %rax
1338 leaq foo@tlsgd(%rip), %rdi
1339 movabsq $__tls_get_addr@pltoff, %rax
1343 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1345 if ((offset
+ 12) > sec
->size
)
1348 call
= contents
+ offset
+ 4;
1350 || !((call
[1] == 0x48
1358 && call
[3] == 0xe8)))
1360 if (!ABI_64_P (abfd
)
1361 || (offset
+ 19) > sec
->size
1363 || memcmp (call
- 7, leaq
+ 1, 3) != 0
1364 || memcmp (call
, "\x48\xb8", 2) != 0
1368 || !((call
[10] == 0x48 && call
[12] == 0xd8)
1369 || (call
[10] == 0x4c && call
[12] == 0xf8)))
1373 else if (ABI_64_P (abfd
))
1376 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1382 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1385 indirect_call
= call
[2] == 0xff;
1389 /* Check transition from LD access model. Only
1390 leaq foo@tlsld(%rip), %rdi;
1391 call __tls_get_addr@PLT
1393 leaq foo@tlsld(%rip), %rdi;
1394 call *__tls_get_addr@GOTPCREL(%rip)
1395 which may be converted to
1396 addr32 call __tls_get_addr
1397 can transit to different access model. For largepic
1399 leaq foo@tlsld(%rip), %rdi
1400 movabsq $__tls_get_addr@pltoff, %rax
1404 leaq foo@tlsld(%rip), %rdi
1405 movabsq $__tls_get_addr@pltoff, %rax
1409 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1411 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1414 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0)
1417 call
= contents
+ offset
+ 4;
1418 if (!(call
[0] == 0xe8
1419 || (call
[0] == 0xff && call
[1] == 0x15)
1420 || (call
[0] == 0x67 && call
[1] == 0xe8)))
1422 if (!ABI_64_P (abfd
)
1423 || (offset
+ 19) > sec
->size
1424 || memcmp (call
, "\x48\xb8", 2) != 0
1428 || !((call
[10] == 0x48 && call
[12] == 0xd8)
1429 || (call
[10] == 0x4c && call
[12] == 0xf8)))
1433 indirect_call
= call
[0] == 0xff;
1436 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1437 if (r_symndx
< symtab_hdr
->sh_info
)
1440 tls_get_addr
= FALSE
;
1441 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1442 if (h
!= NULL
&& h
->root
.root
.string
!= NULL
)
1444 struct elf_x86_64_link_hash_entry
*eh
1445 = (struct elf_x86_64_link_hash_entry
*) h
;
1446 tls_get_addr
= eh
->tls_get_addr
== 1;
1447 if (eh
->tls_get_addr
> 1)
1449 /* Use strncmp to check __tls_get_addr since
1450 __tls_get_addr may be versioned. */
1451 if (strncmp (h
->root
.root
.string
, "__tls_get_addr", 14)
1454 eh
->tls_get_addr
= 1;
1455 tls_get_addr
= TRUE
;
1458 eh
->tls_get_addr
= 0;
1465 return ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLTOFF64
;
1466 else if (indirect_call
)
1467 return ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_GOTPCRELX
;
1469 return (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1470 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
);
1472 case R_X86_64_GOTTPOFF
:
1473 /* Check transition from IE access model:
1474 mov foo@gottpoff(%rip), %reg
1475 add foo@gottpoff(%rip), %reg
1478 /* Check REX prefix first. */
1479 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1481 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1482 if (val
!= 0x48 && val
!= 0x4c)
1484 /* X32 may have 0x44 REX prefix or no REX prefix. */
1485 if (ABI_64_P (abfd
))
1491 /* X32 may not have any REX prefix. */
1492 if (ABI_64_P (abfd
))
1494 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1498 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1499 if (val
!= 0x8b && val
!= 0x03)
1502 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1503 return (val
& 0xc7) == 5;
1505 case R_X86_64_GOTPC32_TLSDESC
:
1506 /* Check transition from GDesc access model:
1507 leaq x@tlsdesc(%rip), %rax
1509 Make sure it's a leaq adding rip to a 32-bit offset
1510 into any register, although it's probably almost always
1513 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1516 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1517 if ((val
& 0xfb) != 0x48)
1520 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1523 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1524 return (val
& 0xc7) == 0x05;
1526 case R_X86_64_TLSDESC_CALL
:
1527 /* Check transition from GDesc access model:
1528 call *x@tlsdesc(%rax)
1530 if (offset
+ 2 <= sec
->size
)
1532 /* Make sure that it's a call *x@tlsdesc(%rax). */
1533 call
= contents
+ offset
;
1534 return call
[0] == 0xff && call
[1] == 0x10;
1544 /* Return TRUE if the TLS access transition is OK or no transition
1545 will be performed. Update R_TYPE if there is a transition. */
1548 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1549 asection
*sec
, bfd_byte
*contents
,
1550 Elf_Internal_Shdr
*symtab_hdr
,
1551 struct elf_link_hash_entry
**sym_hashes
,
1552 unsigned int *r_type
, int tls_type
,
1553 const Elf_Internal_Rela
*rel
,
1554 const Elf_Internal_Rela
*relend
,
1555 struct elf_link_hash_entry
*h
,
1556 unsigned long r_symndx
,
1557 bfd_boolean from_relocate_section
)
1559 unsigned int from_type
= *r_type
;
1560 unsigned int to_type
= from_type
;
1561 bfd_boolean check
= TRUE
;
1563 /* Skip TLS transition for functions. */
1565 && (h
->type
== STT_FUNC
1566 || h
->type
== STT_GNU_IFUNC
))
1571 case R_X86_64_TLSGD
:
1572 case R_X86_64_GOTPC32_TLSDESC
:
1573 case R_X86_64_TLSDESC_CALL
:
1574 case R_X86_64_GOTTPOFF
:
1575 if (bfd_link_executable (info
))
1578 to_type
= R_X86_64_TPOFF32
;
1580 to_type
= R_X86_64_GOTTPOFF
;
1583 /* When we are called from elf_x86_64_relocate_section, there may
1584 be additional transitions based on TLS_TYPE. */
1585 if (from_relocate_section
)
1587 unsigned int new_to_type
= to_type
;
1589 if (bfd_link_executable (info
)
1592 && tls_type
== GOT_TLS_IE
)
1593 new_to_type
= R_X86_64_TPOFF32
;
1595 if (to_type
== R_X86_64_TLSGD
1596 || to_type
== R_X86_64_GOTPC32_TLSDESC
1597 || to_type
== R_X86_64_TLSDESC_CALL
)
1599 if (tls_type
== GOT_TLS_IE
)
1600 new_to_type
= R_X86_64_GOTTPOFF
;
1603 /* We checked the transition before when we were called from
1604 elf_x86_64_check_relocs. We only want to check the new
1605 transition which hasn't been checked before. */
1606 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1607 to_type
= new_to_type
;
1612 case R_X86_64_TLSLD
:
1613 if (bfd_link_executable (info
))
1614 to_type
= R_X86_64_TPOFF32
;
1621 /* Return TRUE if there is no transition. */
1622 if (from_type
== to_type
)
1625 /* Check if the transition can be performed. */
1627 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1628 symtab_hdr
, sym_hashes
,
1629 from_type
, rel
, relend
))
1631 reloc_howto_type
*from
, *to
;
1634 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1635 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1638 name
= h
->root
.root
.string
;
1641 struct elf_x86_64_link_hash_table
*htab
;
1643 htab
= elf_x86_64_hash_table (info
);
1648 Elf_Internal_Sym
*isym
;
1650 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1652 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1656 (*_bfd_error_handler
)
1657 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1658 "in section `%A' failed"),
1659 abfd
, sec
, from
->name
, to
->name
, name
,
1660 (unsigned long) rel
->r_offset
);
1661 bfd_set_error (bfd_error_bad_value
);
1669 /* Rename some of the generic section flags to better document how they
1671 #define need_convert_load sec_flg0
1672 #define check_relocs_failed sec_flg1
1675 elf_x86_64_need_pic (bfd
*input_bfd
, asection
*sec
,
1676 struct elf_link_hash_entry
*h
,
1677 Elf_Internal_Shdr
*symtab_hdr
,
1678 Elf_Internal_Sym
*isym
,
1679 reloc_howto_type
*howto
)
1682 const char *und
= "";
1683 const char *pic
= "";
1688 name
= h
->root
.root
.string
;
1689 switch (ELF_ST_VISIBILITY (h
->other
))
1692 v
= _("hidden symbol ");
1695 v
= _("internal symbol ");
1698 v
= _("protected symbol ");
1702 pic
= _("; recompile with -fPIC");
1706 if (!h
->def_regular
&& !h
->def_dynamic
)
1707 und
= _("undefined ");
1711 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, isym
, NULL
);
1712 pic
= _("; recompile with -fPIC");
1715 (*_bfd_error_handler
) (_("%B: relocation %s against %s%s`%s' can "
1716 "not be used when making a shared object%s"),
1717 input_bfd
, howto
->name
, und
, v
, name
, pic
);
1718 bfd_set_error (bfd_error_bad_value
);
1719 sec
->check_relocs_failed
= 1;
1723 /* With the local symbol, foo, we convert
1724 mov foo@GOTPCREL(%rip), %reg
1728 call/jmp *foo@GOTPCREL(%rip)
1730 nop call foo/jmp foo nop
1731 When PIC is false, convert
1732 test %reg, foo@GOTPCREL(%rip)
1736 binop foo@GOTPCREL(%rip), %reg
1739 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1743 elf_x86_64_convert_load_reloc (bfd
*abfd
, asection
*sec
,
1745 Elf_Internal_Rela
*irel
,
1746 struct elf_link_hash_entry
*h
,
1747 bfd_boolean
*converted
,
1748 struct bfd_link_info
*link_info
)
1750 struct elf_x86_64_link_hash_table
*htab
;
1752 bfd_boolean require_reloc_pc32
;
1754 bfd_boolean to_reloc_pc32
;
1757 bfd_signed_vma raddend
;
1758 unsigned int opcode
;
1760 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
1761 unsigned int r_symndx
;
1763 bfd_vma roff
= irel
->r_offset
;
1765 if (roff
< (r_type
== R_X86_64_REX_GOTPCRELX
? 3 : 2))
1768 raddend
= irel
->r_addend
;
1769 /* Addend for 32-bit PC-relative relocation must be -4. */
1773 htab
= elf_x86_64_hash_table (link_info
);
1774 is_pic
= bfd_link_pic (link_info
);
1776 relocx
= (r_type
== R_X86_64_GOTPCRELX
1777 || r_type
== R_X86_64_REX_GOTPCRELX
);
1779 /* TRUE if we can convert only to R_X86_64_PC32. Enable it for
1782 = link_info
->disable_target_specific_optimizations
> 1;
1784 r_symndx
= htab
->r_sym (irel
->r_info
);
1786 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
1788 /* Convert mov to lea since it has been done for a while. */
1791 /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
1792 for call, jmp or one of adc, add, and, cmp, or, sbb, sub,
1793 test, xor instructions. */
1798 /* We convert only to R_X86_64_PC32:
1800 2. R_X86_64_GOTPCREL since we can't modify REX byte.
1801 3. require_reloc_pc32 is true.
1804 to_reloc_pc32
= (opcode
== 0xff
1806 || require_reloc_pc32
1809 /* Get the symbol referred to by the reloc. */
1812 Elf_Internal_Sym
*isym
1813 = bfd_sym_from_r_symndx (&htab
->sym_cache
, abfd
, r_symndx
);
1815 /* Skip relocation against undefined symbols. */
1816 if (isym
->st_shndx
== SHN_UNDEF
)
1819 symtype
= ELF_ST_TYPE (isym
->st_info
);
1821 if (isym
->st_shndx
== SHN_ABS
)
1822 tsec
= bfd_abs_section_ptr
;
1823 else if (isym
->st_shndx
== SHN_COMMON
)
1824 tsec
= bfd_com_section_ptr
;
1825 else if (isym
->st_shndx
== SHN_X86_64_LCOMMON
)
1826 tsec
= &_bfd_elf_large_com_section
;
1828 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1830 toff
= isym
->st_value
;
1834 /* Undefined weak symbol is only bound locally in executable
1835 and its reference is resolved as 0 without relocation
1836 overflow. We can only perform this optimization for
1837 GOTPCRELX relocations since we need to modify REX byte.
1838 It is OK convert mov with R_X86_64_GOTPCREL to
1840 if ((relocx
|| opcode
== 0x8b)
1841 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
,
1843 elf_x86_64_hash_entry (h
)))
1847 /* Skip for branch instructions since R_X86_64_PC32
1849 if (require_reloc_pc32
)
1854 /* For non-branch instructions, we can convert to
1855 R_X86_64_32/R_X86_64_32S since we know if there
1857 to_reloc_pc32
= FALSE
;
1860 /* Since we don't know the current PC when PIC is true,
1861 we can't convert to R_X86_64_PC32. */
1862 if (to_reloc_pc32
&& is_pic
)
1867 /* Avoid optimizing GOTPCREL relocations againt _DYNAMIC since
1868 ld.so may use its link-time address. */
1869 else if ((h
->def_regular
1870 || h
->root
.type
== bfd_link_hash_defined
1871 || h
->root
.type
== bfd_link_hash_defweak
)
1872 && h
!= htab
->elf
.hdynamic
1873 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
1875 /* bfd_link_hash_new or bfd_link_hash_undefined is
1876 set by an assignment in a linker script in
1877 bfd_elf_record_link_assignment. */
1879 && (h
->root
.type
== bfd_link_hash_new
1880 || h
->root
.type
== bfd_link_hash_undefined
))
1882 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */
1883 if (require_reloc_pc32
)
1887 tsec
= h
->root
.u
.def
.section
;
1888 toff
= h
->root
.u
.def
.value
;
1895 /* Don't convert GOTPCREL relocation against large section. */
1896 if (elf_section_data (tsec
) != NULL
1897 && (elf_section_flags (tsec
) & SHF_X86_64_LARGE
) != 0)
1900 /* We can only estimate relocation overflow for R_X86_64_PC32. */
1904 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
1906 /* At this stage in linking, no SEC_MERGE symbol has been
1907 adjusted, so all references to such symbols need to be
1908 passed through _bfd_merged_section_offset. (Later, in
1909 relocate_section, all SEC_MERGE symbols *except* for
1910 section symbols have been adjusted.)
1912 gas may reduce relocations against symbols in SEC_MERGE
1913 sections to a relocation against the section symbol when
1914 the original addend was zero. When the reloc is against
1915 a section symbol we should include the addend in the
1916 offset passed to _bfd_merged_section_offset, since the
1917 location of interest is the original symbol. On the
1918 other hand, an access to "sym+addend" where "sym" is not
1919 a section symbol should not include the addend; Such an
1920 access is presumed to be an offset from "sym"; The
1921 location of interest is just "sym". */
1922 if (symtype
== STT_SECTION
)
1925 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
1926 elf_section_data (tsec
)->sec_info
,
1929 if (symtype
!= STT_SECTION
)
1935 /* Don't convert if R_X86_64_PC32 relocation overflows. */
1936 if (tsec
->output_section
== sec
->output_section
)
1938 if ((toff
- roff
+ 0x80000000) > 0xffffffff)
1943 bfd_signed_vma distance
;
1945 /* At this point, we don't know the load addresses of TSEC
1946 section nor SEC section. We estimate the distrance between
1947 SEC and TSEC. We store the estimated distances in the
1948 compressed_size field of the output section, which is only
1949 used to decompress the compressed input section. */
1950 if (sec
->output_section
->compressed_size
== 0)
1953 bfd_size_type size
= 0;
1954 for (asect
= link_info
->output_bfd
->sections
;
1956 asect
= asect
->next
)
1957 /* Skip debug sections since compressed_size is used to
1958 compress debug sections. */
1959 if ((asect
->flags
& SEC_DEBUGGING
) == 0)
1962 for (i
= asect
->map_head
.s
;
1966 size
= align_power (size
, i
->alignment_power
);
1969 asect
->compressed_size
= size
;
1973 /* Don't convert GOTPCREL relocations if TSEC isn't placed
1975 distance
= (tsec
->output_section
->compressed_size
1976 - sec
->output_section
->compressed_size
);
1980 /* Take PT_GNU_RELRO segment into account by adding
1982 if ((toff
+ distance
+ get_elf_backend_data (abfd
)->maxpagesize
1983 - roff
+ 0x80000000) > 0xffffffff)
1990 /* We have "call/jmp *foo@GOTPCREL(%rip)". */
1995 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
1997 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2000 /* Convert to "jmp foo nop". */
2003 nop_offset
= irel
->r_offset
+ 3;
2004 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
2005 irel
->r_offset
-= 1;
2006 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
2010 struct elf_x86_64_link_hash_entry
*eh
2011 = (struct elf_x86_64_link_hash_entry
*) h
;
2013 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
2016 /* To support TLS optimization, always use addr32 prefix for
2017 "call *__tls_get_addr@GOTPCREL(%rip)". */
2018 if (eh
&& eh
->tls_get_addr
== 1)
2021 nop_offset
= irel
->r_offset
- 2;
2025 nop
= link_info
->call_nop_byte
;
2026 if (link_info
->call_nop_as_suffix
)
2028 nop_offset
= irel
->r_offset
+ 3;
2029 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
2030 irel
->r_offset
-= 1;
2031 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
2034 nop_offset
= irel
->r_offset
- 2;
2037 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
2038 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
2039 r_type
= R_X86_64_PC32
;
2044 unsigned int rex_mask
= REX_R
;
2046 if (r_type
== R_X86_64_REX_GOTPCRELX
)
2047 rex
= bfd_get_8 (abfd
, contents
+ roff
- 3);
2055 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
2056 "lea foo(%rip), %reg". */
2058 r_type
= R_X86_64_PC32
;
2062 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
2063 "mov $foo, %reg". */
2065 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2066 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
2067 if ((rex
& REX_W
) != 0
2068 && ABI_64_P (link_info
->output_bfd
))
2070 /* Keep the REX_W bit in REX byte for LP64. */
2071 r_type
= R_X86_64_32S
;
2072 goto rewrite_modrm_rex
;
2076 /* If the REX_W bit in REX byte isn't needed,
2077 use R_X86_64_32 and clear the W bit to avoid
2078 sign-extend imm32 to imm64. */
2079 r_type
= R_X86_64_32
;
2080 /* Clear the W bit in REX byte. */
2082 goto rewrite_modrm_rex
;
2088 /* R_X86_64_PC32 isn't supported. */
2092 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2095 /* Convert "test %reg, foo@GOTPCREL(%rip)" to
2096 "test $foo, %reg". */
2097 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
2102 /* Convert "binop foo@GOTPCREL(%rip), %reg" to
2103 "binop $foo, %reg". */
2104 modrm
= 0xc0 | (modrm
& 0x38) >> 3 | (opcode
& 0x3c);
2108 /* Use R_X86_64_32 with 32-bit operand to avoid relocation
2109 overflow when sign-extending imm32 to imm64. */
2110 r_type
= (rex
& REX_W
) != 0 ? R_X86_64_32S
: R_X86_64_32
;
2113 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
2117 /* Move the R bit to the B bit in REX byte. */
2118 rex
= (rex
& ~rex_mask
) | (rex
& REX_R
) >> 2;
2119 bfd_put_8 (abfd
, rex
, contents
+ roff
- 3);
2122 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */
2126 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
2129 irel
->r_info
= htab
->r_info (r_symndx
, r_type
);
2136 /* Look through the relocs for a section during the first phase, and
2137 calculate needed space in the global offset table, procedure
2138 linkage table, and dynamic reloc sections. */
2141 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
2143 const Elf_Internal_Rela
*relocs
)
2145 struct elf_x86_64_link_hash_table
*htab
;
2146 Elf_Internal_Shdr
*symtab_hdr
;
2147 struct elf_link_hash_entry
**sym_hashes
;
2148 const Elf_Internal_Rela
*rel
;
2149 const Elf_Internal_Rela
*rel_end
;
2152 bfd_boolean use_plt_got
;
2154 if (bfd_link_relocatable (info
))
2157 /* Don't do anything special with non-loaded, non-alloced sections.
2158 In particular, any relocs in such sections should not affect GOT
2159 and PLT reference counting (ie. we don't allow them to create GOT
2160 or PLT entries), there's no possibility or desire to optimize TLS
2161 relocs, and there's not much point in propagating relocs to shared
2162 libs that the dynamic linker won't relocate. */
2163 if ((sec
->flags
& SEC_ALLOC
) == 0)
2166 BFD_ASSERT (is_x86_64_elf (abfd
));
2168 htab
= elf_x86_64_hash_table (info
);
2171 sec
->check_relocs_failed
= 1;
2175 /* Get the section contents. */
2176 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2177 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2178 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2180 sec
->check_relocs_failed
= 1;
2184 use_plt_got
= get_elf_x86_64_backend_data (abfd
) == &elf_x86_64_arch_bed
;
2186 symtab_hdr
= &elf_symtab_hdr (abfd
);
2187 sym_hashes
= elf_sym_hashes (abfd
);
2191 rel_end
= relocs
+ sec
->reloc_count
;
2192 for (rel
= relocs
; rel
< rel_end
; rel
++)
2194 unsigned int r_type
;
2195 unsigned long r_symndx
;
2196 struct elf_link_hash_entry
*h
;
2197 struct elf_x86_64_link_hash_entry
*eh
;
2198 Elf_Internal_Sym
*isym
;
2200 bfd_boolean size_reloc
;
2202 r_symndx
= htab
->r_sym (rel
->r_info
);
2203 r_type
= ELF32_R_TYPE (rel
->r_info
);
2205 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
2207 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
2212 if (r_symndx
< symtab_hdr
->sh_info
)
2214 /* A local symbol. */
2215 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2220 /* Check relocation against local STT_GNU_IFUNC symbol. */
2221 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
2223 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
2228 /* Fake a STT_GNU_IFUNC symbol. */
2229 h
->type
= STT_GNU_IFUNC
;
2232 h
->forced_local
= 1;
2233 h
->root
.type
= bfd_link_hash_defined
;
2241 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2242 while (h
->root
.type
== bfd_link_hash_indirect
2243 || h
->root
.type
== bfd_link_hash_warning
)
2244 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2247 /* Check invalid x32 relocations. */
2248 if (!ABI_64_P (abfd
))
2254 case R_X86_64_DTPOFF64
:
2255 case R_X86_64_TPOFF64
:
2257 case R_X86_64_GOTOFF64
:
2258 case R_X86_64_GOT64
:
2259 case R_X86_64_GOTPCREL64
:
2260 case R_X86_64_GOTPC64
:
2261 case R_X86_64_GOTPLT64
:
2262 case R_X86_64_PLTOFF64
:
2265 name
= h
->root
.root
.string
;
2267 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
2269 (*_bfd_error_handler
)
2270 (_("%B: relocation %s against symbol `%s' isn't "
2271 "supported in x32 mode"), abfd
,
2272 x86_64_elf_howto_table
[r_type
].name
, name
);
2273 bfd_set_error (bfd_error_bad_value
);
2286 case R_X86_64_PC32_BND
:
2287 case R_X86_64_PLT32_BND
:
2289 case R_X86_64_PLT32
:
2292 /* MPX PLT is supported only if elf_x86_64_arch_bed
2293 is used in 64-bit mode. */
2296 && (get_elf_x86_64_backend_data (abfd
)
2297 == &elf_x86_64_arch_bed
))
2299 elf_x86_64_hash_entry (h
)->has_bnd_reloc
= 1;
2301 /* Create the second PLT for Intel MPX support. */
2302 if (htab
->plt_bnd
== NULL
)
2304 unsigned int plt_bnd_align
;
2305 const struct elf_backend_data
*bed
;
2307 bed
= get_elf_backend_data (info
->output_bfd
);
2308 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry
) == 8
2309 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2310 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2313 if (htab
->elf
.dynobj
== NULL
)
2314 htab
->elf
.dynobj
= abfd
;
2316 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2318 (bed
->dynamic_sec_flags
2323 if (htab
->plt_bnd
== NULL
2324 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2333 case R_X86_64_GOTPCREL
:
2334 case R_X86_64_GOTPCRELX
:
2335 case R_X86_64_REX_GOTPCRELX
:
2336 case R_X86_64_GOTPCREL64
:
2337 if (htab
->elf
.dynobj
== NULL
)
2338 htab
->elf
.dynobj
= abfd
;
2339 /* Create the ifunc sections for static executables. */
2340 if (h
->type
== STT_GNU_IFUNC
2341 && !_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
,
2347 /* It is referenced by a non-shared object. */
2349 h
->root
.non_ir_ref
= 1;
2351 if (h
->type
== STT_GNU_IFUNC
)
2352 elf_tdata (info
->output_bfd
)->has_gnu_symbols
2353 |= elf_gnu_symbol_ifunc
;
2356 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, contents
,
2357 symtab_hdr
, sym_hashes
,
2358 &r_type
, GOT_UNKNOWN
,
2359 rel
, rel_end
, h
, r_symndx
, FALSE
))
2362 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2365 case R_X86_64_TLSLD
:
2366 htab
->tls_ld_got
.refcount
+= 1;
2369 case R_X86_64_TPOFF32
:
2370 if (!bfd_link_executable (info
) && ABI_64_P (abfd
))
2371 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
2372 &x86_64_elf_howto_table
[r_type
]);
2374 eh
->has_got_reloc
= 1;
2377 case R_X86_64_GOTTPOFF
:
2378 if (!bfd_link_executable (info
))
2379 info
->flags
|= DF_STATIC_TLS
;
2382 case R_X86_64_GOT32
:
2383 case R_X86_64_GOTPCREL
:
2384 case R_X86_64_GOTPCRELX
:
2385 case R_X86_64_REX_GOTPCRELX
:
2386 case R_X86_64_TLSGD
:
2387 case R_X86_64_GOT64
:
2388 case R_X86_64_GOTPCREL64
:
2389 case R_X86_64_GOTPLT64
:
2390 case R_X86_64_GOTPC32_TLSDESC
:
2391 case R_X86_64_TLSDESC_CALL
:
2392 /* This symbol requires a global offset table entry. */
2394 int tls_type
, old_tls_type
;
2398 default: tls_type
= GOT_NORMAL
; break;
2399 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
2400 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
2401 case R_X86_64_GOTPC32_TLSDESC
:
2402 case R_X86_64_TLSDESC_CALL
:
2403 tls_type
= GOT_TLS_GDESC
; break;
2408 h
->got
.refcount
+= 1;
2409 old_tls_type
= eh
->tls_type
;
2413 bfd_signed_vma
*local_got_refcounts
;
2415 /* This is a global offset table entry for a local symbol. */
2416 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2417 if (local_got_refcounts
== NULL
)
2421 size
= symtab_hdr
->sh_info
;
2422 size
*= sizeof (bfd_signed_vma
)
2423 + sizeof (bfd_vma
) + sizeof (char);
2424 local_got_refcounts
= ((bfd_signed_vma
*)
2425 bfd_zalloc (abfd
, size
));
2426 if (local_got_refcounts
== NULL
)
2428 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2429 elf_x86_64_local_tlsdesc_gotent (abfd
)
2430 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
2431 elf_x86_64_local_got_tls_type (abfd
)
2432 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
2434 local_got_refcounts
[r_symndx
] += 1;
2436 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
2439 /* If a TLS symbol is accessed using IE at least once,
2440 there is no point to use dynamic model for it. */
2441 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
2442 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
2443 || tls_type
!= GOT_TLS_IE
))
2445 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
2446 tls_type
= old_tls_type
;
2447 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
2448 && GOT_TLS_GD_ANY_P (tls_type
))
2449 tls_type
|= old_tls_type
;
2453 name
= h
->root
.root
.string
;
2455 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
2457 (*_bfd_error_handler
)
2458 (_("%B: '%s' accessed both as normal and thread local symbol"),
2460 bfd_set_error (bfd_error_bad_value
);
2465 if (old_tls_type
!= tls_type
)
2468 eh
->tls_type
= tls_type
;
2470 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
2475 case R_X86_64_GOTOFF64
:
2476 case R_X86_64_GOTPC32
:
2477 case R_X86_64_GOTPC64
:
2480 eh
->has_got_reloc
= 1;
2481 if (htab
->elf
.sgot
== NULL
)
2483 if (htab
->elf
.dynobj
== NULL
)
2484 htab
->elf
.dynobj
= abfd
;
2485 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
2491 case R_X86_64_PLT32
:
2492 case R_X86_64_PLT32_BND
:
2493 /* This symbol requires a procedure linkage table entry. We
2494 actually build the entry in adjust_dynamic_symbol,
2495 because this might be a case of linking PIC code which is
2496 never referenced by a dynamic object, in which case we
2497 don't need to generate a procedure linkage table entry
2500 /* If this is a local symbol, we resolve it directly without
2501 creating a procedure linkage table entry. */
2505 eh
->has_got_reloc
= 1;
2507 h
->plt
.refcount
+= 1;
2510 case R_X86_64_PLTOFF64
:
2511 /* This tries to form the 'address' of a function relative
2512 to GOT. For global symbols we need a PLT entry. */
2516 h
->plt
.refcount
+= 1;
2520 case R_X86_64_SIZE32
:
2521 case R_X86_64_SIZE64
:
2526 if (!ABI_64_P (abfd
))
2531 /* Check relocation overflow as these relocs may lead to
2532 run-time relocation overflow. Don't error out for
2533 sections we don't care about, such as debug sections or
2534 when relocation overflow check is disabled. */
2535 if (!info
->no_reloc_overflow_check
2536 && (bfd_link_pic (info
)
2537 || (bfd_link_executable (info
)
2541 && (sec
->flags
& SEC_READONLY
) == 0)))
2542 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
2543 &x86_64_elf_howto_table
[r_type
]);
2549 case R_X86_64_PC32_BND
:
2553 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2554 eh
->has_non_got_reloc
= 1;
2555 /* We are called after all symbols have been resolved. Only
2556 relocation against STT_GNU_IFUNC symbol must go through
2559 && (bfd_link_executable (info
)
2560 || h
->type
== STT_GNU_IFUNC
))
2562 /* If this reloc is in a read-only section, we might
2563 need a copy reloc. We can't check reliably at this
2564 stage whether the section is read-only, as input
2565 sections have not yet been mapped to output sections.
2566 Tentatively set the flag for now, and correct in
2567 adjust_dynamic_symbol. */
2570 /* We may need a .plt entry if the symbol is a function
2571 defined in a shared lib or is a STT_GNU_IFUNC function
2572 referenced from the code or read-only section. */
2574 || (sec
->flags
& (SEC_CODE
| SEC_READONLY
)) != 0)
2575 h
->plt
.refcount
+= 1;
2577 if (r_type
== R_X86_64_PC32
)
2579 /* Since something like ".long foo - ." may be used
2580 as pointer, make sure that PLT is used if foo is
2581 a function defined in a shared library. */
2582 if ((sec
->flags
& SEC_CODE
) == 0)
2583 h
->pointer_equality_needed
= 1;
2585 else if (r_type
!= R_X86_64_PC32_BND
2586 && r_type
!= R_X86_64_PC64
)
2588 h
->pointer_equality_needed
= 1;
2589 /* At run-time, R_X86_64_64 can be resolved for both
2590 x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2591 can only be resolved for x32. */
2592 if ((sec
->flags
& SEC_READONLY
) == 0
2593 && (r_type
== R_X86_64_64
2594 || (!ABI_64_P (abfd
)
2595 && (r_type
== R_X86_64_32
2596 || r_type
== R_X86_64_32S
))))
2597 eh
->func_pointer_refcount
+= 1;
2603 /* If we are creating a shared library, and this is a reloc
2604 against a global symbol, or a non PC relative reloc
2605 against a local symbol, then we need to copy the reloc
2606 into the shared library. However, if we are linking with
2607 -Bsymbolic, we do not need to copy a reloc against a
2608 global symbol which is defined in an object we are
2609 including in the link (i.e., DEF_REGULAR is set). At
2610 this point we have not seen all the input files, so it is
2611 possible that DEF_REGULAR is not set now but will be set
2612 later (it is never cleared). In case of a weak definition,
2613 DEF_REGULAR may be cleared later by a strong definition in
2614 a shared library. We account for that possibility below by
2615 storing information in the relocs_copied field of the hash
2616 table entry. A similar situation occurs when creating
2617 shared libraries and symbol visibility changes render the
2620 If on the other hand, we are creating an executable, we
2621 may need to keep relocations for symbols satisfied by a
2622 dynamic library if we manage to avoid copy relocs for the
2625 Generate dynamic pointer relocation against STT_GNU_IFUNC
2626 symbol in the non-code section. */
2627 if ((bfd_link_pic (info
)
2628 && (! IS_X86_64_PCREL_TYPE (r_type
)
2630 && (! (bfd_link_pie (info
)
2631 || SYMBOLIC_BIND (info
, h
))
2632 || h
->root
.type
== bfd_link_hash_defweak
2633 || !h
->def_regular
))))
2635 && h
->type
== STT_GNU_IFUNC
2636 && r_type
== htab
->pointer_r_type
2637 && (sec
->flags
& SEC_CODE
) == 0)
2638 || (ELIMINATE_COPY_RELOCS
2639 && !bfd_link_pic (info
)
2641 && (h
->root
.type
== bfd_link_hash_defweak
2642 || !h
->def_regular
)))
2644 struct elf_dyn_relocs
*p
;
2645 struct elf_dyn_relocs
**head
;
2647 /* We must copy these reloc types into the output file.
2648 Create a reloc section in dynobj and make room for
2652 if (htab
->elf
.dynobj
== NULL
)
2653 htab
->elf
.dynobj
= abfd
;
2655 sreloc
= _bfd_elf_make_dynamic_reloc_section
2656 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
2657 abfd
, /*rela?*/ TRUE
);
2663 /* If this is a global symbol, we count the number of
2664 relocations we need for this symbol. */
2666 head
= &eh
->dyn_relocs
;
2669 /* Track dynamic relocs needed for local syms too.
2670 We really need local syms available to do this
2675 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2680 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2684 /* Beware of type punned pointers vs strict aliasing
2686 vpp
= &(elf_section_data (s
)->local_dynrel
);
2687 head
= (struct elf_dyn_relocs
**)vpp
;
2691 if (p
== NULL
|| p
->sec
!= sec
)
2693 bfd_size_type amt
= sizeof *p
;
2695 p
= ((struct elf_dyn_relocs
*)
2696 bfd_alloc (htab
->elf
.dynobj
, amt
));
2707 /* Count size relocation as PC-relative relocation. */
2708 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
2713 /* This relocation describes the C++ object vtable hierarchy.
2714 Reconstruct it for later use during GC. */
2715 case R_X86_64_GNU_VTINHERIT
:
2716 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2720 /* This relocation describes which C++ vtable entries are actually
2721 used. Record for later use during GC. */
2722 case R_X86_64_GNU_VTENTRY
:
2723 BFD_ASSERT (h
!= NULL
);
2725 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2735 && h
->plt
.refcount
> 0
2736 && (((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2737 || h
->got
.refcount
> 0)
2738 && htab
->plt_got
== NULL
)
2740 /* Create the GOT procedure linkage table. */
2741 unsigned int plt_got_align
;
2742 const struct elf_backend_data
*bed
;
2744 bed
= get_elf_backend_data (info
->output_bfd
);
2745 BFD_ASSERT (sizeof (elf_x86_64_legacy_plt2_entry
) == 8
2746 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2747 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2750 if (htab
->elf
.dynobj
== NULL
)
2751 htab
->elf
.dynobj
= abfd
;
2753 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2755 (bed
->dynamic_sec_flags
2760 if (htab
->plt_got
== NULL
2761 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2767 if ((r_type
== R_X86_64_GOTPCREL
2768 || r_type
== R_X86_64_GOTPCRELX
2769 || r_type
== R_X86_64_REX_GOTPCRELX
)
2770 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2771 sec
->need_convert_load
= 1;
2774 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2776 if (!info
->keep_memory
)
2780 /* Cache the section contents for elf_link_input_bfd. */
2781 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2788 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2790 sec
->check_relocs_failed
= 1;
2794 /* Return the section that should be marked against GC for a given
2798 elf_x86_64_gc_mark_hook (asection
*sec
,
2799 struct bfd_link_info
*info
,
2800 Elf_Internal_Rela
*rel
,
2801 struct elf_link_hash_entry
*h
,
2802 Elf_Internal_Sym
*sym
)
2805 switch (ELF32_R_TYPE (rel
->r_info
))
2807 case R_X86_64_GNU_VTINHERIT
:
2808 case R_X86_64_GNU_VTENTRY
:
2812 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2815 /* Remove undefined weak symbol from the dynamic symbol table if it
2816 is resolved to 0. */
2819 elf_x86_64_fixup_symbol (struct bfd_link_info
*info
,
2820 struct elf_link_hash_entry
*h
)
2822 if (h
->dynindx
!= -1
2823 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2824 elf_x86_64_hash_entry (h
)->has_got_reloc
,
2825 elf_x86_64_hash_entry (h
)))
2828 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2834 /* Adjust a symbol defined by a dynamic object and referenced by a
2835 regular object. The current definition is in some section of the
2836 dynamic object, but we're not including those sections. We have to
2837 change the definition to something the rest of the link can
2841 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2842 struct elf_link_hash_entry
*h
)
2844 struct elf_x86_64_link_hash_table
*htab
;
2846 struct elf_x86_64_link_hash_entry
*eh
;
2847 struct elf_dyn_relocs
*p
;
2849 /* STT_GNU_IFUNC symbol must go through PLT. */
2850 if (h
->type
== STT_GNU_IFUNC
)
2852 /* All local STT_GNU_IFUNC references must be treate as local
2853 calls via local PLT. */
2855 && SYMBOL_CALLS_LOCAL (info
, h
))
2857 bfd_size_type pc_count
= 0, count
= 0;
2858 struct elf_dyn_relocs
**pp
;
2860 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2861 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2863 pc_count
+= p
->pc_count
;
2864 p
->count
-= p
->pc_count
;
2873 if (pc_count
|| count
)
2878 /* Increment PLT reference count only for PC-relative
2881 if (h
->plt
.refcount
<= 0)
2882 h
->plt
.refcount
= 1;
2884 h
->plt
.refcount
+= 1;
2889 if (h
->plt
.refcount
<= 0)
2891 h
->plt
.offset
= (bfd_vma
) -1;
2897 /* If this is a function, put it in the procedure linkage table. We
2898 will fill in the contents of the procedure linkage table later,
2899 when we know the address of the .got section. */
2900 if (h
->type
== STT_FUNC
2903 if (h
->plt
.refcount
<= 0
2904 || SYMBOL_CALLS_LOCAL (info
, h
)
2905 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2906 && h
->root
.type
== bfd_link_hash_undefweak
))
2908 /* This case can occur if we saw a PLT32 reloc in an input
2909 file, but the symbol was never referred to by a dynamic
2910 object, or if all references were garbage collected. In
2911 such a case, we don't actually need to build a procedure
2912 linkage table, and we can just do a PC32 reloc instead. */
2913 h
->plt
.offset
= (bfd_vma
) -1;
2920 /* It's possible that we incorrectly decided a .plt reloc was
2921 needed for an R_X86_64_PC32 reloc to a non-function sym in
2922 check_relocs. We can't decide accurately between function and
2923 non-function syms in check-relocs; Objects loaded later in
2924 the link may change h->type. So fix it now. */
2925 h
->plt
.offset
= (bfd_vma
) -1;
2927 /* If this is a weak symbol, and there is a real definition, the
2928 processor independent code will have arranged for us to see the
2929 real definition first, and we can just use the same value. */
2930 if (h
->u
.weakdef
!= NULL
)
2932 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2933 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2934 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2935 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2936 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2938 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2939 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2940 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
2945 /* This is a reference to a symbol defined by a dynamic object which
2946 is not a function. */
2948 /* If we are creating a shared library, we must presume that the
2949 only references to the symbol are via the global offset table.
2950 For such cases we need not do anything here; the relocations will
2951 be handled correctly by relocate_section. */
2952 if (!bfd_link_executable (info
))
2955 /* If there are no references to this symbol that do not use the
2956 GOT, we don't need to generate a copy reloc. */
2957 if (!h
->non_got_ref
)
2960 /* If -z nocopyreloc was given, we won't generate them either. */
2961 if (info
->nocopyreloc
)
2967 if (ELIMINATE_COPY_RELOCS
)
2969 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2970 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2972 s
= p
->sec
->output_section
;
2973 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2977 /* If we didn't find any dynamic relocs in read-only sections, then
2978 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2986 /* We must allocate the symbol in our .dynbss section, which will
2987 become part of the .bss section of the executable. There will be
2988 an entry for this symbol in the .dynsym section. The dynamic
2989 object will contain position independent code, so all references
2990 from the dynamic object to this symbol will go through the global
2991 offset table. The dynamic linker will use the .dynsym entry to
2992 determine the address it must put in the global offset table, so
2993 both the dynamic object and the regular object will refer to the
2994 same memory location for the variable. */
2996 htab
= elf_x86_64_hash_table (info
);
3000 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
3001 to copy the initial value out of the dynamic object and into the
3002 runtime process image. */
3003 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
3005 const struct elf_backend_data
*bed
;
3006 bed
= get_elf_backend_data (info
->output_bfd
);
3007 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
3013 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
3016 /* Allocate space in .plt, .got and associated reloc sections for
3020 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
3022 struct bfd_link_info
*info
;
3023 struct elf_x86_64_link_hash_table
*htab
;
3024 struct elf_x86_64_link_hash_entry
*eh
;
3025 struct elf_dyn_relocs
*p
;
3026 const struct elf_backend_data
*bed
;
3027 unsigned int plt_entry_size
;
3028 bfd_boolean resolved_to_zero
;
3030 if (h
->root
.type
== bfd_link_hash_indirect
)
3033 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3035 info
= (struct bfd_link_info
*) inf
;
3036 htab
= elf_x86_64_hash_table (info
);
3039 bed
= get_elf_backend_data (info
->output_bfd
);
3040 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
3042 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
3046 /* We can't use the GOT PLT if pointer equality is needed since
3047 finish_dynamic_symbol won't clear symbol value and the dynamic
3048 linker won't update the GOT slot. We will get into an infinite
3049 loop at run-time. */
3050 if (htab
->plt_got
!= NULL
3051 && h
->type
!= STT_GNU_IFUNC
3052 && !h
->pointer_equality_needed
3053 && h
->plt
.refcount
> 0
3054 && h
->got
.refcount
> 0)
3056 /* Don't use the regular PLT if there are both GOT and GOTPLT
3058 h
->plt
.offset
= (bfd_vma
) -1;
3060 /* Use the GOT PLT. */
3061 eh
->plt_got
.refcount
= 1;
3064 /* Clear the reference count of function pointer relocations if
3065 symbol isn't a normal function. */
3066 if (h
->type
!= STT_FUNC
)
3067 eh
->func_pointer_refcount
= 0;
3069 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
3070 here if it is defined and referenced in a non-shared object. */
3071 if (h
->type
== STT_GNU_IFUNC
3074 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
3076 &htab
->readonly_dynrelocs_against_ifunc
,
3079 GOT_ENTRY_SIZE
, TRUE
))
3081 asection
*s
= htab
->plt_bnd
;
3082 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
3084 /* Use the .plt.bnd section if it is created. */
3085 eh
->plt_bnd
.offset
= s
->size
;
3087 /* Make room for this entry in the .plt.bnd section. */
3088 s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
3096 /* Don't create the PLT entry if there are only function pointer
3097 relocations which can be resolved at run-time. */
3098 else if (htab
->elf
.dynamic_sections_created
3099 && (h
->plt
.refcount
> eh
->func_pointer_refcount
3100 || eh
->plt_got
.refcount
> 0))
3102 bfd_boolean use_plt_got
;
3104 /* Clear the reference count of function pointer relocations
3106 eh
->func_pointer_refcount
= 0;
3108 if ((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
3110 /* Don't use the regular PLT for DF_BIND_NOW. */
3111 h
->plt
.offset
= (bfd_vma
) -1;
3113 /* Use the GOT PLT. */
3114 h
->got
.refcount
= 1;
3115 eh
->plt_got
.refcount
= 1;
3118 use_plt_got
= eh
->plt_got
.refcount
> 0;
3120 /* Make sure this symbol is output as a dynamic symbol.
3121 Undefined weak syms won't yet be marked as dynamic. */
3122 if (h
->dynindx
== -1
3124 && !resolved_to_zero
)
3126 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3130 if (bfd_link_pic (info
)
3131 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
3133 asection
*s
= htab
->elf
.splt
;
3134 asection
*bnd_s
= htab
->plt_bnd
;
3135 asection
*got_s
= htab
->plt_got
;
3137 /* If this is the first .plt entry, make room for the special
3138 first entry. The .plt section is used by prelink to undo
3139 prelinking for dynamic relocations. */
3141 s
->size
= plt_entry_size
;
3144 eh
->plt_got
.offset
= got_s
->size
;
3147 h
->plt
.offset
= s
->size
;
3149 eh
->plt_bnd
.offset
= bnd_s
->size
;
3152 /* If this symbol is not defined in a regular file, and we are
3153 not generating a shared library, then set the symbol to this
3154 location in the .plt. This is required to make function
3155 pointers compare as equal between the normal executable and
3156 the shared library. */
3157 if (! bfd_link_pic (info
)
3162 /* We need to make a call to the entry of the GOT PLT
3163 instead of regular PLT entry. */
3164 h
->root
.u
.def
.section
= got_s
;
3165 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
3171 /* We need to make a call to the entry of the second
3172 PLT instead of regular PLT entry. */
3173 h
->root
.u
.def
.section
= bnd_s
;
3174 h
->root
.u
.def
.value
= eh
->plt_bnd
.offset
;
3178 h
->root
.u
.def
.section
= s
;
3179 h
->root
.u
.def
.value
= h
->plt
.offset
;
3184 /* Make room for this entry. */
3186 got_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
3189 s
->size
+= plt_entry_size
;
3191 bnd_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
3193 /* We also need to make an entry in the .got.plt section,
3194 which will be placed in the .got section by the linker
3196 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
3198 /* There should be no PLT relocation against resolved
3199 undefined weak symbol in executable. */
3200 if (!resolved_to_zero
)
3202 /* We also need to make an entry in the .rela.plt
3204 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
3205 htab
->elf
.srelplt
->reloc_count
++;
3211 eh
->plt_got
.offset
= (bfd_vma
) -1;
3212 h
->plt
.offset
= (bfd_vma
) -1;
3218 eh
->plt_got
.offset
= (bfd_vma
) -1;
3219 h
->plt
.offset
= (bfd_vma
) -1;
3223 eh
->tlsdesc_got
= (bfd_vma
) -1;
3225 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
3226 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
3227 if (h
->got
.refcount
> 0
3228 && bfd_link_executable (info
)
3230 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
3232 h
->got
.offset
= (bfd_vma
) -1;
3234 else if (h
->got
.refcount
> 0)
3238 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
3240 /* Make sure this symbol is output as a dynamic symbol.
3241 Undefined weak syms won't yet be marked as dynamic. */
3242 if (h
->dynindx
== -1
3244 && !resolved_to_zero
)
3246 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3250 if (GOT_TLS_GDESC_P (tls_type
))
3252 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
3253 - elf_x86_64_compute_jump_table_size (htab
);
3254 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3255 h
->got
.offset
= (bfd_vma
) -2;
3257 if (! GOT_TLS_GDESC_P (tls_type
)
3258 || GOT_TLS_GD_P (tls_type
))
3261 h
->got
.offset
= s
->size
;
3262 s
->size
+= GOT_ENTRY_SIZE
;
3263 if (GOT_TLS_GD_P (tls_type
))
3264 s
->size
+= GOT_ENTRY_SIZE
;
3266 dyn
= htab
->elf
.dynamic_sections_created
;
3267 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
3268 and two if global. R_X86_64_GOTTPOFF needs one dynamic
3269 relocation. No dynamic relocation against resolved undefined
3270 weak symbol in executable. */
3271 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
3272 || tls_type
== GOT_TLS_IE
)
3273 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3274 else if (GOT_TLS_GD_P (tls_type
))
3275 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
3276 else if (! GOT_TLS_GDESC_P (tls_type
)
3277 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3278 && !resolved_to_zero
)
3279 || h
->root
.type
!= bfd_link_hash_undefweak
)
3280 && (bfd_link_pic (info
)
3281 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
3282 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3283 if (GOT_TLS_GDESC_P (tls_type
))
3285 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
3286 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3290 h
->got
.offset
= (bfd_vma
) -1;
3292 if (eh
->dyn_relocs
== NULL
)
3295 /* In the shared -Bsymbolic case, discard space allocated for
3296 dynamic pc-relative relocs against symbols which turn out to be
3297 defined in regular objects. For the normal shared case, discard
3298 space for pc-relative relocs that have become local due to symbol
3299 visibility changes. */
3301 if (bfd_link_pic (info
))
3303 /* Relocs that use pc_count are those that appear on a call
3304 insn, or certain REL relocs that can generated via assembly.
3305 We want calls to protected symbols to resolve directly to the
3306 function rather than going via the plt. If people want
3307 function pointer comparisons to work as expected then they
3308 should avoid writing weird assembly. */
3309 if (SYMBOL_CALLS_LOCAL (info
, h
))
3311 struct elf_dyn_relocs
**pp
;
3313 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3315 p
->count
-= p
->pc_count
;
3324 /* Also discard relocs on undefined weak syms with non-default
3325 visibility or in PIE. */
3326 if (eh
->dyn_relocs
!= NULL
)
3328 if (h
->root
.type
== bfd_link_hash_undefweak
)
3330 /* Undefined weak symbol is never bound locally in shared
3332 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3333 || resolved_to_zero
)
3334 eh
->dyn_relocs
= NULL
;
3335 else if (h
->dynindx
== -1
3336 && ! h
->forced_local
3337 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3340 /* For PIE, discard space for pc-relative relocs against
3341 symbols which turn out to need copy relocs. */
3342 else if (bfd_link_executable (info
)
3343 && (h
->needs_copy
|| eh
->needs_copy
)
3347 struct elf_dyn_relocs
**pp
;
3349 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3351 if (p
->pc_count
!= 0)
3359 else if (ELIMINATE_COPY_RELOCS
)
3361 /* For the non-shared case, discard space for relocs against
3362 symbols which turn out to need copy relocs or are not
3363 dynamic. Keep dynamic relocations for run-time function
3364 pointer initialization. */
3366 if ((!h
->non_got_ref
3367 || eh
->func_pointer_refcount
> 0
3368 || (h
->root
.type
== bfd_link_hash_undefweak
3369 && !resolved_to_zero
))
3372 || (htab
->elf
.dynamic_sections_created
3373 && (h
->root
.type
== bfd_link_hash_undefweak
3374 || h
->root
.type
== bfd_link_hash_undefined
))))
3376 /* Make sure this symbol is output as a dynamic symbol.
3377 Undefined weak syms won't yet be marked as dynamic. */
3378 if (h
->dynindx
== -1
3379 && ! h
->forced_local
3380 && ! resolved_to_zero
3381 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3384 /* If that succeeded, we know we'll be keeping all the
3386 if (h
->dynindx
!= -1)
3390 eh
->dyn_relocs
= NULL
;
3391 eh
->func_pointer_refcount
= 0;
3396 /* Finally, allocate space. */
3397 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3401 sreloc
= elf_section_data (p
->sec
)->sreloc
;
3403 BFD_ASSERT (sreloc
!= NULL
);
3405 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3411 /* Allocate space in .plt, .got and associated reloc sections for
3412 local dynamic relocs. */
3415 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
3417 struct elf_link_hash_entry
*h
3418 = (struct elf_link_hash_entry
*) *slot
;
3420 if (h
->type
!= STT_GNU_IFUNC
3424 || h
->root
.type
!= bfd_link_hash_defined
)
3427 return elf_x86_64_allocate_dynrelocs (h
, inf
);
3430 /* Find any dynamic relocs that apply to read-only sections. */
3433 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
3436 struct elf_x86_64_link_hash_entry
*eh
;
3437 struct elf_dyn_relocs
*p
;
3439 /* Skip local IFUNC symbols. */
3440 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
3443 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3444 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3446 asection
*s
= p
->sec
->output_section
;
3448 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
3450 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3452 info
->flags
|= DF_TEXTREL
;
3454 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3455 || info
->error_textrel
)
3456 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
3457 p
->sec
->owner
, h
->root
.root
.string
,
3460 /* Not an error, just cut short the traversal. */
3467 /* Convert load via the GOT slot to load immediate. */
3470 elf_x86_64_convert_load (bfd
*abfd
, asection
*sec
,
3471 struct bfd_link_info
*link_info
)
3473 Elf_Internal_Shdr
*symtab_hdr
;
3474 Elf_Internal_Rela
*internal_relocs
;
3475 Elf_Internal_Rela
*irel
, *irelend
;
3477 struct elf_x86_64_link_hash_table
*htab
;
3478 bfd_boolean changed
;
3479 bfd_signed_vma
*local_got_refcounts
;
3481 /* Don't even try to convert non-ELF outputs. */
3482 if (!is_elf_hash_table (link_info
->hash
))
3485 /* Nothing to do if there is no need or no output. */
3486 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
3487 || sec
->need_convert_load
== 0
3488 || bfd_is_abs_section (sec
->output_section
))
3491 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3493 /* Load the relocations for this section. */
3494 internal_relocs
= (_bfd_elf_link_read_relocs
3495 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
3496 link_info
->keep_memory
));
3497 if (internal_relocs
== NULL
)
3501 htab
= elf_x86_64_hash_table (link_info
);
3502 local_got_refcounts
= elf_local_got_refcounts (abfd
);
3504 /* Get the section contents. */
3505 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
3506 contents
= elf_section_data (sec
)->this_hdr
.contents
;
3509 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
3513 irelend
= internal_relocs
+ sec
->reloc_count
;
3514 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3516 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
3517 unsigned int r_symndx
;
3518 struct elf_link_hash_entry
*h
;
3519 bfd_boolean converted
;
3521 if (r_type
!= R_X86_64_GOTPCRELX
3522 && r_type
!= R_X86_64_REX_GOTPCRELX
3523 && r_type
!= R_X86_64_GOTPCREL
)
3526 r_symndx
= htab
->r_sym (irel
->r_info
);
3527 if (r_symndx
< symtab_hdr
->sh_info
)
3528 h
= elf_x86_64_get_local_sym_hash (htab
, sec
->owner
,
3529 (const Elf_Internal_Rela
*) irel
,
3533 h
= elf_sym_hashes (abfd
)[r_symndx
- symtab_hdr
->sh_info
];
3534 while (h
->root
.type
== bfd_link_hash_indirect
3535 || h
->root
.type
== bfd_link_hash_warning
)
3536 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3539 /* STT_GNU_IFUNC must keep GOTPCREL relocations. */
3540 if (h
!= NULL
&& h
->type
== STT_GNU_IFUNC
)
3544 if (!elf_x86_64_convert_load_reloc (abfd
, sec
, contents
, irel
, h
,
3545 &converted
, link_info
))
3550 changed
= converted
;
3553 if (h
->got
.refcount
> 0)
3554 h
->got
.refcount
-= 1;
3558 if (local_got_refcounts
!= NULL
3559 && local_got_refcounts
[r_symndx
] > 0)
3560 local_got_refcounts
[r_symndx
] -= 1;
3565 if (contents
!= NULL
3566 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3568 if (!changed
&& !link_info
->keep_memory
)
3572 /* Cache the section contents for elf_link_input_bfd. */
3573 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3577 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3580 free (internal_relocs
);
3582 elf_section_data (sec
)->relocs
= internal_relocs
;
3588 if (contents
!= NULL
3589 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3591 if (internal_relocs
!= NULL
3592 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3593 free (internal_relocs
);
3597 /* Set the sizes of the dynamic sections. */
3600 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
3601 struct bfd_link_info
*info
)
3603 struct elf_x86_64_link_hash_table
*htab
;
3608 const struct elf_backend_data
*bed
;
3610 htab
= elf_x86_64_hash_table (info
);
3613 bed
= get_elf_backend_data (output_bfd
);
3615 dynobj
= htab
->elf
.dynobj
;
3619 /* Set up .got offsets for local syms, and space for local dynamic
3621 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3623 bfd_signed_vma
*local_got
;
3624 bfd_signed_vma
*end_local_got
;
3625 char *local_tls_type
;
3626 bfd_vma
*local_tlsdesc_gotent
;
3627 bfd_size_type locsymcount
;
3628 Elf_Internal_Shdr
*symtab_hdr
;
3631 if (! is_x86_64_elf (ibfd
))
3634 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3636 struct elf_dyn_relocs
*p
;
3638 if (!elf_x86_64_convert_load (ibfd
, s
, info
))
3641 for (p
= (struct elf_dyn_relocs
*)
3642 (elf_section_data (s
)->local_dynrel
);
3646 if (!bfd_is_abs_section (p
->sec
)
3647 && bfd_is_abs_section (p
->sec
->output_section
))
3649 /* Input section has been discarded, either because
3650 it is a copy of a linkonce section or due to
3651 linker script /DISCARD/, so we'll be discarding
3654 else if (p
->count
!= 0)
3656 srel
= elf_section_data (p
->sec
)->sreloc
;
3657 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3658 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3659 && (info
->flags
& DF_TEXTREL
) == 0)
3661 info
->flags
|= DF_TEXTREL
;
3662 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3663 || info
->error_textrel
)
3664 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3665 p
->sec
->owner
, p
->sec
);
3671 local_got
= elf_local_got_refcounts (ibfd
);
3675 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3676 locsymcount
= symtab_hdr
->sh_info
;
3677 end_local_got
= local_got
+ locsymcount
;
3678 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
3679 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
3681 srel
= htab
->elf
.srelgot
;
3682 for (; local_got
< end_local_got
;
3683 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3685 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3688 if (GOT_TLS_GDESC_P (*local_tls_type
))
3690 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3691 - elf_x86_64_compute_jump_table_size (htab
);
3692 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3693 *local_got
= (bfd_vma
) -2;
3695 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3696 || GOT_TLS_GD_P (*local_tls_type
))
3698 *local_got
= s
->size
;
3699 s
->size
+= GOT_ENTRY_SIZE
;
3700 if (GOT_TLS_GD_P (*local_tls_type
))
3701 s
->size
+= GOT_ENTRY_SIZE
;
3703 if (bfd_link_pic (info
)
3704 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3705 || *local_tls_type
== GOT_TLS_IE
)
3707 if (GOT_TLS_GDESC_P (*local_tls_type
))
3709 htab
->elf
.srelplt
->size
3710 += bed
->s
->sizeof_rela
;
3711 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3713 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3714 || GOT_TLS_GD_P (*local_tls_type
))
3715 srel
->size
+= bed
->s
->sizeof_rela
;
3719 *local_got
= (bfd_vma
) -1;
3723 if (htab
->tls_ld_got
.refcount
> 0)
3725 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3727 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
3728 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
3729 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3732 htab
->tls_ld_got
.offset
= -1;
3734 /* Allocate global sym .plt and .got entries, and space for global
3735 sym dynamic relocs. */
3736 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
3739 /* Allocate .plt and .got entries, and space for local symbols. */
3740 htab_traverse (htab
->loc_hash_table
,
3741 elf_x86_64_allocate_local_dynrelocs
,
3744 /* For every jump slot reserved in the sgotplt, reloc_count is
3745 incremented. However, when we reserve space for TLS descriptors,
3746 it's not incremented, so in order to compute the space reserved
3747 for them, it suffices to multiply the reloc count by the jump
3750 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3751 so that R_X86_64_IRELATIVE entries come last. */
3752 if (htab
->elf
.srelplt
)
3754 htab
->sgotplt_jump_table_size
3755 = elf_x86_64_compute_jump_table_size (htab
);
3756 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3758 else if (htab
->elf
.irelplt
)
3759 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3761 if (htab
->tlsdesc_plt
)
3763 /* If we're not using lazy TLS relocations, don't generate the
3764 PLT and GOT entries they require. */
3765 if ((info
->flags
& DF_BIND_NOW
))
3766 htab
->tlsdesc_plt
= 0;
3769 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
3770 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
3771 /* Reserve room for the initial entry.
3772 FIXME: we could probably do away with it in this case. */
3773 if (htab
->elf
.splt
->size
== 0)
3774 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3775 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
3776 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3780 if (htab
->elf
.sgotplt
)
3782 /* Don't allocate .got.plt section if there are no GOT nor PLT
3783 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3784 if ((htab
->elf
.hgot
== NULL
3785 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3786 && (htab
->elf
.sgotplt
->size
3787 == get_elf_backend_data (output_bfd
)->got_header_size
)
3788 && (htab
->elf
.splt
== NULL
3789 || htab
->elf
.splt
->size
== 0)
3790 && (htab
->elf
.sgot
== NULL
3791 || htab
->elf
.sgot
->size
== 0)
3792 && (htab
->elf
.iplt
== NULL
3793 || htab
->elf
.iplt
->size
== 0)
3794 && (htab
->elf
.igotplt
== NULL
3795 || htab
->elf
.igotplt
->size
== 0))
3796 htab
->elf
.sgotplt
->size
= 0;
3799 if (htab
->plt_eh_frame
!= NULL
3800 && htab
->elf
.splt
!= NULL
3801 && htab
->elf
.splt
->size
!= 0
3802 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3803 && _bfd_elf_eh_frame_present (info
))
3805 const struct elf_x86_64_backend_data
*arch_data
3806 = get_elf_x86_64_arch_data (bed
);
3807 htab
->plt_eh_frame
->size
= arch_data
->eh_frame_plt_size
;
3810 /* We now have determined the sizes of the various dynamic sections.
3811 Allocate memory for them. */
3813 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3815 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3818 if (s
== htab
->elf
.splt
3819 || s
== htab
->elf
.sgot
3820 || s
== htab
->elf
.sgotplt
3821 || s
== htab
->elf
.iplt
3822 || s
== htab
->elf
.igotplt
3823 || s
== htab
->plt_bnd
3824 || s
== htab
->plt_got
3825 || s
== htab
->plt_eh_frame
3826 || s
== htab
->sdynbss
)
3828 /* Strip this section if we don't need it; see the
3831 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3833 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
3836 /* We use the reloc_count field as a counter if we need
3837 to copy relocs into the output file. */
3838 if (s
!= htab
->elf
.srelplt
)
3843 /* It's not one of our sections, so don't allocate space. */
3849 /* If we don't need this section, strip it from the
3850 output file. This is mostly to handle .rela.bss and
3851 .rela.plt. We must create both sections in
3852 create_dynamic_sections, because they must be created
3853 before the linker maps input sections to output
3854 sections. The linker does that before
3855 adjust_dynamic_symbol is called, and it is that
3856 function which decides whether anything needs to go
3857 into these sections. */
3859 s
->flags
|= SEC_EXCLUDE
;
3863 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3866 /* Allocate memory for the section contents. We use bfd_zalloc
3867 here in case unused entries are not reclaimed before the
3868 section's contents are written out. This should not happen,
3869 but this way if it does, we get a R_X86_64_NONE reloc instead
3871 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3872 if (s
->contents
== NULL
)
3876 if (htab
->plt_eh_frame
!= NULL
3877 && htab
->plt_eh_frame
->contents
!= NULL
)
3879 const struct elf_x86_64_backend_data
*arch_data
3880 = get_elf_x86_64_arch_data (bed
);
3882 memcpy (htab
->plt_eh_frame
->contents
,
3883 arch_data
->eh_frame_plt
, htab
->plt_eh_frame
->size
);
3884 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3885 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3888 if (htab
->elf
.dynamic_sections_created
)
3890 /* Add some entries to the .dynamic section. We fill in the
3891 values later, in elf_x86_64_finish_dynamic_sections, but we
3892 must add the entries now so that we get the correct size for
3893 the .dynamic section. The DT_DEBUG entry is filled in by the
3894 dynamic linker and used by the debugger. */
3895 #define add_dynamic_entry(TAG, VAL) \
3896 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3898 if (bfd_link_executable (info
))
3900 if (!add_dynamic_entry (DT_DEBUG
, 0))
3904 if (htab
->elf
.splt
->size
!= 0)
3906 /* DT_PLTGOT is used by prelink even if there is no PLT
3908 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3911 if (htab
->elf
.srelplt
->size
!= 0)
3913 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3914 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3915 || !add_dynamic_entry (DT_JMPREL
, 0))
3919 if (htab
->tlsdesc_plt
3920 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3921 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3927 if (!add_dynamic_entry (DT_RELA
, 0)
3928 || !add_dynamic_entry (DT_RELASZ
, 0)
3929 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3932 /* If any dynamic relocs apply to a read-only section,
3933 then we need a DT_TEXTREL entry. */
3934 if ((info
->flags
& DF_TEXTREL
) == 0)
3935 elf_link_hash_traverse (&htab
->elf
,
3936 elf_x86_64_readonly_dynrelocs
,
3939 if ((info
->flags
& DF_TEXTREL
) != 0)
3941 if (htab
->readonly_dynrelocs_against_ifunc
)
3943 info
->callbacks
->einfo
3944 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3945 bfd_set_error (bfd_error_bad_value
);
3949 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3954 #undef add_dynamic_entry
3960 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3961 struct bfd_link_info
*info
)
3963 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3967 struct elf_link_hash_entry
*tlsbase
;
3969 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3970 "_TLS_MODULE_BASE_",
3971 FALSE
, FALSE
, FALSE
);
3973 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3975 struct elf_x86_64_link_hash_table
*htab
;
3976 struct bfd_link_hash_entry
*bh
= NULL
;
3977 const struct elf_backend_data
*bed
3978 = get_elf_backend_data (output_bfd
);
3980 htab
= elf_x86_64_hash_table (info
);
3984 if (!(_bfd_generic_link_add_one_symbol
3985 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3986 tls_sec
, 0, NULL
, FALSE
,
3987 bed
->collect
, &bh
)))
3990 htab
->tls_module_base
= bh
;
3992 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3993 tlsbase
->def_regular
= 1;
3994 tlsbase
->other
= STV_HIDDEN
;
3995 tlsbase
->root
.linker_def
= 1;
3996 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
4003 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
4004 executables. Rather than setting it to the beginning of the TLS
4005 section, we have to set it to the end. This function may be called
4006 multiple times, it is idempotent. */
4009 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
4011 struct elf_x86_64_link_hash_table
*htab
;
4012 struct bfd_link_hash_entry
*base
;
4014 if (!bfd_link_executable (info
))
4017 htab
= elf_x86_64_hash_table (info
);
4021 base
= htab
->tls_module_base
;
4025 base
->u
.def
.value
= htab
->elf
.tls_size
;
4028 /* Return the base VMA address which should be subtracted from real addresses
4029 when resolving @dtpoff relocation.
4030 This is PT_TLS segment p_vaddr. */
4033 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
4035 /* If tls_sec is NULL, we should have signalled an error already. */
4036 if (elf_hash_table (info
)->tls_sec
== NULL
)
4038 return elf_hash_table (info
)->tls_sec
->vma
;
4041 /* Return the relocation value for @tpoff relocation
4042 if STT_TLS virtual address is ADDRESS. */
4045 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
4047 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
4048 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
4049 bfd_vma static_tls_size
;
4051 /* If tls_segment is NULL, we should have signalled an error already. */
4052 if (htab
->tls_sec
== NULL
)
4055 /* Consider special static TLS alignment requirements. */
4056 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
4057 return address
- static_tls_size
- htab
->tls_sec
->vma
;
4060 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
4064 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
4066 /* Opcode Instruction
4069 0x0f 0x8x conditional jump */
4071 && (contents
[offset
- 1] == 0xe8
4072 || contents
[offset
- 1] == 0xe9))
4074 && contents
[offset
- 2] == 0x0f
4075 && (contents
[offset
- 1] & 0xf0) == 0x80));
4078 /* Relocate an x86_64 ELF section. */
4081 elf_x86_64_relocate_section (bfd
*output_bfd
,
4082 struct bfd_link_info
*info
,
4084 asection
*input_section
,
4086 Elf_Internal_Rela
*relocs
,
4087 Elf_Internal_Sym
*local_syms
,
4088 asection
**local_sections
)
4090 struct elf_x86_64_link_hash_table
*htab
;
4091 Elf_Internal_Shdr
*symtab_hdr
;
4092 struct elf_link_hash_entry
**sym_hashes
;
4093 bfd_vma
*local_got_offsets
;
4094 bfd_vma
*local_tlsdesc_gotents
;
4095 Elf_Internal_Rela
*rel
;
4096 Elf_Internal_Rela
*wrel
;
4097 Elf_Internal_Rela
*relend
;
4098 const unsigned int plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
4100 BFD_ASSERT (is_x86_64_elf (input_bfd
));
4102 /* Skip if check_relocs failed. */
4103 if (input_section
->check_relocs_failed
)
4106 htab
= elf_x86_64_hash_table (info
);
4109 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
4110 sym_hashes
= elf_sym_hashes (input_bfd
);
4111 local_got_offsets
= elf_local_got_offsets (input_bfd
);
4112 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
4114 elf_x86_64_set_tls_module_base (info
);
4116 rel
= wrel
= relocs
;
4117 relend
= relocs
+ input_section
->reloc_count
;
4118 for (; rel
< relend
; wrel
++, rel
++)
4120 unsigned int r_type
;
4121 reloc_howto_type
*howto
;
4122 unsigned long r_symndx
;
4123 struct elf_link_hash_entry
*h
;
4124 struct elf_x86_64_link_hash_entry
*eh
;
4125 Elf_Internal_Sym
*sym
;
4127 bfd_vma off
, offplt
, plt_offset
;
4129 bfd_boolean unresolved_reloc
;
4130 bfd_reloc_status_type r
;
4132 asection
*base_got
, *resolved_plt
;
4134 bfd_boolean resolved_to_zero
;
4136 r_type
= ELF32_R_TYPE (rel
->r_info
);
4137 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
4138 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
4145 if (r_type
>= (int) R_X86_64_standard
)
4147 (*_bfd_error_handler
)
4148 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
4149 input_bfd
, input_section
, r_type
);
4150 bfd_set_error (bfd_error_bad_value
);
4154 if (r_type
!= (int) R_X86_64_32
4155 || ABI_64_P (output_bfd
))
4156 howto
= x86_64_elf_howto_table
+ r_type
;
4158 howto
= (x86_64_elf_howto_table
4159 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
4160 r_symndx
= htab
->r_sym (rel
->r_info
);
4164 unresolved_reloc
= FALSE
;
4165 if (r_symndx
< symtab_hdr
->sh_info
)
4167 sym
= local_syms
+ r_symndx
;
4168 sec
= local_sections
[r_symndx
];
4170 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
4172 st_size
= sym
->st_size
;
4174 /* Relocate against local STT_GNU_IFUNC symbol. */
4175 if (!bfd_link_relocatable (info
)
4176 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
4178 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
4183 /* Set STT_GNU_IFUNC symbol value. */
4184 h
->root
.u
.def
.value
= sym
->st_value
;
4185 h
->root
.u
.def
.section
= sec
;
4190 bfd_boolean warned ATTRIBUTE_UNUSED
;
4191 bfd_boolean ignored ATTRIBUTE_UNUSED
;
4193 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
4194 r_symndx
, symtab_hdr
, sym_hashes
,
4196 unresolved_reloc
, warned
, ignored
);
4200 if (sec
!= NULL
&& discarded_section (sec
))
4202 _bfd_clear_contents (howto
, input_bfd
, input_section
,
4203 contents
+ rel
->r_offset
);
4204 wrel
->r_offset
= rel
->r_offset
;
4208 /* For ld -r, remove relocations in debug sections against
4209 sections defined in discarded sections. Not done for
4210 eh_frame editing code expects to be present. */
4211 if (bfd_link_relocatable (info
)
4212 && (input_section
->flags
& SEC_DEBUGGING
))
4218 if (bfd_link_relocatable (info
))
4225 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
4227 if (r_type
== R_X86_64_64
)
4229 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
4230 zero-extend it to 64bit if addend is zero. */
4231 r_type
= R_X86_64_32
;
4232 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4234 else if (r_type
== R_X86_64_SIZE64
)
4236 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
4237 zero-extend it to 64bit if addend is zero. */
4238 r_type
= R_X86_64_SIZE32
;
4239 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4243 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
4245 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
4246 it here if it is defined in a non-shared object. */
4248 && h
->type
== STT_GNU_IFUNC
4254 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4256 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4257 sections because such sections are not SEC_ALLOC and
4258 thus ld.so will not process them. */
4259 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
4269 case R_X86_64_GOTPCREL
:
4270 case R_X86_64_GOTPCRELX
:
4271 case R_X86_64_REX_GOTPCRELX
:
4272 case R_X86_64_GOTPCREL64
:
4273 base_got
= htab
->elf
.sgot
;
4274 off
= h
->got
.offset
;
4276 if (base_got
== NULL
)
4279 if (off
== (bfd_vma
) -1)
4281 /* We can't use h->got.offset here to save state, or
4282 even just remember the offset, as finish_dynamic_symbol
4283 would use that as offset into .got. */
4285 if (h
->plt
.offset
== (bfd_vma
) -1)
4288 if (htab
->elf
.splt
!= NULL
)
4290 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4291 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4292 base_got
= htab
->elf
.sgotplt
;
4296 plt_index
= h
->plt
.offset
/ plt_entry_size
;
4297 off
= plt_index
* GOT_ENTRY_SIZE
;
4298 base_got
= htab
->elf
.igotplt
;
4301 if (h
->dynindx
== -1
4305 /* This references the local defitionion. We must
4306 initialize this entry in the global offset table.
4307 Since the offset must always be a multiple of 8,
4308 we use the least significant bit to record
4309 whether we have initialized it already.
4311 When doing a dynamic link, we create a .rela.got
4312 relocation entry to initialize the value. This
4313 is done in the finish_dynamic_symbol routine. */
4318 bfd_put_64 (output_bfd
, relocation
,
4319 base_got
->contents
+ off
);
4320 /* Note that this is harmless for the GOTPLT64
4321 case, as -1 | 1 still is -1. */
4327 relocation
= (base_got
->output_section
->vma
4328 + base_got
->output_offset
+ off
);
4333 if (h
->plt
.offset
== (bfd_vma
) -1)
4335 /* Handle static pointers of STT_GNU_IFUNC symbols. */
4336 if (r_type
== htab
->pointer_r_type
4337 && (input_section
->flags
& SEC_CODE
) == 0)
4338 goto do_ifunc_pointer
;
4339 goto bad_ifunc_reloc
;
4342 /* STT_GNU_IFUNC symbol must go through PLT. */
4343 if (htab
->elf
.splt
!= NULL
)
4345 if (htab
->plt_bnd
!= NULL
)
4347 resolved_plt
= htab
->plt_bnd
;
4348 plt_offset
= eh
->plt_bnd
.offset
;
4352 resolved_plt
= htab
->elf
.splt
;
4353 plt_offset
= h
->plt
.offset
;
4358 resolved_plt
= htab
->elf
.iplt
;
4359 plt_offset
= h
->plt
.offset
;
4362 relocation
= (resolved_plt
->output_section
->vma
4363 + resolved_plt
->output_offset
+ plt_offset
);
4369 if (h
->root
.root
.string
)
4370 name
= h
->root
.root
.string
;
4372 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4374 (*_bfd_error_handler
)
4375 (_("%B: relocation %s against STT_GNU_IFUNC "
4376 "symbol `%s' isn't supported"), input_bfd
,
4378 bfd_set_error (bfd_error_bad_value
);
4382 if (bfd_link_pic (info
))
4387 if (ABI_64_P (output_bfd
))
4392 if (rel
->r_addend
!= 0)
4394 if (h
->root
.root
.string
)
4395 name
= h
->root
.root
.string
;
4397 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4399 (*_bfd_error_handler
)
4400 (_("%B: relocation %s against STT_GNU_IFUNC "
4401 "symbol `%s' has non-zero addend: %d"),
4402 input_bfd
, howto
->name
, name
, rel
->r_addend
);
4403 bfd_set_error (bfd_error_bad_value
);
4407 /* Generate dynamic relcoation only when there is a
4408 non-GOT reference in a shared object or there is no
4410 if ((bfd_link_pic (info
) && h
->non_got_ref
)
4411 || h
->plt
.offset
== (bfd_vma
) -1)
4413 Elf_Internal_Rela outrel
;
4416 /* Need a dynamic relocation to get the real function
4418 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
4422 if (outrel
.r_offset
== (bfd_vma
) -1
4423 || outrel
.r_offset
== (bfd_vma
) -2)
4426 outrel
.r_offset
+= (input_section
->output_section
->vma
4427 + input_section
->output_offset
);
4429 if (h
->dynindx
== -1
4431 || bfd_link_executable (info
))
4433 /* This symbol is resolved locally. */
4434 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4435 outrel
.r_addend
= (h
->root
.u
.def
.value
4436 + h
->root
.u
.def
.section
->output_section
->vma
4437 + h
->root
.u
.def
.section
->output_offset
);
4441 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4442 outrel
.r_addend
= 0;
4445 /* Dynamic relocations are stored in
4446 1. .rela.ifunc section in PIC object.
4447 2. .rela.got section in dynamic executable.
4448 3. .rela.iplt section in static executable. */
4449 if (bfd_link_pic (info
))
4450 sreloc
= htab
->elf
.irelifunc
;
4451 else if (htab
->elf
.splt
!= NULL
)
4452 sreloc
= htab
->elf
.srelgot
;
4454 sreloc
= htab
->elf
.irelplt
;
4455 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4457 /* If this reloc is against an external symbol, we
4458 do not want to fiddle with the addend. Otherwise,
4459 we need to include the symbol value so that it
4460 becomes an addend for the dynamic reloc. For an
4461 internal symbol, we have updated addend. */
4466 case R_X86_64_PC32_BND
:
4468 case R_X86_64_PLT32
:
4469 case R_X86_64_PLT32_BND
:
4474 resolved_to_zero
= (eh
!= NULL
4475 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
4479 /* When generating a shared object, the relocations handled here are
4480 copied into the output file to be resolved at run time. */
4483 case R_X86_64_GOT32
:
4484 case R_X86_64_GOT64
:
4485 /* Relocation is to the entry for this symbol in the global
4487 case R_X86_64_GOTPCREL
:
4488 case R_X86_64_GOTPCRELX
:
4489 case R_X86_64_REX_GOTPCRELX
:
4490 case R_X86_64_GOTPCREL64
:
4491 /* Use global offset table entry as symbol value. */
4492 case R_X86_64_GOTPLT64
:
4493 /* This is obsolete and treated the the same as GOT64. */
4494 base_got
= htab
->elf
.sgot
;
4496 if (htab
->elf
.sgot
== NULL
)
4503 off
= h
->got
.offset
;
4505 && h
->plt
.offset
!= (bfd_vma
)-1
4506 && off
== (bfd_vma
)-1)
4508 /* We can't use h->got.offset here to save
4509 state, or even just remember the offset, as
4510 finish_dynamic_symbol would use that as offset into
4512 bfd_vma plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4513 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4514 base_got
= htab
->elf
.sgotplt
;
4517 dyn
= htab
->elf
.dynamic_sections_created
;
4519 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
4520 || (bfd_link_pic (info
)
4521 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4522 || (ELF_ST_VISIBILITY (h
->other
)
4523 && h
->root
.type
== bfd_link_hash_undefweak
))
4525 /* This is actually a static link, or it is a -Bsymbolic
4526 link and the symbol is defined locally, or the symbol
4527 was forced to be local because of a version file. We
4528 must initialize this entry in the global offset table.
4529 Since the offset must always be a multiple of 8, we
4530 use the least significant bit to record whether we
4531 have initialized it already.
4533 When doing a dynamic link, we create a .rela.got
4534 relocation entry to initialize the value. This is
4535 done in the finish_dynamic_symbol routine. */
4540 bfd_put_64 (output_bfd
, relocation
,
4541 base_got
->contents
+ off
);
4542 /* Note that this is harmless for the GOTPLT64 case,
4543 as -1 | 1 still is -1. */
4548 unresolved_reloc
= FALSE
;
4552 if (local_got_offsets
== NULL
)
4555 off
= local_got_offsets
[r_symndx
];
4557 /* The offset must always be a multiple of 8. We use
4558 the least significant bit to record whether we have
4559 already generated the necessary reloc. */
4564 bfd_put_64 (output_bfd
, relocation
,
4565 base_got
->contents
+ off
);
4567 if (bfd_link_pic (info
))
4570 Elf_Internal_Rela outrel
;
4572 /* We need to generate a R_X86_64_RELATIVE reloc
4573 for the dynamic linker. */
4574 s
= htab
->elf
.srelgot
;
4578 outrel
.r_offset
= (base_got
->output_section
->vma
4579 + base_got
->output_offset
4581 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4582 outrel
.r_addend
= relocation
;
4583 elf_append_rela (output_bfd
, s
, &outrel
);
4586 local_got_offsets
[r_symndx
] |= 1;
4590 if (off
>= (bfd_vma
) -2)
4593 relocation
= base_got
->output_section
->vma
4594 + base_got
->output_offset
+ off
;
4595 if (r_type
!= R_X86_64_GOTPCREL
4596 && r_type
!= R_X86_64_GOTPCRELX
4597 && r_type
!= R_X86_64_REX_GOTPCRELX
4598 && r_type
!= R_X86_64_GOTPCREL64
)
4599 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4600 - htab
->elf
.sgotplt
->output_offset
;
4604 case R_X86_64_GOTOFF64
:
4605 /* Relocation is relative to the start of the global offset
4608 /* Check to make sure it isn't a protected function or data
4609 symbol for shared library since it may not be local when
4610 used as function address or with copy relocation. We also
4611 need to make sure that a symbol is referenced locally. */
4612 if (bfd_link_pic (info
) && h
)
4614 if (!h
->def_regular
)
4618 switch (ELF_ST_VISIBILITY (h
->other
))
4621 v
= _("hidden symbol");
4624 v
= _("internal symbol");
4627 v
= _("protected symbol");
4634 (*_bfd_error_handler
)
4635 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s `%s' can not be used when making a shared object"),
4636 input_bfd
, v
, h
->root
.root
.string
);
4637 bfd_set_error (bfd_error_bad_value
);
4640 else if (!bfd_link_executable (info
)
4641 && !SYMBOL_REFERENCES_LOCAL (info
, h
)
4642 && (h
->type
== STT_FUNC
4643 || h
->type
== STT_OBJECT
)
4644 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4646 (*_bfd_error_handler
)
4647 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s `%s' can not be used when making a shared object"),
4649 h
->type
== STT_FUNC
? "function" : "data",
4650 h
->root
.root
.string
);
4651 bfd_set_error (bfd_error_bad_value
);
4656 /* Note that sgot is not involved in this
4657 calculation. We always want the start of .got.plt. If we
4658 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4659 permitted by the ABI, we might have to change this
4661 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4662 + htab
->elf
.sgotplt
->output_offset
;
4665 case R_X86_64_GOTPC32
:
4666 case R_X86_64_GOTPC64
:
4667 /* Use global offset table as symbol value. */
4668 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4669 + htab
->elf
.sgotplt
->output_offset
;
4670 unresolved_reloc
= FALSE
;
4673 case R_X86_64_PLTOFF64
:
4674 /* Relocation is PLT entry relative to GOT. For local
4675 symbols it's the symbol itself relative to GOT. */
4677 /* See PLT32 handling. */
4678 && h
->plt
.offset
!= (bfd_vma
) -1
4679 && htab
->elf
.splt
!= NULL
)
4681 if (htab
->plt_bnd
!= NULL
)
4683 resolved_plt
= htab
->plt_bnd
;
4684 plt_offset
= eh
->plt_bnd
.offset
;
4688 resolved_plt
= htab
->elf
.splt
;
4689 plt_offset
= h
->plt
.offset
;
4692 relocation
= (resolved_plt
->output_section
->vma
4693 + resolved_plt
->output_offset
4695 unresolved_reloc
= FALSE
;
4698 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4699 + htab
->elf
.sgotplt
->output_offset
;
4702 case R_X86_64_PLT32
:
4703 case R_X86_64_PLT32_BND
:
4704 /* Relocation is to the entry for this symbol in the
4705 procedure linkage table. */
4707 /* Resolve a PLT32 reloc against a local symbol directly,
4708 without using the procedure linkage table. */
4712 if ((h
->plt
.offset
== (bfd_vma
) -1
4713 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4714 || htab
->elf
.splt
== NULL
)
4716 /* We didn't make a PLT entry for this symbol. This
4717 happens when statically linking PIC code, or when
4718 using -Bsymbolic. */
4722 if (h
->plt
.offset
!= (bfd_vma
) -1)
4724 if (htab
->plt_bnd
!= NULL
)
4726 resolved_plt
= htab
->plt_bnd
;
4727 plt_offset
= eh
->plt_bnd
.offset
;
4731 resolved_plt
= htab
->elf
.splt
;
4732 plt_offset
= h
->plt
.offset
;
4737 /* Use the GOT PLT. */
4738 resolved_plt
= htab
->plt_got
;
4739 plt_offset
= eh
->plt_got
.offset
;
4742 relocation
= (resolved_plt
->output_section
->vma
4743 + resolved_plt
->output_offset
4745 unresolved_reloc
= FALSE
;
4748 case R_X86_64_SIZE32
:
4749 case R_X86_64_SIZE64
:
4750 /* Set to symbol size. */
4751 relocation
= st_size
;
4757 case R_X86_64_PC32_BND
:
4758 /* Don't complain about -fPIC if the symbol is undefined when
4759 building executable unless it is unresolved weak symbol. */
4760 if ((input_section
->flags
& SEC_ALLOC
) != 0
4761 && (input_section
->flags
& SEC_READONLY
) != 0
4763 && ((bfd_link_executable (info
)
4764 && h
->root
.type
== bfd_link_hash_undefweak
4765 && !resolved_to_zero
)
4766 || (bfd_link_pic (info
)
4767 && !(bfd_link_pie (info
)
4768 && h
->root
.type
== bfd_link_hash_undefined
))))
4770 bfd_boolean fail
= FALSE
;
4772 = ((r_type
== R_X86_64_PC32
4773 || r_type
== R_X86_64_PC32_BND
)
4774 && is_32bit_relative_branch (contents
, rel
->r_offset
));
4776 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
4778 /* Symbol is referenced locally. Make sure it is
4779 defined locally or for a branch. */
4780 fail
= !h
->def_regular
&& !branch
;
4782 else if (!(bfd_link_pie (info
)
4783 && (h
->needs_copy
|| eh
->needs_copy
)))
4785 /* Symbol doesn't need copy reloc and isn't referenced
4786 locally. We only allow branch to symbol with
4787 non-default visibility. */
4789 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
4793 return elf_x86_64_need_pic (input_bfd
, input_section
,
4794 h
, NULL
, NULL
, howto
);
4803 /* FIXME: The ABI says the linker should make sure the value is
4804 the same when it's zeroextended to 64 bit. */
4807 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4810 /* Don't copy a pc-relative relocation into the output file
4811 if the symbol needs copy reloc or the symbol is undefined
4812 when building executable. Copy dynamic function pointer
4813 relocations. Don't generate dynamic relocations against
4814 resolved undefined weak symbols in PIE. */
4815 if ((bfd_link_pic (info
)
4816 && !(bfd_link_pie (info
)
4820 || h
->root
.type
== bfd_link_hash_undefined
)
4821 && (IS_X86_64_PCREL_TYPE (r_type
)
4822 || r_type
== R_X86_64_SIZE32
4823 || r_type
== R_X86_64_SIZE64
))
4825 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4826 && !resolved_to_zero
)
4827 || h
->root
.type
!= bfd_link_hash_undefweak
))
4828 && ((! IS_X86_64_PCREL_TYPE (r_type
)
4829 && r_type
!= R_X86_64_SIZE32
4830 && r_type
!= R_X86_64_SIZE64
)
4831 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
4832 || (ELIMINATE_COPY_RELOCS
4833 && !bfd_link_pic (info
)
4837 || eh
->func_pointer_refcount
> 0
4838 || (h
->root
.type
== bfd_link_hash_undefweak
4839 && !resolved_to_zero
))
4840 && ((h
->def_dynamic
&& !h
->def_regular
)
4841 /* Undefined weak symbol is bound locally when
4843 || h
->root
.type
== bfd_link_hash_undefined
)))
4845 Elf_Internal_Rela outrel
;
4846 bfd_boolean skip
, relocate
;
4849 /* When generating a shared object, these relocations
4850 are copied into the output file to be resolved at run
4856 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4858 if (outrel
.r_offset
== (bfd_vma
) -1)
4860 else if (outrel
.r_offset
== (bfd_vma
) -2)
4861 skip
= TRUE
, relocate
= TRUE
;
4863 outrel
.r_offset
+= (input_section
->output_section
->vma
4864 + input_section
->output_offset
);
4867 memset (&outrel
, 0, sizeof outrel
);
4869 /* h->dynindx may be -1 if this symbol was marked to
4873 && (IS_X86_64_PCREL_TYPE (r_type
)
4874 || !(bfd_link_executable (info
)
4875 || SYMBOLIC_BIND (info
, h
))
4876 || ! h
->def_regular
))
4878 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4879 outrel
.r_addend
= rel
->r_addend
;
4883 /* This symbol is local, or marked to become local.
4884 When relocation overflow check is disabled, we
4885 convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */
4886 if (r_type
== htab
->pointer_r_type
4887 || (r_type
== R_X86_64_32
4888 && info
->no_reloc_overflow_check
))
4891 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4892 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4894 else if (r_type
== R_X86_64_64
4895 && !ABI_64_P (output_bfd
))
4898 outrel
.r_info
= htab
->r_info (0,
4899 R_X86_64_RELATIVE64
);
4900 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4901 /* Check addend overflow. */
4902 if ((outrel
.r_addend
& 0x80000000)
4903 != (rel
->r_addend
& 0x80000000))
4906 int addend
= rel
->r_addend
;
4907 if (h
&& h
->root
.root
.string
)
4908 name
= h
->root
.root
.string
;
4910 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4913 (*_bfd_error_handler
)
4914 (_("%B: addend -0x%x in relocation %s against "
4915 "symbol `%s' at 0x%lx in section `%A' is "
4917 input_bfd
, input_section
, addend
,
4919 (unsigned long) rel
->r_offset
);
4921 (*_bfd_error_handler
)
4922 (_("%B: addend 0x%x in relocation %s against "
4923 "symbol `%s' at 0x%lx in section `%A' is "
4925 input_bfd
, input_section
, addend
,
4927 (unsigned long) rel
->r_offset
);
4928 bfd_set_error (bfd_error_bad_value
);
4936 if (bfd_is_abs_section (sec
))
4938 else if (sec
== NULL
|| sec
->owner
== NULL
)
4940 bfd_set_error (bfd_error_bad_value
);
4947 /* We are turning this relocation into one
4948 against a section symbol. It would be
4949 proper to subtract the symbol's value,
4950 osec->vma, from the emitted reloc addend,
4951 but ld.so expects buggy relocs. */
4952 osec
= sec
->output_section
;
4953 sindx
= elf_section_data (osec
)->dynindx
;
4956 asection
*oi
= htab
->elf
.text_index_section
;
4957 sindx
= elf_section_data (oi
)->dynindx
;
4959 BFD_ASSERT (sindx
!= 0);
4962 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
4963 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4967 sreloc
= elf_section_data (input_section
)->sreloc
;
4969 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4971 r
= bfd_reloc_notsupported
;
4972 goto check_relocation_error
;
4975 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4977 /* If this reloc is against an external symbol, we do
4978 not want to fiddle with the addend. Otherwise, we
4979 need to include the symbol value so that it becomes
4980 an addend for the dynamic reloc. */
4987 case R_X86_64_TLSGD
:
4988 case R_X86_64_GOTPC32_TLSDESC
:
4989 case R_X86_64_TLSDESC_CALL
:
4990 case R_X86_64_GOTTPOFF
:
4991 tls_type
= GOT_UNKNOWN
;
4992 if (h
== NULL
&& local_got_offsets
)
4993 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
4995 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
4997 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4998 input_section
, contents
,
4999 symtab_hdr
, sym_hashes
,
5000 &r_type
, tls_type
, rel
,
5001 relend
, h
, r_symndx
, TRUE
))
5004 if (r_type
== R_X86_64_TPOFF32
)
5006 bfd_vma roff
= rel
->r_offset
;
5008 BFD_ASSERT (! unresolved_reloc
);
5010 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5012 /* GD->LE transition. For 64bit, change
5013 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5014 .word 0x6666; rex64; call __tls_get_addr@PLT
5016 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5018 call *__tls_get_addr@GOTPCREL(%rip)
5019 which may be converted to
5020 addr32 call __tls_get_addr
5023 leaq foo@tpoff(%rax), %rax
5025 leaq foo@tlsgd(%rip), %rdi
5026 .word 0x6666; rex64; call __tls_get_addr@PLT
5028 leaq foo@tlsgd(%rip), %rdi
5030 call *__tls_get_addr@GOTPCREL(%rip)
5031 which may be converted to
5032 addr32 call __tls_get_addr
5035 leaq foo@tpoff(%rax), %rax
5036 For largepic, change:
5037 leaq foo@tlsgd(%rip), %rdi
5038 movabsq $__tls_get_addr@pltoff, %rax
5043 leaq foo@tpoff(%rax), %rax
5044 nopw 0x0(%rax,%rax,1) */
5046 if (ABI_64_P (output_bfd
))
5048 if (contents
[roff
+ 5] == 0xb8)
5050 memcpy (contents
+ roff
- 3,
5051 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
5052 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5056 memcpy (contents
+ roff
- 4,
5057 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5061 memcpy (contents
+ roff
- 3,
5062 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5064 bfd_put_32 (output_bfd
,
5065 elf_x86_64_tpoff (info
, relocation
),
5066 contents
+ roff
+ 8 + largepic
);
5067 /* Skip R_X86_64_PC32, R_X86_64_PLT32,
5068 R_X86_64_GOTPCRELX and R_X86_64_PLTOFF64. */
5073 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5075 /* GDesc -> LE transition.
5076 It's originally something like:
5077 leaq x@tlsdesc(%rip), %rax
5080 movl $x@tpoff, %rax. */
5082 unsigned int val
, type
;
5084 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5085 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5086 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
5087 contents
+ roff
- 3);
5088 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
5089 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
5090 contents
+ roff
- 1);
5091 bfd_put_32 (output_bfd
,
5092 elf_x86_64_tpoff (info
, relocation
),
5096 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5098 /* GDesc -> LE transition.
5103 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5104 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5107 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
5109 /* IE->LE transition:
5110 For 64bit, originally it can be one of:
5111 movq foo@gottpoff(%rip), %reg
5112 addq foo@gottpoff(%rip), %reg
5115 leaq foo(%reg), %reg
5117 For 32bit, originally it can be one of:
5118 movq foo@gottpoff(%rip), %reg
5119 addl foo@gottpoff(%rip), %reg
5122 leal foo(%reg), %reg
5125 unsigned int val
, type
, reg
;
5128 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5131 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
5132 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5138 bfd_put_8 (output_bfd
, 0x49,
5139 contents
+ roff
- 3);
5140 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5141 bfd_put_8 (output_bfd
, 0x41,
5142 contents
+ roff
- 3);
5143 bfd_put_8 (output_bfd
, 0xc7,
5144 contents
+ roff
- 2);
5145 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5146 contents
+ roff
- 1);
5150 /* addq/addl -> addq/addl - addressing with %rsp/%r12
5153 bfd_put_8 (output_bfd
, 0x49,
5154 contents
+ roff
- 3);
5155 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5156 bfd_put_8 (output_bfd
, 0x41,
5157 contents
+ roff
- 3);
5158 bfd_put_8 (output_bfd
, 0x81,
5159 contents
+ roff
- 2);
5160 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5161 contents
+ roff
- 1);
5165 /* addq/addl -> leaq/leal */
5167 bfd_put_8 (output_bfd
, 0x4d,
5168 contents
+ roff
- 3);
5169 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5170 bfd_put_8 (output_bfd
, 0x45,
5171 contents
+ roff
- 3);
5172 bfd_put_8 (output_bfd
, 0x8d,
5173 contents
+ roff
- 2);
5174 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
5175 contents
+ roff
- 1);
5177 bfd_put_32 (output_bfd
,
5178 elf_x86_64_tpoff (info
, relocation
),
5186 if (htab
->elf
.sgot
== NULL
)
5191 off
= h
->got
.offset
;
5192 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
5196 if (local_got_offsets
== NULL
)
5199 off
= local_got_offsets
[r_symndx
];
5200 offplt
= local_tlsdesc_gotents
[r_symndx
];
5207 Elf_Internal_Rela outrel
;
5211 if (htab
->elf
.srelgot
== NULL
)
5214 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
5216 if (GOT_TLS_GDESC_P (tls_type
))
5218 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
5219 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
5220 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
5221 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5222 + htab
->elf
.sgotplt
->output_offset
5224 + htab
->sgotplt_jump_table_size
);
5225 sreloc
= htab
->elf
.srelplt
;
5227 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5229 outrel
.r_addend
= 0;
5230 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5233 sreloc
= htab
->elf
.srelgot
;
5235 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5236 + htab
->elf
.sgot
->output_offset
+ off
);
5238 if (GOT_TLS_GD_P (tls_type
))
5239 dr_type
= R_X86_64_DTPMOD64
;
5240 else if (GOT_TLS_GDESC_P (tls_type
))
5243 dr_type
= R_X86_64_TPOFF64
;
5245 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
5246 outrel
.r_addend
= 0;
5247 if ((dr_type
== R_X86_64_TPOFF64
5248 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
5249 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5250 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
5252 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5254 if (GOT_TLS_GD_P (tls_type
))
5258 BFD_ASSERT (! unresolved_reloc
);
5259 bfd_put_64 (output_bfd
,
5260 relocation
- elf_x86_64_dtpoff_base (info
),
5261 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5265 bfd_put_64 (output_bfd
, 0,
5266 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5267 outrel
.r_info
= htab
->r_info (indx
,
5269 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
5270 elf_append_rela (output_bfd
, sreloc
,
5279 local_got_offsets
[r_symndx
] |= 1;
5282 if (off
>= (bfd_vma
) -2
5283 && ! GOT_TLS_GDESC_P (tls_type
))
5285 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
5287 if (r_type
== R_X86_64_GOTPC32_TLSDESC
5288 || r_type
== R_X86_64_TLSDESC_CALL
)
5289 relocation
= htab
->elf
.sgotplt
->output_section
->vma
5290 + htab
->elf
.sgotplt
->output_offset
5291 + offplt
+ htab
->sgotplt_jump_table_size
;
5293 relocation
= htab
->elf
.sgot
->output_section
->vma
5294 + htab
->elf
.sgot
->output_offset
+ off
;
5295 unresolved_reloc
= FALSE
;
5299 bfd_vma roff
= rel
->r_offset
;
5301 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5303 /* GD->IE transition. For 64bit, change
5304 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5305 .word 0x6666; rex64; call __tls_get_addr@PLT
5307 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5309 call *__tls_get_addr@GOTPCREL(%rip
5310 which may be converted to
5311 addr32 call __tls_get_addr
5314 addq foo@gottpoff(%rip), %rax
5316 leaq foo@tlsgd(%rip), %rdi
5317 .word 0x6666; rex64; call __tls_get_addr@PLT
5319 leaq foo@tlsgd(%rip), %rdi
5321 call *__tls_get_addr@GOTPCREL(%rip)
5322 which may be converted to
5323 addr32 call __tls_get_addr
5326 addq foo@gottpoff(%rip), %rax
5327 For largepic, change:
5328 leaq foo@tlsgd(%rip), %rdi
5329 movabsq $__tls_get_addr@pltoff, %rax
5334 addq foo@gottpoff(%rax), %rax
5335 nopw 0x0(%rax,%rax,1) */
5337 if (ABI_64_P (output_bfd
))
5339 if (contents
[roff
+ 5] == 0xb8)
5341 memcpy (contents
+ roff
- 3,
5342 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
5343 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5347 memcpy (contents
+ roff
- 4,
5348 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5352 memcpy (contents
+ roff
- 3,
5353 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5356 relocation
= (htab
->elf
.sgot
->output_section
->vma
5357 + htab
->elf
.sgot
->output_offset
+ off
5360 - input_section
->output_section
->vma
5361 - input_section
->output_offset
5363 bfd_put_32 (output_bfd
, relocation
,
5364 contents
+ roff
+ 8 + largepic
);
5365 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5370 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5372 /* GDesc -> IE transition.
5373 It's originally something like:
5374 leaq x@tlsdesc(%rip), %rax
5377 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
5379 /* Now modify the instruction as appropriate. To
5380 turn a leaq into a movq in the form we use it, it
5381 suffices to change the second byte from 0x8d to
5383 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
5385 bfd_put_32 (output_bfd
,
5386 htab
->elf
.sgot
->output_section
->vma
5387 + htab
->elf
.sgot
->output_offset
+ off
5389 - input_section
->output_section
->vma
5390 - input_section
->output_offset
5395 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5397 /* GDesc -> IE transition.
5404 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5405 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5413 case R_X86_64_TLSLD
:
5414 if (! elf_x86_64_tls_transition (info
, input_bfd
,
5415 input_section
, contents
,
5416 symtab_hdr
, sym_hashes
,
5417 &r_type
, GOT_UNKNOWN
, rel
,
5418 relend
, h
, r_symndx
, TRUE
))
5421 if (r_type
!= R_X86_64_TLSLD
)
5423 /* LD->LE transition:
5424 leaq foo@tlsld(%rip), %rdi
5425 call __tls_get_addr@PLT
5426 For 64bit, we change it into:
5427 .word 0x6666; .byte 0x66; movq %fs:0, %rax
5428 For 32bit, we change it into:
5429 nopl 0x0(%rax); movl %fs:0, %eax
5431 leaq foo@tlsld(%rip), %rdi;
5432 call *__tls_get_addr@GOTPCREL(%rip)
5433 which may be converted to
5434 addr32 call __tls_get_addr
5435 For 64bit, we change it into:
5436 .word 0x6666; .word 0x6666; movq %fs:0, %rax
5437 For 32bit, we change it into:
5438 nopw 0x0(%rax); movl %fs:0, %eax
5439 For largepic, change:
5440 leaq foo@tlsgd(%rip), %rdi
5441 movabsq $__tls_get_addr@pltoff, %rax
5445 data16 data16 data16 nopw %cs:0x0(%rax,%rax,1)
5448 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
5449 if (ABI_64_P (output_bfd
))
5451 if (contents
[rel
->r_offset
+ 5] == 0xb8)
5452 memcpy (contents
+ rel
->r_offset
- 3,
5453 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
5454 "\x64\x48\x8b\x04\x25\0\0\0", 22);
5455 else if (contents
[rel
->r_offset
+ 4] == 0xff
5456 || contents
[rel
->r_offset
+ 4] == 0x67)
5457 memcpy (contents
+ rel
->r_offset
- 3,
5458 "\x66\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0",
5461 memcpy (contents
+ rel
->r_offset
- 3,
5462 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
5466 if (contents
[rel
->r_offset
+ 4] == 0xff)
5467 memcpy (contents
+ rel
->r_offset
- 3,
5468 "\x66\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0",
5471 memcpy (contents
+ rel
->r_offset
- 3,
5472 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
5474 /* Skip R_X86_64_PC32, R_X86_64_PLT32, R_X86_64_GOTPCRELX
5475 and R_X86_64_PLTOFF64. */
5481 if (htab
->elf
.sgot
== NULL
)
5484 off
= htab
->tls_ld_got
.offset
;
5489 Elf_Internal_Rela outrel
;
5491 if (htab
->elf
.srelgot
== NULL
)
5494 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5495 + htab
->elf
.sgot
->output_offset
+ off
);
5497 bfd_put_64 (output_bfd
, 0,
5498 htab
->elf
.sgot
->contents
+ off
);
5499 bfd_put_64 (output_bfd
, 0,
5500 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5501 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
5502 outrel
.r_addend
= 0;
5503 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
5505 htab
->tls_ld_got
.offset
|= 1;
5507 relocation
= htab
->elf
.sgot
->output_section
->vma
5508 + htab
->elf
.sgot
->output_offset
+ off
;
5509 unresolved_reloc
= FALSE
;
5512 case R_X86_64_DTPOFF32
:
5513 if (!bfd_link_executable (info
)
5514 || (input_section
->flags
& SEC_CODE
) == 0)
5515 relocation
-= elf_x86_64_dtpoff_base (info
);
5517 relocation
= elf_x86_64_tpoff (info
, relocation
);
5520 case R_X86_64_TPOFF32
:
5521 case R_X86_64_TPOFF64
:
5522 BFD_ASSERT (bfd_link_executable (info
));
5523 relocation
= elf_x86_64_tpoff (info
, relocation
);
5526 case R_X86_64_DTPOFF64
:
5527 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
5528 relocation
-= elf_x86_64_dtpoff_base (info
);
5535 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5536 because such sections are not SEC_ALLOC and thus ld.so will
5537 not process them. */
5538 if (unresolved_reloc
5539 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
5541 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5542 rel
->r_offset
) != (bfd_vma
) -1)
5544 (*_bfd_error_handler
)
5545 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5548 (long) rel
->r_offset
,
5550 h
->root
.root
.string
);
5555 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5556 contents
, rel
->r_offset
,
5557 relocation
, rel
->r_addend
);
5559 check_relocation_error
:
5560 if (r
!= bfd_reloc_ok
)
5565 name
= h
->root
.root
.string
;
5568 name
= bfd_elf_string_from_elf_section (input_bfd
,
5569 symtab_hdr
->sh_link
,
5574 name
= bfd_section_name (input_bfd
, sec
);
5577 if (r
== bfd_reloc_overflow
)
5578 (*info
->callbacks
->reloc_overflow
)
5579 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5580 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
5583 (*_bfd_error_handler
)
5584 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5585 input_bfd
, input_section
,
5586 (long) rel
->r_offset
, name
, (int) r
);
5597 Elf_Internal_Shdr
*rel_hdr
;
5598 size_t deleted
= rel
- wrel
;
5600 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
5601 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5602 if (rel_hdr
->sh_size
== 0)
5604 /* It is too late to remove an empty reloc section. Leave
5606 ??? What is wrong with an empty section??? */
5607 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
5610 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5611 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5612 input_section
->reloc_count
-= deleted
;
5618 /* Finish up dynamic symbol handling. We set the contents of various
5619 dynamic sections here. */
5622 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
5623 struct bfd_link_info
*info
,
5624 struct elf_link_hash_entry
*h
,
5625 Elf_Internal_Sym
*sym
)
5627 struct elf_x86_64_link_hash_table
*htab
;
5628 const struct elf_x86_64_backend_data
*abed
;
5629 bfd_boolean use_plt_bnd
;
5630 struct elf_x86_64_link_hash_entry
*eh
;
5631 bfd_boolean local_undefweak
;
5633 htab
= elf_x86_64_hash_table (info
);
5637 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5638 section only if there is .plt section. */
5639 use_plt_bnd
= htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
;
5641 ? &elf_x86_64_bnd_arch_bed
5642 : get_elf_x86_64_backend_data (output_bfd
));
5644 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
5646 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5647 resolved undefined weak symbols in executable so that their
5648 references have value 0 at run-time. */
5649 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
5653 if (h
->plt
.offset
!= (bfd_vma
) -1)
5656 bfd_vma got_offset
, plt_offset
, plt_plt_offset
, plt_got_offset
;
5657 bfd_vma plt_plt_insn_end
, plt_got_insn_size
;
5658 Elf_Internal_Rela rela
;
5660 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
5661 const struct elf_backend_data
*bed
;
5662 bfd_vma plt_got_pcrel_offset
;
5664 /* When building a static executable, use .iplt, .igot.plt and
5665 .rela.iplt sections for STT_GNU_IFUNC symbols. */
5666 if (htab
->elf
.splt
!= NULL
)
5668 plt
= htab
->elf
.splt
;
5669 gotplt
= htab
->elf
.sgotplt
;
5670 relplt
= htab
->elf
.srelplt
;
5674 plt
= htab
->elf
.iplt
;
5675 gotplt
= htab
->elf
.igotplt
;
5676 relplt
= htab
->elf
.irelplt
;
5679 /* This symbol has an entry in the procedure linkage table. Set
5681 if ((h
->dynindx
== -1
5683 && !((h
->forced_local
|| bfd_link_executable (info
))
5685 && h
->type
== STT_GNU_IFUNC
))
5691 /* Get the index in the procedure linkage table which
5692 corresponds to this symbol. This is the index of this symbol
5693 in all the symbols for which we are making plt entries. The
5694 first entry in the procedure linkage table is reserved.
5696 Get the offset into the .got table of the entry that
5697 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
5698 bytes. The first three are reserved for the dynamic linker.
5700 For static executables, we don't reserve anything. */
5702 if (plt
== htab
->elf
.splt
)
5704 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
5705 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
5709 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
5710 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
5713 plt_plt_insn_end
= abed
->plt_plt_insn_end
;
5714 plt_plt_offset
= abed
->plt_plt_offset
;
5715 plt_got_insn_size
= abed
->plt_got_insn_size
;
5716 plt_got_offset
= abed
->plt_got_offset
;
5719 /* Use the second PLT with BND relocations. */
5720 const bfd_byte
*plt_entry
, *plt2_entry
;
5722 if (eh
->has_bnd_reloc
)
5724 plt_entry
= elf_x86_64_bnd_plt_entry
;
5725 plt2_entry
= elf_x86_64_bnd_plt2_entry
;
5729 plt_entry
= elf_x86_64_legacy_plt_entry
;
5730 plt2_entry
= elf_x86_64_legacy_plt2_entry
;
5732 /* Subtract 1 since there is no BND prefix. */
5733 plt_plt_insn_end
-= 1;
5734 plt_plt_offset
-= 1;
5735 plt_got_insn_size
-= 1;
5736 plt_got_offset
-= 1;
5739 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry
)
5740 == sizeof (elf_x86_64_legacy_plt_entry
));
5742 /* Fill in the entry in the procedure linkage table. */
5743 memcpy (plt
->contents
+ h
->plt
.offset
,
5744 plt_entry
, sizeof (elf_x86_64_legacy_plt_entry
));
5745 /* Fill in the entry in the second PLT. */
5746 memcpy (htab
->plt_bnd
->contents
+ eh
->plt_bnd
.offset
,
5747 plt2_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5749 resolved_plt
= htab
->plt_bnd
;
5750 plt_offset
= eh
->plt_bnd
.offset
;
5754 /* Fill in the entry in the procedure linkage table. */
5755 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
5756 abed
->plt_entry_size
);
5759 plt_offset
= h
->plt
.offset
;
5762 /* Insert the relocation positions of the plt section. */
5764 /* Put offset the PC-relative instruction referring to the GOT entry,
5765 subtracting the size of that instruction. */
5766 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
5767 + gotplt
->output_offset
5769 - resolved_plt
->output_section
->vma
5770 - resolved_plt
->output_offset
5772 - plt_got_insn_size
);
5774 /* Check PC-relative offset overflow in PLT entry. */
5775 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
5776 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5777 output_bfd
, h
->root
.root
.string
);
5779 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
5780 resolved_plt
->contents
+ plt_offset
+ plt_got_offset
);
5782 /* Fill in the entry in the global offset table, initially this
5783 points to the second part of the PLT entry. Leave the entry
5784 as zero for undefined weak symbol in PIE. No PLT relocation
5785 against undefined weak symbol in PIE. */
5786 if (!local_undefweak
)
5788 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5789 + plt
->output_offset
5791 + abed
->plt_lazy_offset
),
5792 gotplt
->contents
+ got_offset
);
5794 /* Fill in the entry in the .rela.plt section. */
5795 rela
.r_offset
= (gotplt
->output_section
->vma
5796 + gotplt
->output_offset
5798 if (h
->dynindx
== -1
5799 || ((bfd_link_executable (info
)
5800 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5802 && h
->type
== STT_GNU_IFUNC
))
5804 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5805 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
5806 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
5807 rela
.r_addend
= (h
->root
.u
.def
.value
5808 + h
->root
.u
.def
.section
->output_section
->vma
5809 + h
->root
.u
.def
.section
->output_offset
);
5810 /* R_X86_64_IRELATIVE comes last. */
5811 plt_index
= htab
->next_irelative_index
--;
5815 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
5817 plt_index
= htab
->next_jump_slot_index
++;
5820 /* Don't fill PLT entry for static executables. */
5821 if (plt
== htab
->elf
.splt
)
5823 bfd_vma plt0_offset
= h
->plt
.offset
+ plt_plt_insn_end
;
5825 /* Put relocation index. */
5826 bfd_put_32 (output_bfd
, plt_index
,
5827 (plt
->contents
+ h
->plt
.offset
5828 + abed
->plt_reloc_offset
));
5830 /* Put offset for jmp .PLT0 and check for overflow. We don't
5831 check relocation index for overflow since branch displacement
5832 will overflow first. */
5833 if (plt0_offset
> 0x80000000)
5834 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5835 output_bfd
, h
->root
.root
.string
);
5836 bfd_put_32 (output_bfd
, - plt0_offset
,
5837 plt
->contents
+ h
->plt
.offset
+ plt_plt_offset
);
5840 bed
= get_elf_backend_data (output_bfd
);
5841 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
5842 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
5845 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5847 bfd_vma got_offset
, plt_offset
, plt_got_offset
, plt_got_insn_size
;
5848 asection
*plt
, *got
;
5849 bfd_boolean got_after_plt
;
5850 int32_t got_pcrel_offset
;
5851 const bfd_byte
*got_plt_entry
;
5853 /* Set the entry in the GOT procedure linkage table. */
5854 plt
= htab
->plt_got
;
5855 got
= htab
->elf
.sgot
;
5856 got_offset
= h
->got
.offset
;
5858 if (got_offset
== (bfd_vma
) -1
5859 || h
->type
== STT_GNU_IFUNC
5864 /* Use the second PLT entry template for the GOT PLT since they
5865 are the identical. */
5866 plt_got_insn_size
= elf_x86_64_bnd_arch_bed
.plt_got_insn_size
;
5867 plt_got_offset
= elf_x86_64_bnd_arch_bed
.plt_got_offset
;
5868 if (eh
->has_bnd_reloc
)
5869 got_plt_entry
= elf_x86_64_bnd_plt2_entry
;
5872 got_plt_entry
= elf_x86_64_legacy_plt2_entry
;
5874 /* Subtract 1 since there is no BND prefix. */
5875 plt_got_insn_size
-= 1;
5876 plt_got_offset
-= 1;
5879 /* Fill in the entry in the GOT procedure linkage table. */
5880 plt_offset
= eh
->plt_got
.offset
;
5881 memcpy (plt
->contents
+ plt_offset
,
5882 got_plt_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5884 /* Put offset the PC-relative instruction referring to the GOT
5885 entry, subtracting the size of that instruction. */
5886 got_pcrel_offset
= (got
->output_section
->vma
5887 + got
->output_offset
5889 - plt
->output_section
->vma
5890 - plt
->output_offset
5892 - plt_got_insn_size
);
5894 /* Check PC-relative offset overflow in GOT PLT entry. */
5895 got_after_plt
= got
->output_section
->vma
> plt
->output_section
->vma
;
5896 if ((got_after_plt
&& got_pcrel_offset
< 0)
5897 || (!got_after_plt
&& got_pcrel_offset
> 0))
5898 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
5899 output_bfd
, h
->root
.root
.string
);
5901 bfd_put_32 (output_bfd
, got_pcrel_offset
,
5902 plt
->contents
+ plt_offset
+ plt_got_offset
);
5905 if (!local_undefweak
5907 && (h
->plt
.offset
!= (bfd_vma
) -1
5908 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5910 /* Mark the symbol as undefined, rather than as defined in
5911 the .plt section. Leave the value if there were any
5912 relocations where pointer equality matters (this is a clue
5913 for the dynamic linker, to make function pointer
5914 comparisons work between an application and shared
5915 library), otherwise set it to zero. If a function is only
5916 called from a binary, there is no need to slow down
5917 shared libraries because of that. */
5918 sym
->st_shndx
= SHN_UNDEF
;
5919 if (!h
->pointer_equality_needed
)
5923 /* Don't generate dynamic GOT relocation against undefined weak
5924 symbol in executable. */
5925 if (h
->got
.offset
!= (bfd_vma
) -1
5926 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
5927 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
5928 && !local_undefweak
)
5930 Elf_Internal_Rela rela
;
5931 asection
*relgot
= htab
->elf
.srelgot
;
5933 /* This symbol has an entry in the global offset table. Set it
5935 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5938 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5939 + htab
->elf
.sgot
->output_offset
5940 + (h
->got
.offset
&~ (bfd_vma
) 1));
5942 /* If this is a static link, or it is a -Bsymbolic link and the
5943 symbol is defined locally or was forced to be local because
5944 of a version file, we just want to emit a RELATIVE reloc.
5945 The entry in the global offset table will already have been
5946 initialized in the relocate_section function. */
5948 && h
->type
== STT_GNU_IFUNC
)
5950 if (h
->plt
.offset
== (bfd_vma
) -1)
5952 /* STT_GNU_IFUNC is referenced without PLT. */
5953 if (htab
->elf
.splt
== NULL
)
5955 /* use .rel[a].iplt section to store .got relocations
5956 in static executable. */
5957 relgot
= htab
->elf
.irelplt
;
5959 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
5961 rela
.r_info
= htab
->r_info (0,
5962 R_X86_64_IRELATIVE
);
5963 rela
.r_addend
= (h
->root
.u
.def
.value
5964 + h
->root
.u
.def
.section
->output_section
->vma
5965 + h
->root
.u
.def
.section
->output_offset
);
5970 else if (bfd_link_pic (info
))
5972 /* Generate R_X86_64_GLOB_DAT. */
5979 if (!h
->pointer_equality_needed
)
5982 /* For non-shared object, we can't use .got.plt, which
5983 contains the real function addres if we need pointer
5984 equality. We load the GOT entry with the PLT entry. */
5985 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5986 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5987 + plt
->output_offset
5989 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5993 else if (bfd_link_pic (info
)
5994 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5996 if (!h
->def_regular
)
5998 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5999 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
6000 rela
.r_addend
= (h
->root
.u
.def
.value
6001 + h
->root
.u
.def
.section
->output_section
->vma
6002 + h
->root
.u
.def
.section
->output_offset
);
6006 BFD_ASSERT((h
->got
.offset
& 1) == 0);
6008 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6009 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
6010 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
6014 elf_append_rela (output_bfd
, relgot
, &rela
);
6019 Elf_Internal_Rela rela
;
6021 /* This symbol needs a copy reloc. Set it up. */
6023 if (h
->dynindx
== -1
6024 || (h
->root
.type
!= bfd_link_hash_defined
6025 && h
->root
.type
!= bfd_link_hash_defweak
)
6026 || htab
->srelbss
== NULL
)
6029 rela
.r_offset
= (h
->root
.u
.def
.value
6030 + h
->root
.u
.def
.section
->output_section
->vma
6031 + h
->root
.u
.def
.section
->output_offset
);
6032 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
6034 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
6040 /* Finish up local dynamic symbol handling. We set the contents of
6041 various dynamic sections here. */
6044 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
6046 struct elf_link_hash_entry
*h
6047 = (struct elf_link_hash_entry
*) *slot
;
6048 struct bfd_link_info
*info
6049 = (struct bfd_link_info
*) inf
;
6051 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
6055 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
6056 here since undefined weak symbol may not be dynamic and may not be
6057 called for elf_x86_64_finish_dynamic_symbol. */
6060 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
6063 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
6064 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
6066 if (h
->root
.type
!= bfd_link_hash_undefweak
6067 || h
->dynindx
!= -1)
6070 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
6074 /* Used to decide how to sort relocs in an optimal manner for the
6075 dynamic linker, before writing them out. */
6077 static enum elf_reloc_type_class
6078 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info
,
6079 const asection
*rel_sec ATTRIBUTE_UNUSED
,
6080 const Elf_Internal_Rela
*rela
)
6082 bfd
*abfd
= info
->output_bfd
;
6083 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6084 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
6086 if (htab
->elf
.dynsym
!= NULL
6087 && htab
->elf
.dynsym
->contents
!= NULL
)
6089 /* Check relocation against STT_GNU_IFUNC symbol if there are
6091 unsigned long r_symndx
= htab
->r_sym (rela
->r_info
);
6092 if (r_symndx
!= STN_UNDEF
)
6094 Elf_Internal_Sym sym
;
6095 if (!bed
->s
->swap_symbol_in (abfd
,
6096 (htab
->elf
.dynsym
->contents
6097 + r_symndx
* bed
->s
->sizeof_sym
),
6101 if (ELF_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
6102 return reloc_class_ifunc
;
6106 switch ((int) ELF32_R_TYPE (rela
->r_info
))
6108 case R_X86_64_IRELATIVE
:
6109 return reloc_class_ifunc
;
6110 case R_X86_64_RELATIVE
:
6111 case R_X86_64_RELATIVE64
:
6112 return reloc_class_relative
;
6113 case R_X86_64_JUMP_SLOT
:
6114 return reloc_class_plt
;
6116 return reloc_class_copy
;
6118 return reloc_class_normal
;
6122 /* Finish up the dynamic sections. */
6125 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
6126 struct bfd_link_info
*info
)
6128 struct elf_x86_64_link_hash_table
*htab
;
6131 const struct elf_x86_64_backend_data
*abed
;
6133 htab
= elf_x86_64_hash_table (info
);
6137 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
6138 section only if there is .plt section. */
6139 abed
= (htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
6140 ? &elf_x86_64_bnd_arch_bed
6141 : get_elf_x86_64_backend_data (output_bfd
));
6143 dynobj
= htab
->elf
.dynobj
;
6144 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
6146 if (htab
->elf
.dynamic_sections_created
)
6148 bfd_byte
*dyncon
, *dynconend
;
6149 const struct elf_backend_data
*bed
;
6150 bfd_size_type sizeof_dyn
;
6152 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
6155 bed
= get_elf_backend_data (dynobj
);
6156 sizeof_dyn
= bed
->s
->sizeof_dyn
;
6157 dyncon
= sdyn
->contents
;
6158 dynconend
= sdyn
->contents
+ sdyn
->size
;
6159 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
6161 Elf_Internal_Dyn dyn
;
6164 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
6172 s
= htab
->elf
.sgotplt
;
6173 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
6177 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
6181 s
= htab
->elf
.srelplt
->output_section
;
6182 dyn
.d_un
.d_val
= s
->size
;
6186 /* The procedure linkage table relocs (DT_JMPREL) should
6187 not be included in the overall relocs (DT_RELA).
6188 Therefore, we override the DT_RELASZ entry here to
6189 make it not include the JMPREL relocs. Since the
6190 linker script arranges for .rela.plt to follow all
6191 other relocation sections, we don't have to worry
6192 about changing the DT_RELA entry. */
6193 if (htab
->elf
.srelplt
!= NULL
)
6195 s
= htab
->elf
.srelplt
->output_section
;
6196 dyn
.d_un
.d_val
-= s
->size
;
6200 case DT_TLSDESC_PLT
:
6202 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6203 + htab
->tlsdesc_plt
;
6206 case DT_TLSDESC_GOT
:
6208 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6209 + htab
->tlsdesc_got
;
6213 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
6216 /* Fill in the special first entry in the procedure linkage table. */
6217 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
6219 /* Fill in the first entry in the procedure linkage table. */
6220 memcpy (htab
->elf
.splt
->contents
,
6221 abed
->plt0_entry
, abed
->plt_entry_size
);
6222 /* Add offset for pushq GOT+8(%rip), since the instruction
6223 uses 6 bytes subtract this value. */
6224 bfd_put_32 (output_bfd
,
6225 (htab
->elf
.sgotplt
->output_section
->vma
6226 + htab
->elf
.sgotplt
->output_offset
6228 - htab
->elf
.splt
->output_section
->vma
6229 - htab
->elf
.splt
->output_offset
6231 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
6232 /* Add offset for the PC-relative instruction accessing GOT+16,
6233 subtracting the offset to the end of that instruction. */
6234 bfd_put_32 (output_bfd
,
6235 (htab
->elf
.sgotplt
->output_section
->vma
6236 + htab
->elf
.sgotplt
->output_offset
6238 - htab
->elf
.splt
->output_section
->vma
6239 - htab
->elf
.splt
->output_offset
6240 - abed
->plt0_got2_insn_end
),
6241 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
6243 elf_section_data (htab
->elf
.splt
->output_section
)
6244 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
6246 if (htab
->tlsdesc_plt
)
6248 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6249 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
6251 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
6252 abed
->plt0_entry
, abed
->plt_entry_size
);
6254 /* Add offset for pushq GOT+8(%rip), since the
6255 instruction uses 6 bytes subtract this value. */
6256 bfd_put_32 (output_bfd
,
6257 (htab
->elf
.sgotplt
->output_section
->vma
6258 + htab
->elf
.sgotplt
->output_offset
6260 - htab
->elf
.splt
->output_section
->vma
6261 - htab
->elf
.splt
->output_offset
6264 htab
->elf
.splt
->contents
6265 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
6266 /* Add offset for the PC-relative instruction accessing GOT+TDG,
6267 where TGD stands for htab->tlsdesc_got, subtracting the offset
6268 to the end of that instruction. */
6269 bfd_put_32 (output_bfd
,
6270 (htab
->elf
.sgot
->output_section
->vma
6271 + htab
->elf
.sgot
->output_offset
6273 - htab
->elf
.splt
->output_section
->vma
6274 - htab
->elf
.splt
->output_offset
6276 - abed
->plt0_got2_insn_end
),
6277 htab
->elf
.splt
->contents
6278 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
6283 if (htab
->plt_bnd
!= NULL
)
6284 elf_section_data (htab
->plt_bnd
->output_section
)
6285 ->this_hdr
.sh_entsize
= sizeof (elf_x86_64_bnd_plt2_entry
);
6287 if (htab
->elf
.sgotplt
)
6289 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
6291 (*_bfd_error_handler
)
6292 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
6296 /* Fill in the first three entries in the global offset table. */
6297 if (htab
->elf
.sgotplt
->size
> 0)
6299 /* Set the first entry in the global offset table to the address of
6300 the dynamic section. */
6302 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
6304 bfd_put_64 (output_bfd
,
6305 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
6306 htab
->elf
.sgotplt
->contents
);
6307 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
6308 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
6309 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
6312 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
6316 /* Adjust .eh_frame for .plt section. */
6317 if (htab
->plt_eh_frame
!= NULL
6318 && htab
->plt_eh_frame
->contents
!= NULL
)
6320 if (htab
->elf
.splt
!= NULL
6321 && htab
->elf
.splt
->size
!= 0
6322 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
6323 && htab
->elf
.splt
->output_section
!= NULL
6324 && htab
->plt_eh_frame
->output_section
!= NULL
)
6326 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
6327 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
6328 + htab
->plt_eh_frame
->output_offset
6329 + PLT_FDE_START_OFFSET
;
6330 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6331 htab
->plt_eh_frame
->contents
6332 + PLT_FDE_START_OFFSET
);
6334 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
6336 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6338 htab
->plt_eh_frame
->contents
))
6343 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
6344 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
6347 /* Fill PLT entries for undefined weak symbols in PIE. */
6348 if (bfd_link_pie (info
))
6349 bfd_hash_traverse (&info
->hash
->table
,
6350 elf_x86_64_pie_finish_undefweak_symbol
,
6356 /* Fill PLT/GOT entries and allocate dynamic relocations for local
6357 STT_GNU_IFUNC symbols, which aren't in the ELF linker hash table.
6358 It has to be done before elf_link_sort_relocs is called so that
6359 dynamic relocations are properly sorted. */
6362 elf_x86_64_output_arch_local_syms
6363 (bfd
*output_bfd ATTRIBUTE_UNUSED
,
6364 struct bfd_link_info
*info
,
6365 void *flaginfo ATTRIBUTE_UNUSED
,
6366 int (*func
) (void *, const char *,
6369 struct elf_link_hash_entry
*) ATTRIBUTE_UNUSED
)
6371 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
6375 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
6376 htab_traverse (htab
->loc_hash_table
,
6377 elf_x86_64_finish_local_dynamic_symbol
,
6383 /* Return an array of PLT entry symbol values. */
6386 elf_x86_64_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
6389 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
6392 bfd_vma
*plt_sym_val
;
6394 bfd_byte
*plt_contents
;
6395 const struct elf_x86_64_backend_data
*bed
;
6396 Elf_Internal_Shdr
*hdr
;
6399 /* Get the .plt section contents. PLT passed down may point to the
6400 .plt.bnd section. Make sure that PLT always points to the .plt
6402 plt_bnd
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6407 plt
= bfd_get_section_by_name (abfd
, ".plt");
6410 bed
= &elf_x86_64_bnd_arch_bed
;
6413 bed
= get_elf_x86_64_backend_data (abfd
);
6415 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
6416 if (plt_contents
== NULL
)
6418 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
6419 plt_contents
, 0, plt
->size
))
6422 free (plt_contents
);
6426 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
6427 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
6430 hdr
= &elf_section_data (relplt
)->this_hdr
;
6431 count
= relplt
->size
/ hdr
->sh_entsize
;
6433 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
6434 if (plt_sym_val
== NULL
)
6437 for (i
= 0; i
< count
; i
++)
6438 plt_sym_val
[i
] = -1;
6440 plt_offset
= bed
->plt_entry_size
;
6441 p
= relplt
->relocation
;
6442 for (i
= 0; i
< count
; i
++, p
++)
6446 /* Skip unknown relocation. */
6447 if (p
->howto
== NULL
)
6450 if (p
->howto
->type
!= R_X86_64_JUMP_SLOT
6451 && p
->howto
->type
!= R_X86_64_IRELATIVE
)
6454 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
6455 + bed
->plt_reloc_offset
));
6456 if (reloc_index
< count
)
6460 /* This is the index in .plt section. */
6461 long plt_index
= plt_offset
/ bed
->plt_entry_size
;
6462 /* Store VMA + the offset in .plt.bnd section. */
6463 plt_sym_val
[reloc_index
] =
6465 + (plt_index
- 1) * sizeof (elf_x86_64_legacy_plt2_entry
));
6468 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
6470 plt_offset
+= bed
->plt_entry_size
;
6472 /* PR binutils/18437: Skip extra relocations in the .rela.plt
6474 if (plt_offset
>= plt
->size
)
6478 free (plt_contents
);
6483 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
6487 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
6494 /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
6495 as PLT if it exists. */
6496 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6498 plt
= bfd_get_section_by_name (abfd
, ".plt");
6499 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
6500 dynsymcount
, dynsyms
, ret
,
6502 elf_x86_64_get_plt_sym_val
);
6505 /* Handle an x86-64 specific section when reading an object file. This
6506 is called when elfcode.h finds a section with an unknown type. */
6509 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
6510 const char *name
, int shindex
)
6512 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
6515 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
6521 /* Hook called by the linker routine which adds symbols from an object
6522 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
6526 elf_x86_64_add_symbol_hook (bfd
*abfd
,
6527 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6528 Elf_Internal_Sym
*sym
,
6529 const char **namep ATTRIBUTE_UNUSED
,
6530 flagword
*flagsp ATTRIBUTE_UNUSED
,
6536 switch (sym
->st_shndx
)
6538 case SHN_X86_64_LCOMMON
:
6539 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
6542 lcomm
= bfd_make_section_with_flags (abfd
,
6546 | SEC_LINKER_CREATED
));
6549 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
6552 *valp
= sym
->st_size
;
6560 /* Given a BFD section, try to locate the corresponding ELF section
6564 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
6565 asection
*sec
, int *index_return
)
6567 if (sec
== &_bfd_elf_large_com_section
)
6569 *index_return
= SHN_X86_64_LCOMMON
;
6575 /* Process a symbol. */
6578 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
6581 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
6583 switch (elfsym
->internal_elf_sym
.st_shndx
)
6585 case SHN_X86_64_LCOMMON
:
6586 asym
->section
= &_bfd_elf_large_com_section
;
6587 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
6588 /* Common symbol doesn't set BSF_GLOBAL. */
6589 asym
->flags
&= ~BSF_GLOBAL
;
6595 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
6597 return (sym
->st_shndx
== SHN_COMMON
6598 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
6602 elf_x86_64_common_section_index (asection
*sec
)
6604 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6607 return SHN_X86_64_LCOMMON
;
6611 elf_x86_64_common_section (asection
*sec
)
6613 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6614 return bfd_com_section_ptr
;
6616 return &_bfd_elf_large_com_section
;
6620 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
6621 const Elf_Internal_Sym
*sym
,
6626 const asection
*oldsec
)
6628 /* A normal common symbol and a large common symbol result in a
6629 normal common symbol. We turn the large common symbol into a
6632 && h
->root
.type
== bfd_link_hash_common
6634 && bfd_is_com_section (*psec
)
6637 if (sym
->st_shndx
== SHN_COMMON
6638 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
6640 h
->root
.u
.c
.p
->section
6641 = bfd_make_section_old_way (oldbfd
, "COMMON");
6642 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
6644 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
6645 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
6646 *psec
= bfd_com_section_ptr
;
6653 elf_x86_64_additional_program_headers (bfd
*abfd
,
6654 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6659 /* Check to see if we need a large readonly segment. */
6660 s
= bfd_get_section_by_name (abfd
, ".lrodata");
6661 if (s
&& (s
->flags
& SEC_LOAD
))
6664 /* Check to see if we need a large data segment. Since .lbss sections
6665 is placed right after the .bss section, there should be no need for
6666 a large data segment just because of .lbss. */
6667 s
= bfd_get_section_by_name (abfd
, ".ldata");
6668 if (s
&& (s
->flags
& SEC_LOAD
))
6674 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6677 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
6679 if (h
->plt
.offset
!= (bfd_vma
) -1
6681 && !h
->pointer_equality_needed
)
6684 return _bfd_elf_hash_symbol (h
);
6687 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
6690 elf_x86_64_relocs_compatible (const bfd_target
*input
,
6691 const bfd_target
*output
)
6693 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
6694 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
6695 && _bfd_elf_relocs_compatible (input
, output
));
6698 static const struct bfd_elf_special_section
6699 elf_x86_64_special_sections
[]=
6701 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6702 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6703 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
6704 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6705 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6706 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6707 { NULL
, 0, 0, 0, 0 }
6710 #define TARGET_LITTLE_SYM x86_64_elf64_vec
6711 #define TARGET_LITTLE_NAME "elf64-x86-64"
6712 #define ELF_ARCH bfd_arch_i386
6713 #define ELF_TARGET_ID X86_64_ELF_DATA
6714 #define ELF_MACHINE_CODE EM_X86_64
6715 #define ELF_MAXPAGESIZE 0x200000
6716 #define ELF_MINPAGESIZE 0x1000
6717 #define ELF_COMMONPAGESIZE 0x1000
6719 #define elf_backend_can_gc_sections 1
6720 #define elf_backend_can_refcount 1
6721 #define elf_backend_want_got_plt 1
6722 #define elf_backend_plt_readonly 1
6723 #define elf_backend_want_plt_sym 0
6724 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
6725 #define elf_backend_rela_normal 1
6726 #define elf_backend_plt_alignment 4
6727 #define elf_backend_extern_protected_data 1
6728 #define elf_backend_caches_rawsize 1
6730 #define elf_info_to_howto elf_x86_64_info_to_howto
6732 #define bfd_elf64_bfd_link_hash_table_create \
6733 elf_x86_64_link_hash_table_create
6734 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
6735 #define bfd_elf64_bfd_reloc_name_lookup \
6736 elf_x86_64_reloc_name_lookup
6738 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
6739 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
6740 #define elf_backend_check_relocs elf_x86_64_check_relocs
6741 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
6742 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
6743 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
6744 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
6745 #define elf_backend_output_arch_local_syms elf_x86_64_output_arch_local_syms
6746 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
6747 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
6748 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
6750 #define elf_backend_write_core_note elf_x86_64_write_core_note
6752 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
6753 #define elf_backend_relocate_section elf_x86_64_relocate_section
6754 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
6755 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
6756 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
6757 #define elf_backend_object_p elf64_x86_64_elf_object_p
6758 #define bfd_elf64_mkobject elf_x86_64_mkobject
6759 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
6761 #define elf_backend_section_from_shdr \
6762 elf_x86_64_section_from_shdr
6764 #define elf_backend_section_from_bfd_section \
6765 elf_x86_64_elf_section_from_bfd_section
6766 #define elf_backend_add_symbol_hook \
6767 elf_x86_64_add_symbol_hook
6768 #define elf_backend_symbol_processing \
6769 elf_x86_64_symbol_processing
6770 #define elf_backend_common_section_index \
6771 elf_x86_64_common_section_index
6772 #define elf_backend_common_section \
6773 elf_x86_64_common_section
6774 #define elf_backend_common_definition \
6775 elf_x86_64_common_definition
6776 #define elf_backend_merge_symbol \
6777 elf_x86_64_merge_symbol
6778 #define elf_backend_special_sections \
6779 elf_x86_64_special_sections
6780 #define elf_backend_additional_program_headers \
6781 elf_x86_64_additional_program_headers
6782 #define elf_backend_hash_symbol \
6783 elf_x86_64_hash_symbol
6784 #define elf_backend_omit_section_dynsym \
6785 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6786 #define elf_backend_fixup_symbol \
6787 elf_x86_64_fixup_symbol
6789 #include "elf64-target.h"
6791 /* CloudABI support. */
6793 #undef TARGET_LITTLE_SYM
6794 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
6795 #undef TARGET_LITTLE_NAME
6796 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
6799 #define ELF_OSABI ELFOSABI_CLOUDABI
6802 #define elf64_bed elf64_x86_64_cloudabi_bed
6804 #include "elf64-target.h"
6806 /* FreeBSD support. */
6808 #undef TARGET_LITTLE_SYM
6809 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
6810 #undef TARGET_LITTLE_NAME
6811 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
6814 #define ELF_OSABI ELFOSABI_FREEBSD
6817 #define elf64_bed elf64_x86_64_fbsd_bed
6819 #include "elf64-target.h"
6821 /* Solaris 2 support. */
6823 #undef TARGET_LITTLE_SYM
6824 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
6825 #undef TARGET_LITTLE_NAME
6826 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
6828 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6829 objects won't be recognized. */
6833 #define elf64_bed elf64_x86_64_sol2_bed
6835 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
6837 #undef elf_backend_static_tls_alignment
6838 #define elf_backend_static_tls_alignment 16
6840 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6842 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6844 #undef elf_backend_want_plt_sym
6845 #define elf_backend_want_plt_sym 1
6847 #undef elf_backend_strtab_flags
6848 #define elf_backend_strtab_flags SHF_STRINGS
6851 elf64_x86_64_copy_solaris_special_section_fields (const bfd
*ibfd ATTRIBUTE_UNUSED
,
6852 bfd
*obfd ATTRIBUTE_UNUSED
,
6853 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
6854 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
6856 /* PR 19938: FIXME: Need to add code for setting the sh_info
6857 and sh_link fields of Solaris specific section types. */
6861 #undef elf_backend_copy_special_section_fields
6862 #define elf_backend_copy_special_section_fields elf64_x86_64_copy_solaris_special_section_fields
6864 #include "elf64-target.h"
6866 /* Native Client support. */
6869 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
6871 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
6872 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
6876 #undef TARGET_LITTLE_SYM
6877 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
6878 #undef TARGET_LITTLE_NAME
6879 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
6881 #define elf64_bed elf64_x86_64_nacl_bed
6883 #undef ELF_MAXPAGESIZE
6884 #undef ELF_MINPAGESIZE
6885 #undef ELF_COMMONPAGESIZE
6886 #define ELF_MAXPAGESIZE 0x10000
6887 #define ELF_MINPAGESIZE 0x10000
6888 #define ELF_COMMONPAGESIZE 0x10000
6890 /* Restore defaults. */
6892 #undef elf_backend_static_tls_alignment
6893 #undef elf_backend_want_plt_sym
6894 #define elf_backend_want_plt_sym 0
6895 #undef elf_backend_strtab_flags
6896 #undef elf_backend_copy_special_section_fields
6898 /* NaCl uses substantially different PLT entries for the same effects. */
6900 #undef elf_backend_plt_alignment
6901 #define elf_backend_plt_alignment 5
6902 #define NACL_PLT_ENTRY_SIZE 64
6903 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6905 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
6907 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
6908 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
6909 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6910 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6911 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6913 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
6914 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
6916 /* 32 bytes of nop to pad out to the standard size. */
6917 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6918 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6919 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6920 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6921 0x66, /* excess data16 prefix */
6925 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6927 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
6928 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6929 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6930 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6932 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
6933 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6934 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6936 /* Lazy GOT entries point here (32-byte aligned). */
6937 0x68, /* pushq immediate */
6938 0, 0, 0, 0, /* replaced with index into relocation table. */
6939 0xe9, /* jmp relative */
6940 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
6942 /* 22 bytes of nop to pad out to the standard size. */
6943 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6944 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6945 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
6948 /* .eh_frame covering the .plt section. */
6950 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
6952 #if (PLT_CIE_LENGTH != 20 \
6953 || PLT_FDE_LENGTH != 36 \
6954 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6955 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6956 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
6958 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6959 0, 0, 0, 0, /* CIE ID */
6960 1, /* CIE version */
6961 'z', 'R', 0, /* Augmentation string */
6962 1, /* Code alignment factor */
6963 0x78, /* Data alignment factor */
6964 16, /* Return address column */
6965 1, /* Augmentation size */
6966 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6967 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
6968 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
6969 DW_CFA_nop
, DW_CFA_nop
,
6971 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6972 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
6973 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
6974 0, 0, 0, 0, /* .plt size goes here */
6975 0, /* Augmentation size */
6976 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
6977 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6978 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
6979 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6980 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6981 13, /* Block length */
6982 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
6983 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
6984 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6985 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
6986 DW_CFA_nop
, DW_CFA_nop
6989 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
6991 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
6992 elf_x86_64_nacl_plt_entry
, /* plt_entry */
6993 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6994 2, /* plt0_got1_offset */
6995 9, /* plt0_got2_offset */
6996 13, /* plt0_got2_insn_end */
6997 3, /* plt_got_offset */
6998 33, /* plt_reloc_offset */
6999 38, /* plt_plt_offset */
7000 7, /* plt_got_insn_size */
7001 42, /* plt_plt_insn_end */
7002 32, /* plt_lazy_offset */
7003 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
7004 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
7007 #undef elf_backend_arch_data
7008 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
7010 #undef elf_backend_object_p
7011 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
7012 #undef elf_backend_modify_segment_map
7013 #define elf_backend_modify_segment_map nacl_modify_segment_map
7014 #undef elf_backend_modify_program_headers
7015 #define elf_backend_modify_program_headers nacl_modify_program_headers
7016 #undef elf_backend_final_write_processing
7017 #define elf_backend_final_write_processing nacl_final_write_processing
7019 #include "elf64-target.h"
7021 /* Native Client x32 support. */
7024 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
7026 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
7027 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
7031 #undef TARGET_LITTLE_SYM
7032 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
7033 #undef TARGET_LITTLE_NAME
7034 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
7036 #define elf32_bed elf32_x86_64_nacl_bed
7038 #define bfd_elf32_bfd_link_hash_table_create \
7039 elf_x86_64_link_hash_table_create
7040 #define bfd_elf32_bfd_reloc_type_lookup \
7041 elf_x86_64_reloc_type_lookup
7042 #define bfd_elf32_bfd_reloc_name_lookup \
7043 elf_x86_64_reloc_name_lookup
7044 #define bfd_elf32_mkobject \
7046 #define bfd_elf32_get_synthetic_symtab \
7047 elf_x86_64_get_synthetic_symtab
7049 #undef elf_backend_object_p
7050 #define elf_backend_object_p \
7051 elf32_x86_64_nacl_elf_object_p
7053 #undef elf_backend_bfd_from_remote_memory
7054 #define elf_backend_bfd_from_remote_memory \
7055 _bfd_elf32_bfd_from_remote_memory
7057 #undef elf_backend_size_info
7058 #define elf_backend_size_info \
7059 _bfd_elf32_size_info
7061 #include "elf32-target.h"
7063 /* Restore defaults. */
7064 #undef elf_backend_object_p
7065 #define elf_backend_object_p elf64_x86_64_elf_object_p
7066 #undef elf_backend_bfd_from_remote_memory
7067 #undef elf_backend_size_info
7068 #undef elf_backend_modify_segment_map
7069 #undef elf_backend_modify_program_headers
7070 #undef elf_backend_final_write_processing
7072 /* Intel L1OM support. */
7075 elf64_l1om_elf_object_p (bfd
*abfd
)
7077 /* Set the right machine number for an L1OM elf64 file. */
7078 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
7082 #undef TARGET_LITTLE_SYM
7083 #define TARGET_LITTLE_SYM l1om_elf64_vec
7084 #undef TARGET_LITTLE_NAME
7085 #define TARGET_LITTLE_NAME "elf64-l1om"
7087 #define ELF_ARCH bfd_arch_l1om
7089 #undef ELF_MACHINE_CODE
7090 #define ELF_MACHINE_CODE EM_L1OM
7095 #define elf64_bed elf64_l1om_bed
7097 #undef elf_backend_object_p
7098 #define elf_backend_object_p elf64_l1om_elf_object_p
7100 /* Restore defaults. */
7101 #undef ELF_MAXPAGESIZE
7102 #undef ELF_MINPAGESIZE
7103 #undef ELF_COMMONPAGESIZE
7104 #define ELF_MAXPAGESIZE 0x200000
7105 #define ELF_MINPAGESIZE 0x1000
7106 #define ELF_COMMONPAGESIZE 0x1000
7107 #undef elf_backend_plt_alignment
7108 #define elf_backend_plt_alignment 4
7109 #undef elf_backend_arch_data
7110 #define elf_backend_arch_data &elf_x86_64_arch_bed
7112 #include "elf64-target.h"
7114 /* FreeBSD L1OM support. */
7116 #undef TARGET_LITTLE_SYM
7117 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
7118 #undef TARGET_LITTLE_NAME
7119 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
7122 #define ELF_OSABI ELFOSABI_FREEBSD
7125 #define elf64_bed elf64_l1om_fbsd_bed
7127 #include "elf64-target.h"
7129 /* Intel K1OM support. */
7132 elf64_k1om_elf_object_p (bfd
*abfd
)
7134 /* Set the right machine number for an K1OM elf64 file. */
7135 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
7139 #undef TARGET_LITTLE_SYM
7140 #define TARGET_LITTLE_SYM k1om_elf64_vec
7141 #undef TARGET_LITTLE_NAME
7142 #define TARGET_LITTLE_NAME "elf64-k1om"
7144 #define ELF_ARCH bfd_arch_k1om
7146 #undef ELF_MACHINE_CODE
7147 #define ELF_MACHINE_CODE EM_K1OM
7152 #define elf64_bed elf64_k1om_bed
7154 #undef elf_backend_object_p
7155 #define elf_backend_object_p elf64_k1om_elf_object_p
7157 #undef elf_backend_static_tls_alignment
7159 #undef elf_backend_want_plt_sym
7160 #define elf_backend_want_plt_sym 0
7162 #include "elf64-target.h"
7164 /* FreeBSD K1OM support. */
7166 #undef TARGET_LITTLE_SYM
7167 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
7168 #undef TARGET_LITTLE_NAME
7169 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
7172 #define ELF_OSABI ELFOSABI_FREEBSD
7175 #define elf64_bed elf64_k1om_fbsd_bed
7177 #include "elf64-target.h"
7179 /* 32bit x86-64 support. */
7181 #undef TARGET_LITTLE_SYM
7182 #define TARGET_LITTLE_SYM x86_64_elf32_vec
7183 #undef TARGET_LITTLE_NAME
7184 #define TARGET_LITTLE_NAME "elf32-x86-64"
7188 #define ELF_ARCH bfd_arch_i386
7190 #undef ELF_MACHINE_CODE
7191 #define ELF_MACHINE_CODE EM_X86_64
7195 #undef elf_backend_object_p
7196 #define elf_backend_object_p \
7197 elf32_x86_64_elf_object_p
7199 #undef elf_backend_bfd_from_remote_memory
7200 #define elf_backend_bfd_from_remote_memory \
7201 _bfd_elf32_bfd_from_remote_memory
7203 #undef elf_backend_size_info
7204 #define elf_backend_size_info \
7205 _bfd_elf32_size_info
7207 #include "elf32-target.h"