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
))
4823 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4824 && !resolved_to_zero
)
4825 || h
->root
.type
!= bfd_link_hash_undefweak
))
4826 && ((! IS_X86_64_PCREL_TYPE (r_type
)
4827 && r_type
!= R_X86_64_SIZE32
4828 && r_type
!= R_X86_64_SIZE64
)
4829 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
4830 || (ELIMINATE_COPY_RELOCS
4831 && !bfd_link_pic (info
)
4835 || eh
->func_pointer_refcount
> 0
4836 || (h
->root
.type
== bfd_link_hash_undefweak
4837 && !resolved_to_zero
))
4838 && ((h
->def_dynamic
&& !h
->def_regular
)
4839 /* Undefined weak symbol is bound locally when
4841 || h
->root
.type
== bfd_link_hash_undefined
)))
4843 Elf_Internal_Rela outrel
;
4844 bfd_boolean skip
, relocate
;
4847 /* When generating a shared object, these relocations
4848 are copied into the output file to be resolved at run
4854 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4856 if (outrel
.r_offset
== (bfd_vma
) -1)
4858 else if (outrel
.r_offset
== (bfd_vma
) -2)
4859 skip
= TRUE
, relocate
= TRUE
;
4861 outrel
.r_offset
+= (input_section
->output_section
->vma
4862 + input_section
->output_offset
);
4865 memset (&outrel
, 0, sizeof outrel
);
4867 /* h->dynindx may be -1 if this symbol was marked to
4871 && (IS_X86_64_PCREL_TYPE (r_type
)
4872 || !(bfd_link_executable (info
)
4873 || SYMBOLIC_BIND (info
, h
))
4874 || ! h
->def_regular
))
4876 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4877 outrel
.r_addend
= rel
->r_addend
;
4881 /* This symbol is local, or marked to become local.
4882 When relocation overflow check is disabled, we
4883 convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */
4884 if (r_type
== htab
->pointer_r_type
4885 || (r_type
== R_X86_64_32
4886 && info
->no_reloc_overflow_check
))
4889 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4890 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4892 else if (r_type
== R_X86_64_64
4893 && !ABI_64_P (output_bfd
))
4896 outrel
.r_info
= htab
->r_info (0,
4897 R_X86_64_RELATIVE64
);
4898 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4899 /* Check addend overflow. */
4900 if ((outrel
.r_addend
& 0x80000000)
4901 != (rel
->r_addend
& 0x80000000))
4904 int addend
= rel
->r_addend
;
4905 if (h
&& h
->root
.root
.string
)
4906 name
= h
->root
.root
.string
;
4908 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4911 (*_bfd_error_handler
)
4912 (_("%B: addend -0x%x in relocation %s against "
4913 "symbol `%s' at 0x%lx in section `%A' is "
4915 input_bfd
, input_section
, addend
,
4917 (unsigned long) rel
->r_offset
);
4919 (*_bfd_error_handler
)
4920 (_("%B: addend 0x%x in relocation %s against "
4921 "symbol `%s' at 0x%lx in section `%A' is "
4923 input_bfd
, input_section
, addend
,
4925 (unsigned long) rel
->r_offset
);
4926 bfd_set_error (bfd_error_bad_value
);
4934 if (bfd_is_abs_section (sec
))
4936 else if (sec
== NULL
|| sec
->owner
== NULL
)
4938 bfd_set_error (bfd_error_bad_value
);
4945 /* We are turning this relocation into one
4946 against a section symbol. It would be
4947 proper to subtract the symbol's value,
4948 osec->vma, from the emitted reloc addend,
4949 but ld.so expects buggy relocs. */
4950 osec
= sec
->output_section
;
4951 sindx
= elf_section_data (osec
)->dynindx
;
4954 asection
*oi
= htab
->elf
.text_index_section
;
4955 sindx
= elf_section_data (oi
)->dynindx
;
4957 BFD_ASSERT (sindx
!= 0);
4960 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
4961 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4965 sreloc
= elf_section_data (input_section
)->sreloc
;
4967 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4969 r
= bfd_reloc_notsupported
;
4970 goto check_relocation_error
;
4973 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4975 /* If this reloc is against an external symbol, we do
4976 not want to fiddle with the addend. Otherwise, we
4977 need to include the symbol value so that it becomes
4978 an addend for the dynamic reloc. */
4985 case R_X86_64_TLSGD
:
4986 case R_X86_64_GOTPC32_TLSDESC
:
4987 case R_X86_64_TLSDESC_CALL
:
4988 case R_X86_64_GOTTPOFF
:
4989 tls_type
= GOT_UNKNOWN
;
4990 if (h
== NULL
&& local_got_offsets
)
4991 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
4993 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
4995 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4996 input_section
, contents
,
4997 symtab_hdr
, sym_hashes
,
4998 &r_type
, tls_type
, rel
,
4999 relend
, h
, r_symndx
, TRUE
))
5002 if (r_type
== R_X86_64_TPOFF32
)
5004 bfd_vma roff
= rel
->r_offset
;
5006 BFD_ASSERT (! unresolved_reloc
);
5008 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5010 /* GD->LE transition. For 64bit, change
5011 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5012 .word 0x6666; rex64; call __tls_get_addr@PLT
5014 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5016 call *__tls_get_addr@GOTPCREL(%rip)
5017 which may be converted to
5018 addr32 call __tls_get_addr
5021 leaq foo@tpoff(%rax), %rax
5023 leaq foo@tlsgd(%rip), %rdi
5024 .word 0x6666; rex64; call __tls_get_addr@PLT
5026 leaq foo@tlsgd(%rip), %rdi
5028 call *__tls_get_addr@GOTPCREL(%rip)
5029 which may be converted to
5030 addr32 call __tls_get_addr
5033 leaq foo@tpoff(%rax), %rax
5034 For largepic, change:
5035 leaq foo@tlsgd(%rip), %rdi
5036 movabsq $__tls_get_addr@pltoff, %rax
5041 leaq foo@tpoff(%rax), %rax
5042 nopw 0x0(%rax,%rax,1) */
5044 if (ABI_64_P (output_bfd
))
5046 if (contents
[roff
+ 5] == 0xb8)
5048 memcpy (contents
+ roff
- 3,
5049 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
5050 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5054 memcpy (contents
+ roff
- 4,
5055 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5059 memcpy (contents
+ roff
- 3,
5060 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5062 bfd_put_32 (output_bfd
,
5063 elf_x86_64_tpoff (info
, relocation
),
5064 contents
+ roff
+ 8 + largepic
);
5065 /* Skip R_X86_64_PC32, R_X86_64_PLT32,
5066 R_X86_64_GOTPCRELX and R_X86_64_PLTOFF64. */
5071 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5073 /* GDesc -> LE transition.
5074 It's originally something like:
5075 leaq x@tlsdesc(%rip), %rax
5078 movl $x@tpoff, %rax. */
5080 unsigned int val
, type
;
5082 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5083 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5084 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
5085 contents
+ roff
- 3);
5086 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
5087 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
5088 contents
+ roff
- 1);
5089 bfd_put_32 (output_bfd
,
5090 elf_x86_64_tpoff (info
, relocation
),
5094 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5096 /* GDesc -> LE transition.
5101 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5102 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5105 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
5107 /* IE->LE transition:
5108 For 64bit, originally it can be one of:
5109 movq foo@gottpoff(%rip), %reg
5110 addq foo@gottpoff(%rip), %reg
5113 leaq foo(%reg), %reg
5115 For 32bit, originally it can be one of:
5116 movq foo@gottpoff(%rip), %reg
5117 addl foo@gottpoff(%rip), %reg
5120 leal foo(%reg), %reg
5123 unsigned int val
, type
, reg
;
5126 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5129 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
5130 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5136 bfd_put_8 (output_bfd
, 0x49,
5137 contents
+ roff
- 3);
5138 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5139 bfd_put_8 (output_bfd
, 0x41,
5140 contents
+ roff
- 3);
5141 bfd_put_8 (output_bfd
, 0xc7,
5142 contents
+ roff
- 2);
5143 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5144 contents
+ roff
- 1);
5148 /* addq/addl -> addq/addl - addressing with %rsp/%r12
5151 bfd_put_8 (output_bfd
, 0x49,
5152 contents
+ roff
- 3);
5153 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5154 bfd_put_8 (output_bfd
, 0x41,
5155 contents
+ roff
- 3);
5156 bfd_put_8 (output_bfd
, 0x81,
5157 contents
+ roff
- 2);
5158 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5159 contents
+ roff
- 1);
5163 /* addq/addl -> leaq/leal */
5165 bfd_put_8 (output_bfd
, 0x4d,
5166 contents
+ roff
- 3);
5167 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5168 bfd_put_8 (output_bfd
, 0x45,
5169 contents
+ roff
- 3);
5170 bfd_put_8 (output_bfd
, 0x8d,
5171 contents
+ roff
- 2);
5172 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
5173 contents
+ roff
- 1);
5175 bfd_put_32 (output_bfd
,
5176 elf_x86_64_tpoff (info
, relocation
),
5184 if (htab
->elf
.sgot
== NULL
)
5189 off
= h
->got
.offset
;
5190 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
5194 if (local_got_offsets
== NULL
)
5197 off
= local_got_offsets
[r_symndx
];
5198 offplt
= local_tlsdesc_gotents
[r_symndx
];
5205 Elf_Internal_Rela outrel
;
5209 if (htab
->elf
.srelgot
== NULL
)
5212 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
5214 if (GOT_TLS_GDESC_P (tls_type
))
5216 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
5217 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
5218 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
5219 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5220 + htab
->elf
.sgotplt
->output_offset
5222 + htab
->sgotplt_jump_table_size
);
5223 sreloc
= htab
->elf
.srelplt
;
5225 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5227 outrel
.r_addend
= 0;
5228 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5231 sreloc
= htab
->elf
.srelgot
;
5233 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5234 + htab
->elf
.sgot
->output_offset
+ off
);
5236 if (GOT_TLS_GD_P (tls_type
))
5237 dr_type
= R_X86_64_DTPMOD64
;
5238 else if (GOT_TLS_GDESC_P (tls_type
))
5241 dr_type
= R_X86_64_TPOFF64
;
5243 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
5244 outrel
.r_addend
= 0;
5245 if ((dr_type
== R_X86_64_TPOFF64
5246 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
5247 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5248 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
5250 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5252 if (GOT_TLS_GD_P (tls_type
))
5256 BFD_ASSERT (! unresolved_reloc
);
5257 bfd_put_64 (output_bfd
,
5258 relocation
- elf_x86_64_dtpoff_base (info
),
5259 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5263 bfd_put_64 (output_bfd
, 0,
5264 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5265 outrel
.r_info
= htab
->r_info (indx
,
5267 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
5268 elf_append_rela (output_bfd
, sreloc
,
5277 local_got_offsets
[r_symndx
] |= 1;
5280 if (off
>= (bfd_vma
) -2
5281 && ! GOT_TLS_GDESC_P (tls_type
))
5283 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
5285 if (r_type
== R_X86_64_GOTPC32_TLSDESC
5286 || r_type
== R_X86_64_TLSDESC_CALL
)
5287 relocation
= htab
->elf
.sgotplt
->output_section
->vma
5288 + htab
->elf
.sgotplt
->output_offset
5289 + offplt
+ htab
->sgotplt_jump_table_size
;
5291 relocation
= htab
->elf
.sgot
->output_section
->vma
5292 + htab
->elf
.sgot
->output_offset
+ off
;
5293 unresolved_reloc
= FALSE
;
5297 bfd_vma roff
= rel
->r_offset
;
5299 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5301 /* GD->IE transition. For 64bit, change
5302 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5303 .word 0x6666; rex64; call __tls_get_addr@PLT
5305 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5307 call *__tls_get_addr@GOTPCREL(%rip
5308 which may be converted to
5309 addr32 call __tls_get_addr
5312 addq foo@gottpoff(%rip), %rax
5314 leaq foo@tlsgd(%rip), %rdi
5315 .word 0x6666; rex64; call __tls_get_addr@PLT
5317 leaq foo@tlsgd(%rip), %rdi
5319 call *__tls_get_addr@GOTPCREL(%rip)
5320 which may be converted to
5321 addr32 call __tls_get_addr
5324 addq foo@gottpoff(%rip), %rax
5325 For largepic, change:
5326 leaq foo@tlsgd(%rip), %rdi
5327 movabsq $__tls_get_addr@pltoff, %rax
5332 addq foo@gottpoff(%rax), %rax
5333 nopw 0x0(%rax,%rax,1) */
5335 if (ABI_64_P (output_bfd
))
5337 if (contents
[roff
+ 5] == 0xb8)
5339 memcpy (contents
+ roff
- 3,
5340 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
5341 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5345 memcpy (contents
+ roff
- 4,
5346 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5350 memcpy (contents
+ roff
- 3,
5351 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5354 relocation
= (htab
->elf
.sgot
->output_section
->vma
5355 + htab
->elf
.sgot
->output_offset
+ off
5358 - input_section
->output_section
->vma
5359 - input_section
->output_offset
5361 bfd_put_32 (output_bfd
, relocation
,
5362 contents
+ roff
+ 8 + largepic
);
5363 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5368 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5370 /* GDesc -> IE transition.
5371 It's originally something like:
5372 leaq x@tlsdesc(%rip), %rax
5375 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
5377 /* Now modify the instruction as appropriate. To
5378 turn a leaq into a movq in the form we use it, it
5379 suffices to change the second byte from 0x8d to
5381 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
5383 bfd_put_32 (output_bfd
,
5384 htab
->elf
.sgot
->output_section
->vma
5385 + htab
->elf
.sgot
->output_offset
+ off
5387 - input_section
->output_section
->vma
5388 - input_section
->output_offset
5393 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5395 /* GDesc -> IE transition.
5402 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5403 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5411 case R_X86_64_TLSLD
:
5412 if (! elf_x86_64_tls_transition (info
, input_bfd
,
5413 input_section
, contents
,
5414 symtab_hdr
, sym_hashes
,
5415 &r_type
, GOT_UNKNOWN
, rel
,
5416 relend
, h
, r_symndx
, TRUE
))
5419 if (r_type
!= R_X86_64_TLSLD
)
5421 /* LD->LE transition:
5422 leaq foo@tlsld(%rip), %rdi
5423 call __tls_get_addr@PLT
5424 For 64bit, we change it into:
5425 .word 0x6666; .byte 0x66; movq %fs:0, %rax
5426 For 32bit, we change it into:
5427 nopl 0x0(%rax); movl %fs:0, %eax
5429 leaq foo@tlsld(%rip), %rdi;
5430 call *__tls_get_addr@GOTPCREL(%rip)
5431 which may be converted to
5432 addr32 call __tls_get_addr
5433 For 64bit, we change it into:
5434 .word 0x6666; .word 0x6666; movq %fs:0, %rax
5435 For 32bit, we change it into:
5436 nopw 0x0(%rax); movl %fs:0, %eax
5437 For largepic, change:
5438 leaq foo@tlsgd(%rip), %rdi
5439 movabsq $__tls_get_addr@pltoff, %rax
5443 data16 data16 data16 nopw %cs:0x0(%rax,%rax,1)
5446 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
5447 if (ABI_64_P (output_bfd
))
5449 if (contents
[rel
->r_offset
+ 5] == 0xb8)
5450 memcpy (contents
+ rel
->r_offset
- 3,
5451 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
5452 "\x64\x48\x8b\x04\x25\0\0\0", 22);
5453 else if (contents
[rel
->r_offset
+ 4] == 0xff
5454 || contents
[rel
->r_offset
+ 4] == 0x67)
5455 memcpy (contents
+ rel
->r_offset
- 3,
5456 "\x66\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0",
5459 memcpy (contents
+ rel
->r_offset
- 3,
5460 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
5464 if (contents
[rel
->r_offset
+ 4] == 0xff)
5465 memcpy (contents
+ rel
->r_offset
- 3,
5466 "\x66\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0",
5469 memcpy (contents
+ rel
->r_offset
- 3,
5470 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
5472 /* Skip R_X86_64_PC32, R_X86_64_PLT32, R_X86_64_GOTPCRELX
5473 and R_X86_64_PLTOFF64. */
5479 if (htab
->elf
.sgot
== NULL
)
5482 off
= htab
->tls_ld_got
.offset
;
5487 Elf_Internal_Rela outrel
;
5489 if (htab
->elf
.srelgot
== NULL
)
5492 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5493 + htab
->elf
.sgot
->output_offset
+ off
);
5495 bfd_put_64 (output_bfd
, 0,
5496 htab
->elf
.sgot
->contents
+ off
);
5497 bfd_put_64 (output_bfd
, 0,
5498 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5499 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
5500 outrel
.r_addend
= 0;
5501 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
5503 htab
->tls_ld_got
.offset
|= 1;
5505 relocation
= htab
->elf
.sgot
->output_section
->vma
5506 + htab
->elf
.sgot
->output_offset
+ off
;
5507 unresolved_reloc
= FALSE
;
5510 case R_X86_64_DTPOFF32
:
5511 if (!bfd_link_executable (info
)
5512 || (input_section
->flags
& SEC_CODE
) == 0)
5513 relocation
-= elf_x86_64_dtpoff_base (info
);
5515 relocation
= elf_x86_64_tpoff (info
, relocation
);
5518 case R_X86_64_TPOFF32
:
5519 case R_X86_64_TPOFF64
:
5520 BFD_ASSERT (bfd_link_executable (info
));
5521 relocation
= elf_x86_64_tpoff (info
, relocation
);
5524 case R_X86_64_DTPOFF64
:
5525 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
5526 relocation
-= elf_x86_64_dtpoff_base (info
);
5533 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5534 because such sections are not SEC_ALLOC and thus ld.so will
5535 not process them. */
5536 if (unresolved_reloc
5537 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
5539 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5540 rel
->r_offset
) != (bfd_vma
) -1)
5542 (*_bfd_error_handler
)
5543 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5546 (long) rel
->r_offset
,
5548 h
->root
.root
.string
);
5553 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5554 contents
, rel
->r_offset
,
5555 relocation
, rel
->r_addend
);
5557 check_relocation_error
:
5558 if (r
!= bfd_reloc_ok
)
5563 name
= h
->root
.root
.string
;
5566 name
= bfd_elf_string_from_elf_section (input_bfd
,
5567 symtab_hdr
->sh_link
,
5572 name
= bfd_section_name (input_bfd
, sec
);
5575 if (r
== bfd_reloc_overflow
)
5576 (*info
->callbacks
->reloc_overflow
)
5577 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5578 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
5581 (*_bfd_error_handler
)
5582 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5583 input_bfd
, input_section
,
5584 (long) rel
->r_offset
, name
, (int) r
);
5595 Elf_Internal_Shdr
*rel_hdr
;
5596 size_t deleted
= rel
- wrel
;
5598 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
5599 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5600 if (rel_hdr
->sh_size
== 0)
5602 /* It is too late to remove an empty reloc section. Leave
5604 ??? What is wrong with an empty section??? */
5605 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
5608 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5609 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5610 input_section
->reloc_count
-= deleted
;
5616 /* Finish up dynamic symbol handling. We set the contents of various
5617 dynamic sections here. */
5620 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
5621 struct bfd_link_info
*info
,
5622 struct elf_link_hash_entry
*h
,
5623 Elf_Internal_Sym
*sym
)
5625 struct elf_x86_64_link_hash_table
*htab
;
5626 const struct elf_x86_64_backend_data
*abed
;
5627 bfd_boolean use_plt_bnd
;
5628 struct elf_x86_64_link_hash_entry
*eh
;
5629 bfd_boolean local_undefweak
;
5631 htab
= elf_x86_64_hash_table (info
);
5635 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5636 section only if there is .plt section. */
5637 use_plt_bnd
= htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
;
5639 ? &elf_x86_64_bnd_arch_bed
5640 : get_elf_x86_64_backend_data (output_bfd
));
5642 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
5644 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5645 resolved undefined weak symbols in executable so that their
5646 references have value 0 at run-time. */
5647 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
5651 if (h
->plt
.offset
!= (bfd_vma
) -1)
5654 bfd_vma got_offset
, plt_offset
, plt_plt_offset
, plt_got_offset
;
5655 bfd_vma plt_plt_insn_end
, plt_got_insn_size
;
5656 Elf_Internal_Rela rela
;
5658 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
5659 const struct elf_backend_data
*bed
;
5660 bfd_vma plt_got_pcrel_offset
;
5662 /* When building a static executable, use .iplt, .igot.plt and
5663 .rela.iplt sections for STT_GNU_IFUNC symbols. */
5664 if (htab
->elf
.splt
!= NULL
)
5666 plt
= htab
->elf
.splt
;
5667 gotplt
= htab
->elf
.sgotplt
;
5668 relplt
= htab
->elf
.srelplt
;
5672 plt
= htab
->elf
.iplt
;
5673 gotplt
= htab
->elf
.igotplt
;
5674 relplt
= htab
->elf
.irelplt
;
5677 /* This symbol has an entry in the procedure linkage table. Set
5679 if ((h
->dynindx
== -1
5681 && !((h
->forced_local
|| bfd_link_executable (info
))
5683 && h
->type
== STT_GNU_IFUNC
))
5689 /* Get the index in the procedure linkage table which
5690 corresponds to this symbol. This is the index of this symbol
5691 in all the symbols for which we are making plt entries. The
5692 first entry in the procedure linkage table is reserved.
5694 Get the offset into the .got table of the entry that
5695 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
5696 bytes. The first three are reserved for the dynamic linker.
5698 For static executables, we don't reserve anything. */
5700 if (plt
== htab
->elf
.splt
)
5702 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
5703 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
5707 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
5708 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
5711 plt_plt_insn_end
= abed
->plt_plt_insn_end
;
5712 plt_plt_offset
= abed
->plt_plt_offset
;
5713 plt_got_insn_size
= abed
->plt_got_insn_size
;
5714 plt_got_offset
= abed
->plt_got_offset
;
5717 /* Use the second PLT with BND relocations. */
5718 const bfd_byte
*plt_entry
, *plt2_entry
;
5720 if (eh
->has_bnd_reloc
)
5722 plt_entry
= elf_x86_64_bnd_plt_entry
;
5723 plt2_entry
= elf_x86_64_bnd_plt2_entry
;
5727 plt_entry
= elf_x86_64_legacy_plt_entry
;
5728 plt2_entry
= elf_x86_64_legacy_plt2_entry
;
5730 /* Subtract 1 since there is no BND prefix. */
5731 plt_plt_insn_end
-= 1;
5732 plt_plt_offset
-= 1;
5733 plt_got_insn_size
-= 1;
5734 plt_got_offset
-= 1;
5737 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry
)
5738 == sizeof (elf_x86_64_legacy_plt_entry
));
5740 /* Fill in the entry in the procedure linkage table. */
5741 memcpy (plt
->contents
+ h
->plt
.offset
,
5742 plt_entry
, sizeof (elf_x86_64_legacy_plt_entry
));
5743 /* Fill in the entry in the second PLT. */
5744 memcpy (htab
->plt_bnd
->contents
+ eh
->plt_bnd
.offset
,
5745 plt2_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5747 resolved_plt
= htab
->plt_bnd
;
5748 plt_offset
= eh
->plt_bnd
.offset
;
5752 /* Fill in the entry in the procedure linkage table. */
5753 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
5754 abed
->plt_entry_size
);
5757 plt_offset
= h
->plt
.offset
;
5760 /* Insert the relocation positions of the plt section. */
5762 /* Put offset the PC-relative instruction referring to the GOT entry,
5763 subtracting the size of that instruction. */
5764 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
5765 + gotplt
->output_offset
5767 - resolved_plt
->output_section
->vma
5768 - resolved_plt
->output_offset
5770 - plt_got_insn_size
);
5772 /* Check PC-relative offset overflow in PLT entry. */
5773 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
5774 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5775 output_bfd
, h
->root
.root
.string
);
5777 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
5778 resolved_plt
->contents
+ plt_offset
+ plt_got_offset
);
5780 /* Fill in the entry in the global offset table, initially this
5781 points to the second part of the PLT entry. Leave the entry
5782 as zero for undefined weak symbol in PIE. No PLT relocation
5783 against undefined weak symbol in PIE. */
5784 if (!local_undefweak
)
5786 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5787 + plt
->output_offset
5789 + abed
->plt_lazy_offset
),
5790 gotplt
->contents
+ got_offset
);
5792 /* Fill in the entry in the .rela.plt section. */
5793 rela
.r_offset
= (gotplt
->output_section
->vma
5794 + gotplt
->output_offset
5796 if (h
->dynindx
== -1
5797 || ((bfd_link_executable (info
)
5798 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5800 && h
->type
== STT_GNU_IFUNC
))
5802 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5803 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
5804 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
5805 rela
.r_addend
= (h
->root
.u
.def
.value
5806 + h
->root
.u
.def
.section
->output_section
->vma
5807 + h
->root
.u
.def
.section
->output_offset
);
5808 /* R_X86_64_IRELATIVE comes last. */
5809 plt_index
= htab
->next_irelative_index
--;
5813 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
5815 plt_index
= htab
->next_jump_slot_index
++;
5818 /* Don't fill PLT entry for static executables. */
5819 if (plt
== htab
->elf
.splt
)
5821 bfd_vma plt0_offset
= h
->plt
.offset
+ plt_plt_insn_end
;
5823 /* Put relocation index. */
5824 bfd_put_32 (output_bfd
, plt_index
,
5825 (plt
->contents
+ h
->plt
.offset
5826 + abed
->plt_reloc_offset
));
5828 /* Put offset for jmp .PLT0 and check for overflow. We don't
5829 check relocation index for overflow since branch displacement
5830 will overflow first. */
5831 if (plt0_offset
> 0x80000000)
5832 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5833 output_bfd
, h
->root
.root
.string
);
5834 bfd_put_32 (output_bfd
, - plt0_offset
,
5835 plt
->contents
+ h
->plt
.offset
+ plt_plt_offset
);
5838 bed
= get_elf_backend_data (output_bfd
);
5839 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
5840 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
5843 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5845 bfd_vma got_offset
, plt_offset
, plt_got_offset
, plt_got_insn_size
;
5846 asection
*plt
, *got
;
5847 bfd_boolean got_after_plt
;
5848 int32_t got_pcrel_offset
;
5849 const bfd_byte
*got_plt_entry
;
5851 /* Set the entry in the GOT procedure linkage table. */
5852 plt
= htab
->plt_got
;
5853 got
= htab
->elf
.sgot
;
5854 got_offset
= h
->got
.offset
;
5856 if (got_offset
== (bfd_vma
) -1
5857 || h
->type
== STT_GNU_IFUNC
5862 /* Use the second PLT entry template for the GOT PLT since they
5863 are the identical. */
5864 plt_got_insn_size
= elf_x86_64_bnd_arch_bed
.plt_got_insn_size
;
5865 plt_got_offset
= elf_x86_64_bnd_arch_bed
.plt_got_offset
;
5866 if (eh
->has_bnd_reloc
)
5867 got_plt_entry
= elf_x86_64_bnd_plt2_entry
;
5870 got_plt_entry
= elf_x86_64_legacy_plt2_entry
;
5872 /* Subtract 1 since there is no BND prefix. */
5873 plt_got_insn_size
-= 1;
5874 plt_got_offset
-= 1;
5877 /* Fill in the entry in the GOT procedure linkage table. */
5878 plt_offset
= eh
->plt_got
.offset
;
5879 memcpy (plt
->contents
+ plt_offset
,
5880 got_plt_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5882 /* Put offset the PC-relative instruction referring to the GOT
5883 entry, subtracting the size of that instruction. */
5884 got_pcrel_offset
= (got
->output_section
->vma
5885 + got
->output_offset
5887 - plt
->output_section
->vma
5888 - plt
->output_offset
5890 - plt_got_insn_size
);
5892 /* Check PC-relative offset overflow in GOT PLT entry. */
5893 got_after_plt
= got
->output_section
->vma
> plt
->output_section
->vma
;
5894 if ((got_after_plt
&& got_pcrel_offset
< 0)
5895 || (!got_after_plt
&& got_pcrel_offset
> 0))
5896 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
5897 output_bfd
, h
->root
.root
.string
);
5899 bfd_put_32 (output_bfd
, got_pcrel_offset
,
5900 plt
->contents
+ plt_offset
+ plt_got_offset
);
5903 if (!local_undefweak
5905 && (h
->plt
.offset
!= (bfd_vma
) -1
5906 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5908 /* Mark the symbol as undefined, rather than as defined in
5909 the .plt section. Leave the value if there were any
5910 relocations where pointer equality matters (this is a clue
5911 for the dynamic linker, to make function pointer
5912 comparisons work between an application and shared
5913 library), otherwise set it to zero. If a function is only
5914 called from a binary, there is no need to slow down
5915 shared libraries because of that. */
5916 sym
->st_shndx
= SHN_UNDEF
;
5917 if (!h
->pointer_equality_needed
)
5921 /* Don't generate dynamic GOT relocation against undefined weak
5922 symbol in executable. */
5923 if (h
->got
.offset
!= (bfd_vma
) -1
5924 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
5925 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
5926 && !local_undefweak
)
5928 Elf_Internal_Rela rela
;
5929 asection
*relgot
= htab
->elf
.srelgot
;
5931 /* This symbol has an entry in the global offset table. Set it
5933 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5936 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5937 + htab
->elf
.sgot
->output_offset
5938 + (h
->got
.offset
&~ (bfd_vma
) 1));
5940 /* If this is a static link, or it is a -Bsymbolic link and the
5941 symbol is defined locally or was forced to be local because
5942 of a version file, we just want to emit a RELATIVE reloc.
5943 The entry in the global offset table will already have been
5944 initialized in the relocate_section function. */
5946 && h
->type
== STT_GNU_IFUNC
)
5948 if (h
->plt
.offset
== (bfd_vma
) -1)
5950 /* STT_GNU_IFUNC is referenced without PLT. */
5951 if (htab
->elf
.splt
== NULL
)
5953 /* use .rel[a].iplt section to store .got relocations
5954 in static executable. */
5955 relgot
= htab
->elf
.irelplt
;
5957 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
5959 rela
.r_info
= htab
->r_info (0,
5960 R_X86_64_IRELATIVE
);
5961 rela
.r_addend
= (h
->root
.u
.def
.value
5962 + h
->root
.u
.def
.section
->output_section
->vma
5963 + h
->root
.u
.def
.section
->output_offset
);
5968 else if (bfd_link_pic (info
))
5970 /* Generate R_X86_64_GLOB_DAT. */
5977 if (!h
->pointer_equality_needed
)
5980 /* For non-shared object, we can't use .got.plt, which
5981 contains the real function addres if we need pointer
5982 equality. We load the GOT entry with the PLT entry. */
5983 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5984 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5985 + plt
->output_offset
5987 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5991 else if (bfd_link_pic (info
)
5992 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5994 if (!h
->def_regular
)
5996 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5997 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
5998 rela
.r_addend
= (h
->root
.u
.def
.value
5999 + h
->root
.u
.def
.section
->output_section
->vma
6000 + h
->root
.u
.def
.section
->output_offset
);
6004 BFD_ASSERT((h
->got
.offset
& 1) == 0);
6006 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6007 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
6008 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
6012 elf_append_rela (output_bfd
, relgot
, &rela
);
6017 Elf_Internal_Rela rela
;
6019 /* This symbol needs a copy reloc. Set it up. */
6021 if (h
->dynindx
== -1
6022 || (h
->root
.type
!= bfd_link_hash_defined
6023 && h
->root
.type
!= bfd_link_hash_defweak
)
6024 || htab
->srelbss
== NULL
)
6027 rela
.r_offset
= (h
->root
.u
.def
.value
6028 + h
->root
.u
.def
.section
->output_section
->vma
6029 + h
->root
.u
.def
.section
->output_offset
);
6030 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
6032 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
6038 /* Finish up local dynamic symbol handling. We set the contents of
6039 various dynamic sections here. */
6042 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
6044 struct elf_link_hash_entry
*h
6045 = (struct elf_link_hash_entry
*) *slot
;
6046 struct bfd_link_info
*info
6047 = (struct bfd_link_info
*) inf
;
6049 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
6053 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
6054 here since undefined weak symbol may not be dynamic and may not be
6055 called for elf_x86_64_finish_dynamic_symbol. */
6058 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
6061 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
6062 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
6064 if (h
->root
.type
!= bfd_link_hash_undefweak
6065 || h
->dynindx
!= -1)
6068 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
6072 /* Used to decide how to sort relocs in an optimal manner for the
6073 dynamic linker, before writing them out. */
6075 static enum elf_reloc_type_class
6076 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info
,
6077 const asection
*rel_sec ATTRIBUTE_UNUSED
,
6078 const Elf_Internal_Rela
*rela
)
6080 bfd
*abfd
= info
->output_bfd
;
6081 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6082 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
6084 if (htab
->elf
.dynsym
!= NULL
6085 && htab
->elf
.dynsym
->contents
!= NULL
)
6087 /* Check relocation against STT_GNU_IFUNC symbol if there are
6089 unsigned long r_symndx
= htab
->r_sym (rela
->r_info
);
6090 if (r_symndx
!= STN_UNDEF
)
6092 Elf_Internal_Sym sym
;
6093 if (!bed
->s
->swap_symbol_in (abfd
,
6094 (htab
->elf
.dynsym
->contents
6095 + r_symndx
* bed
->s
->sizeof_sym
),
6099 if (ELF_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
6100 return reloc_class_ifunc
;
6104 switch ((int) ELF32_R_TYPE (rela
->r_info
))
6106 case R_X86_64_IRELATIVE
:
6107 return reloc_class_ifunc
;
6108 case R_X86_64_RELATIVE
:
6109 case R_X86_64_RELATIVE64
:
6110 return reloc_class_relative
;
6111 case R_X86_64_JUMP_SLOT
:
6112 return reloc_class_plt
;
6114 return reloc_class_copy
;
6116 return reloc_class_normal
;
6120 /* Finish up the dynamic sections. */
6123 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
6124 struct bfd_link_info
*info
)
6126 struct elf_x86_64_link_hash_table
*htab
;
6129 const struct elf_x86_64_backend_data
*abed
;
6131 htab
= elf_x86_64_hash_table (info
);
6135 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
6136 section only if there is .plt section. */
6137 abed
= (htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
6138 ? &elf_x86_64_bnd_arch_bed
6139 : get_elf_x86_64_backend_data (output_bfd
));
6141 dynobj
= htab
->elf
.dynobj
;
6142 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
6144 if (htab
->elf
.dynamic_sections_created
)
6146 bfd_byte
*dyncon
, *dynconend
;
6147 const struct elf_backend_data
*bed
;
6148 bfd_size_type sizeof_dyn
;
6150 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
6153 bed
= get_elf_backend_data (dynobj
);
6154 sizeof_dyn
= bed
->s
->sizeof_dyn
;
6155 dyncon
= sdyn
->contents
;
6156 dynconend
= sdyn
->contents
+ sdyn
->size
;
6157 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
6159 Elf_Internal_Dyn dyn
;
6162 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
6170 s
= htab
->elf
.sgotplt
;
6171 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
6175 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
6179 s
= htab
->elf
.srelplt
->output_section
;
6180 dyn
.d_un
.d_val
= s
->size
;
6184 /* The procedure linkage table relocs (DT_JMPREL) should
6185 not be included in the overall relocs (DT_RELA).
6186 Therefore, we override the DT_RELASZ entry here to
6187 make it not include the JMPREL relocs. Since the
6188 linker script arranges for .rela.plt to follow all
6189 other relocation sections, we don't have to worry
6190 about changing the DT_RELA entry. */
6191 if (htab
->elf
.srelplt
!= NULL
)
6193 s
= htab
->elf
.srelplt
->output_section
;
6194 dyn
.d_un
.d_val
-= s
->size
;
6198 case DT_TLSDESC_PLT
:
6200 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6201 + htab
->tlsdesc_plt
;
6204 case DT_TLSDESC_GOT
:
6206 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6207 + htab
->tlsdesc_got
;
6211 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
6214 /* Fill in the special first entry in the procedure linkage table. */
6215 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
6217 /* Fill in the first entry in the procedure linkage table. */
6218 memcpy (htab
->elf
.splt
->contents
,
6219 abed
->plt0_entry
, abed
->plt_entry_size
);
6220 /* Add offset for pushq GOT+8(%rip), since the instruction
6221 uses 6 bytes subtract this value. */
6222 bfd_put_32 (output_bfd
,
6223 (htab
->elf
.sgotplt
->output_section
->vma
6224 + htab
->elf
.sgotplt
->output_offset
6226 - htab
->elf
.splt
->output_section
->vma
6227 - htab
->elf
.splt
->output_offset
6229 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
6230 /* Add offset for the PC-relative instruction accessing GOT+16,
6231 subtracting the offset to the end of that instruction. */
6232 bfd_put_32 (output_bfd
,
6233 (htab
->elf
.sgotplt
->output_section
->vma
6234 + htab
->elf
.sgotplt
->output_offset
6236 - htab
->elf
.splt
->output_section
->vma
6237 - htab
->elf
.splt
->output_offset
6238 - abed
->plt0_got2_insn_end
),
6239 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
6241 elf_section_data (htab
->elf
.splt
->output_section
)
6242 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
6244 if (htab
->tlsdesc_plt
)
6246 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6247 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
6249 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
6250 abed
->plt0_entry
, abed
->plt_entry_size
);
6252 /* Add offset for pushq GOT+8(%rip), since the
6253 instruction uses 6 bytes subtract this value. */
6254 bfd_put_32 (output_bfd
,
6255 (htab
->elf
.sgotplt
->output_section
->vma
6256 + htab
->elf
.sgotplt
->output_offset
6258 - htab
->elf
.splt
->output_section
->vma
6259 - htab
->elf
.splt
->output_offset
6262 htab
->elf
.splt
->contents
6263 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
6264 /* Add offset for the PC-relative instruction accessing GOT+TDG,
6265 where TGD stands for htab->tlsdesc_got, subtracting the offset
6266 to the end of that instruction. */
6267 bfd_put_32 (output_bfd
,
6268 (htab
->elf
.sgot
->output_section
->vma
6269 + htab
->elf
.sgot
->output_offset
6271 - htab
->elf
.splt
->output_section
->vma
6272 - htab
->elf
.splt
->output_offset
6274 - abed
->plt0_got2_insn_end
),
6275 htab
->elf
.splt
->contents
6276 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
6281 if (htab
->plt_bnd
!= NULL
)
6282 elf_section_data (htab
->plt_bnd
->output_section
)
6283 ->this_hdr
.sh_entsize
= sizeof (elf_x86_64_bnd_plt2_entry
);
6285 if (htab
->elf
.sgotplt
)
6287 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
6289 (*_bfd_error_handler
)
6290 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
6294 /* Fill in the first three entries in the global offset table. */
6295 if (htab
->elf
.sgotplt
->size
> 0)
6297 /* Set the first entry in the global offset table to the address of
6298 the dynamic section. */
6300 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
6302 bfd_put_64 (output_bfd
,
6303 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
6304 htab
->elf
.sgotplt
->contents
);
6305 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
6306 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
6307 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
6310 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
6314 /* Adjust .eh_frame for .plt section. */
6315 if (htab
->plt_eh_frame
!= NULL
6316 && htab
->plt_eh_frame
->contents
!= NULL
)
6318 if (htab
->elf
.splt
!= NULL
6319 && htab
->elf
.splt
->size
!= 0
6320 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
6321 && htab
->elf
.splt
->output_section
!= NULL
6322 && htab
->plt_eh_frame
->output_section
!= NULL
)
6324 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
6325 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
6326 + htab
->plt_eh_frame
->output_offset
6327 + PLT_FDE_START_OFFSET
;
6328 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6329 htab
->plt_eh_frame
->contents
6330 + PLT_FDE_START_OFFSET
);
6332 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
6334 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6336 htab
->plt_eh_frame
->contents
))
6341 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
6342 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
6345 /* Fill PLT entries for undefined weak symbols in PIE. */
6346 if (bfd_link_pie (info
))
6347 bfd_hash_traverse (&info
->hash
->table
,
6348 elf_x86_64_pie_finish_undefweak_symbol
,
6354 /* Fill PLT/GOT entries and allocate dynamic relocations for local
6355 STT_GNU_IFUNC symbols, which aren't in the ELF linker hash table.
6356 It has to be done before elf_link_sort_relocs is called so that
6357 dynamic relocations are properly sorted. */
6360 elf_x86_64_output_arch_local_syms
6361 (bfd
*output_bfd ATTRIBUTE_UNUSED
,
6362 struct bfd_link_info
*info
,
6363 void *flaginfo ATTRIBUTE_UNUSED
,
6364 int (*func
) (void *, const char *,
6367 struct elf_link_hash_entry
*) ATTRIBUTE_UNUSED
)
6369 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
6373 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
6374 htab_traverse (htab
->loc_hash_table
,
6375 elf_x86_64_finish_local_dynamic_symbol
,
6381 /* Return an array of PLT entry symbol values. */
6384 elf_x86_64_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
6387 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
6390 bfd_vma
*plt_sym_val
;
6392 bfd_byte
*plt_contents
;
6393 const struct elf_x86_64_backend_data
*bed
;
6394 Elf_Internal_Shdr
*hdr
;
6397 /* Get the .plt section contents. PLT passed down may point to the
6398 .plt.bnd section. Make sure that PLT always points to the .plt
6400 plt_bnd
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6405 plt
= bfd_get_section_by_name (abfd
, ".plt");
6408 bed
= &elf_x86_64_bnd_arch_bed
;
6411 bed
= get_elf_x86_64_backend_data (abfd
);
6413 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
6414 if (plt_contents
== NULL
)
6416 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
6417 plt_contents
, 0, plt
->size
))
6420 free (plt_contents
);
6424 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
6425 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
6428 hdr
= &elf_section_data (relplt
)->this_hdr
;
6429 count
= relplt
->size
/ hdr
->sh_entsize
;
6431 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
6432 if (plt_sym_val
== NULL
)
6435 for (i
= 0; i
< count
; i
++)
6436 plt_sym_val
[i
] = -1;
6438 plt_offset
= bed
->plt_entry_size
;
6439 p
= relplt
->relocation
;
6440 for (i
= 0; i
< count
; i
++, p
++)
6444 /* Skip unknown relocation. */
6445 if (p
->howto
== NULL
)
6448 if (p
->howto
->type
!= R_X86_64_JUMP_SLOT
6449 && p
->howto
->type
!= R_X86_64_IRELATIVE
)
6452 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
6453 + bed
->plt_reloc_offset
));
6454 if (reloc_index
< count
)
6458 /* This is the index in .plt section. */
6459 long plt_index
= plt_offset
/ bed
->plt_entry_size
;
6460 /* Store VMA + the offset in .plt.bnd section. */
6461 plt_sym_val
[reloc_index
] =
6463 + (plt_index
- 1) * sizeof (elf_x86_64_legacy_plt2_entry
));
6466 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
6468 plt_offset
+= bed
->plt_entry_size
;
6470 /* PR binutils/18437: Skip extra relocations in the .rela.plt
6472 if (plt_offset
>= plt
->size
)
6476 free (plt_contents
);
6481 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
6485 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
6492 /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
6493 as PLT if it exists. */
6494 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6496 plt
= bfd_get_section_by_name (abfd
, ".plt");
6497 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
6498 dynsymcount
, dynsyms
, ret
,
6500 elf_x86_64_get_plt_sym_val
);
6503 /* Handle an x86-64 specific section when reading an object file. This
6504 is called when elfcode.h finds a section with an unknown type. */
6507 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
6508 const char *name
, int shindex
)
6510 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
6513 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
6519 /* Hook called by the linker routine which adds symbols from an object
6520 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
6524 elf_x86_64_add_symbol_hook (bfd
*abfd
,
6525 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6526 Elf_Internal_Sym
*sym
,
6527 const char **namep ATTRIBUTE_UNUSED
,
6528 flagword
*flagsp ATTRIBUTE_UNUSED
,
6534 switch (sym
->st_shndx
)
6536 case SHN_X86_64_LCOMMON
:
6537 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
6540 lcomm
= bfd_make_section_with_flags (abfd
,
6544 | SEC_LINKER_CREATED
));
6547 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
6550 *valp
= sym
->st_size
;
6558 /* Given a BFD section, try to locate the corresponding ELF section
6562 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
6563 asection
*sec
, int *index_return
)
6565 if (sec
== &_bfd_elf_large_com_section
)
6567 *index_return
= SHN_X86_64_LCOMMON
;
6573 /* Process a symbol. */
6576 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
6579 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
6581 switch (elfsym
->internal_elf_sym
.st_shndx
)
6583 case SHN_X86_64_LCOMMON
:
6584 asym
->section
= &_bfd_elf_large_com_section
;
6585 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
6586 /* Common symbol doesn't set BSF_GLOBAL. */
6587 asym
->flags
&= ~BSF_GLOBAL
;
6593 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
6595 return (sym
->st_shndx
== SHN_COMMON
6596 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
6600 elf_x86_64_common_section_index (asection
*sec
)
6602 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6605 return SHN_X86_64_LCOMMON
;
6609 elf_x86_64_common_section (asection
*sec
)
6611 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6612 return bfd_com_section_ptr
;
6614 return &_bfd_elf_large_com_section
;
6618 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
6619 const Elf_Internal_Sym
*sym
,
6624 const asection
*oldsec
)
6626 /* A normal common symbol and a large common symbol result in a
6627 normal common symbol. We turn the large common symbol into a
6630 && h
->root
.type
== bfd_link_hash_common
6632 && bfd_is_com_section (*psec
)
6635 if (sym
->st_shndx
== SHN_COMMON
6636 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
6638 h
->root
.u
.c
.p
->section
6639 = bfd_make_section_old_way (oldbfd
, "COMMON");
6640 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
6642 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
6643 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
6644 *psec
= bfd_com_section_ptr
;
6651 elf_x86_64_additional_program_headers (bfd
*abfd
,
6652 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6657 /* Check to see if we need a large readonly segment. */
6658 s
= bfd_get_section_by_name (abfd
, ".lrodata");
6659 if (s
&& (s
->flags
& SEC_LOAD
))
6662 /* Check to see if we need a large data segment. Since .lbss sections
6663 is placed right after the .bss section, there should be no need for
6664 a large data segment just because of .lbss. */
6665 s
= bfd_get_section_by_name (abfd
, ".ldata");
6666 if (s
&& (s
->flags
& SEC_LOAD
))
6672 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6675 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
6677 if (h
->plt
.offset
!= (bfd_vma
) -1
6679 && !h
->pointer_equality_needed
)
6682 return _bfd_elf_hash_symbol (h
);
6685 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
6688 elf_x86_64_relocs_compatible (const bfd_target
*input
,
6689 const bfd_target
*output
)
6691 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
6692 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
6693 && _bfd_elf_relocs_compatible (input
, output
));
6696 static const struct bfd_elf_special_section
6697 elf_x86_64_special_sections
[]=
6699 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6700 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6701 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
6702 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6703 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6704 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6705 { NULL
, 0, 0, 0, 0 }
6708 #define TARGET_LITTLE_SYM x86_64_elf64_vec
6709 #define TARGET_LITTLE_NAME "elf64-x86-64"
6710 #define ELF_ARCH bfd_arch_i386
6711 #define ELF_TARGET_ID X86_64_ELF_DATA
6712 #define ELF_MACHINE_CODE EM_X86_64
6713 #define ELF_MAXPAGESIZE 0x200000
6714 #define ELF_MINPAGESIZE 0x1000
6715 #define ELF_COMMONPAGESIZE 0x1000
6717 #define elf_backend_can_gc_sections 1
6718 #define elf_backend_can_refcount 1
6719 #define elf_backend_want_got_plt 1
6720 #define elf_backend_plt_readonly 1
6721 #define elf_backend_want_plt_sym 0
6722 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
6723 #define elf_backend_rela_normal 1
6724 #define elf_backend_plt_alignment 4
6725 #define elf_backend_extern_protected_data 1
6726 #define elf_backend_caches_rawsize 1
6728 #define elf_info_to_howto elf_x86_64_info_to_howto
6730 #define bfd_elf64_bfd_link_hash_table_create \
6731 elf_x86_64_link_hash_table_create
6732 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
6733 #define bfd_elf64_bfd_reloc_name_lookup \
6734 elf_x86_64_reloc_name_lookup
6736 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
6737 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
6738 #define elf_backend_check_relocs elf_x86_64_check_relocs
6739 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
6740 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
6741 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
6742 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
6743 #define elf_backend_output_arch_local_syms elf_x86_64_output_arch_local_syms
6744 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
6745 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
6746 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
6748 #define elf_backend_write_core_note elf_x86_64_write_core_note
6750 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
6751 #define elf_backend_relocate_section elf_x86_64_relocate_section
6752 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
6753 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
6754 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
6755 #define elf_backend_object_p elf64_x86_64_elf_object_p
6756 #define bfd_elf64_mkobject elf_x86_64_mkobject
6757 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
6759 #define elf_backend_section_from_shdr \
6760 elf_x86_64_section_from_shdr
6762 #define elf_backend_section_from_bfd_section \
6763 elf_x86_64_elf_section_from_bfd_section
6764 #define elf_backend_add_symbol_hook \
6765 elf_x86_64_add_symbol_hook
6766 #define elf_backend_symbol_processing \
6767 elf_x86_64_symbol_processing
6768 #define elf_backend_common_section_index \
6769 elf_x86_64_common_section_index
6770 #define elf_backend_common_section \
6771 elf_x86_64_common_section
6772 #define elf_backend_common_definition \
6773 elf_x86_64_common_definition
6774 #define elf_backend_merge_symbol \
6775 elf_x86_64_merge_symbol
6776 #define elf_backend_special_sections \
6777 elf_x86_64_special_sections
6778 #define elf_backend_additional_program_headers \
6779 elf_x86_64_additional_program_headers
6780 #define elf_backend_hash_symbol \
6781 elf_x86_64_hash_symbol
6782 #define elf_backend_omit_section_dynsym \
6783 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6784 #define elf_backend_fixup_symbol \
6785 elf_x86_64_fixup_symbol
6787 #include "elf64-target.h"
6789 /* CloudABI support. */
6791 #undef TARGET_LITTLE_SYM
6792 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
6793 #undef TARGET_LITTLE_NAME
6794 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
6797 #define ELF_OSABI ELFOSABI_CLOUDABI
6800 #define elf64_bed elf64_x86_64_cloudabi_bed
6802 #include "elf64-target.h"
6804 /* FreeBSD support. */
6806 #undef TARGET_LITTLE_SYM
6807 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
6808 #undef TARGET_LITTLE_NAME
6809 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
6812 #define ELF_OSABI ELFOSABI_FREEBSD
6815 #define elf64_bed elf64_x86_64_fbsd_bed
6817 #include "elf64-target.h"
6819 /* Solaris 2 support. */
6821 #undef TARGET_LITTLE_SYM
6822 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
6823 #undef TARGET_LITTLE_NAME
6824 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
6826 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6827 objects won't be recognized. */
6831 #define elf64_bed elf64_x86_64_sol2_bed
6833 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
6835 #undef elf_backend_static_tls_alignment
6836 #define elf_backend_static_tls_alignment 16
6838 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6840 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6842 #undef elf_backend_want_plt_sym
6843 #define elf_backend_want_plt_sym 1
6845 #undef elf_backend_strtab_flags
6846 #define elf_backend_strtab_flags SHF_STRINGS
6849 elf64_x86_64_copy_solaris_special_section_fields (const bfd
*ibfd ATTRIBUTE_UNUSED
,
6850 bfd
*obfd ATTRIBUTE_UNUSED
,
6851 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
6852 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
6854 /* PR 19938: FIXME: Need to add code for setting the sh_info
6855 and sh_link fields of Solaris specific section types. */
6859 #undef elf_backend_copy_special_section_fields
6860 #define elf_backend_copy_special_section_fields elf64_x86_64_copy_solaris_special_section_fields
6862 #include "elf64-target.h"
6864 /* Native Client support. */
6867 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
6869 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
6870 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
6874 #undef TARGET_LITTLE_SYM
6875 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
6876 #undef TARGET_LITTLE_NAME
6877 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
6879 #define elf64_bed elf64_x86_64_nacl_bed
6881 #undef ELF_MAXPAGESIZE
6882 #undef ELF_MINPAGESIZE
6883 #undef ELF_COMMONPAGESIZE
6884 #define ELF_MAXPAGESIZE 0x10000
6885 #define ELF_MINPAGESIZE 0x10000
6886 #define ELF_COMMONPAGESIZE 0x10000
6888 /* Restore defaults. */
6890 #undef elf_backend_static_tls_alignment
6891 #undef elf_backend_want_plt_sym
6892 #define elf_backend_want_plt_sym 0
6893 #undef elf_backend_strtab_flags
6894 #undef elf_backend_copy_special_section_fields
6896 /* NaCl uses substantially different PLT entries for the same effects. */
6898 #undef elf_backend_plt_alignment
6899 #define elf_backend_plt_alignment 5
6900 #define NACL_PLT_ENTRY_SIZE 64
6901 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6903 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
6905 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
6906 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
6907 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6908 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6909 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6911 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
6912 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
6914 /* 32 bytes of nop to pad out to the standard size. */
6915 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6916 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
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, /* excess data16 prefix */
6923 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6925 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
6926 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6927 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6928 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6930 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
6931 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6932 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6934 /* Lazy GOT entries point here (32-byte aligned). */
6935 0x68, /* pushq immediate */
6936 0, 0, 0, 0, /* replaced with index into relocation table. */
6937 0xe9, /* jmp relative */
6938 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
6940 /* 22 bytes of nop to pad out to the standard size. */
6941 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6942 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6943 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
6946 /* .eh_frame covering the .plt section. */
6948 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
6950 #if (PLT_CIE_LENGTH != 20 \
6951 || PLT_FDE_LENGTH != 36 \
6952 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6953 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6954 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
6956 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6957 0, 0, 0, 0, /* CIE ID */
6958 1, /* CIE version */
6959 'z', 'R', 0, /* Augmentation string */
6960 1, /* Code alignment factor */
6961 0x78, /* Data alignment factor */
6962 16, /* Return address column */
6963 1, /* Augmentation size */
6964 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6965 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
6966 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
6967 DW_CFA_nop
, DW_CFA_nop
,
6969 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6970 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
6971 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
6972 0, 0, 0, 0, /* .plt size goes here */
6973 0, /* Augmentation size */
6974 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
6975 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6976 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
6977 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6978 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6979 13, /* Block length */
6980 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
6981 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
6982 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6983 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
6984 DW_CFA_nop
, DW_CFA_nop
6987 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
6989 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
6990 elf_x86_64_nacl_plt_entry
, /* plt_entry */
6991 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6992 2, /* plt0_got1_offset */
6993 9, /* plt0_got2_offset */
6994 13, /* plt0_got2_insn_end */
6995 3, /* plt_got_offset */
6996 33, /* plt_reloc_offset */
6997 38, /* plt_plt_offset */
6998 7, /* plt_got_insn_size */
6999 42, /* plt_plt_insn_end */
7000 32, /* plt_lazy_offset */
7001 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
7002 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
7005 #undef elf_backend_arch_data
7006 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
7008 #undef elf_backend_object_p
7009 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
7010 #undef elf_backend_modify_segment_map
7011 #define elf_backend_modify_segment_map nacl_modify_segment_map
7012 #undef elf_backend_modify_program_headers
7013 #define elf_backend_modify_program_headers nacl_modify_program_headers
7014 #undef elf_backend_final_write_processing
7015 #define elf_backend_final_write_processing nacl_final_write_processing
7017 #include "elf64-target.h"
7019 /* Native Client x32 support. */
7022 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
7024 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
7025 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
7029 #undef TARGET_LITTLE_SYM
7030 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
7031 #undef TARGET_LITTLE_NAME
7032 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
7034 #define elf32_bed elf32_x86_64_nacl_bed
7036 #define bfd_elf32_bfd_link_hash_table_create \
7037 elf_x86_64_link_hash_table_create
7038 #define bfd_elf32_bfd_reloc_type_lookup \
7039 elf_x86_64_reloc_type_lookup
7040 #define bfd_elf32_bfd_reloc_name_lookup \
7041 elf_x86_64_reloc_name_lookup
7042 #define bfd_elf32_mkobject \
7044 #define bfd_elf32_get_synthetic_symtab \
7045 elf_x86_64_get_synthetic_symtab
7047 #undef elf_backend_object_p
7048 #define elf_backend_object_p \
7049 elf32_x86_64_nacl_elf_object_p
7051 #undef elf_backend_bfd_from_remote_memory
7052 #define elf_backend_bfd_from_remote_memory \
7053 _bfd_elf32_bfd_from_remote_memory
7055 #undef elf_backend_size_info
7056 #define elf_backend_size_info \
7057 _bfd_elf32_size_info
7059 #include "elf32-target.h"
7061 /* Restore defaults. */
7062 #undef elf_backend_object_p
7063 #define elf_backend_object_p elf64_x86_64_elf_object_p
7064 #undef elf_backend_bfd_from_remote_memory
7065 #undef elf_backend_size_info
7066 #undef elf_backend_modify_segment_map
7067 #undef elf_backend_modify_program_headers
7068 #undef elf_backend_final_write_processing
7070 /* Intel L1OM support. */
7073 elf64_l1om_elf_object_p (bfd
*abfd
)
7075 /* Set the right machine number for an L1OM elf64 file. */
7076 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
7080 #undef TARGET_LITTLE_SYM
7081 #define TARGET_LITTLE_SYM l1om_elf64_vec
7082 #undef TARGET_LITTLE_NAME
7083 #define TARGET_LITTLE_NAME "elf64-l1om"
7085 #define ELF_ARCH bfd_arch_l1om
7087 #undef ELF_MACHINE_CODE
7088 #define ELF_MACHINE_CODE EM_L1OM
7093 #define elf64_bed elf64_l1om_bed
7095 #undef elf_backend_object_p
7096 #define elf_backend_object_p elf64_l1om_elf_object_p
7098 /* Restore defaults. */
7099 #undef ELF_MAXPAGESIZE
7100 #undef ELF_MINPAGESIZE
7101 #undef ELF_COMMONPAGESIZE
7102 #define ELF_MAXPAGESIZE 0x200000
7103 #define ELF_MINPAGESIZE 0x1000
7104 #define ELF_COMMONPAGESIZE 0x1000
7105 #undef elf_backend_plt_alignment
7106 #define elf_backend_plt_alignment 4
7107 #undef elf_backend_arch_data
7108 #define elf_backend_arch_data &elf_x86_64_arch_bed
7110 #include "elf64-target.h"
7112 /* FreeBSD L1OM support. */
7114 #undef TARGET_LITTLE_SYM
7115 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
7116 #undef TARGET_LITTLE_NAME
7117 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
7120 #define ELF_OSABI ELFOSABI_FREEBSD
7123 #define elf64_bed elf64_l1om_fbsd_bed
7125 #include "elf64-target.h"
7127 /* Intel K1OM support. */
7130 elf64_k1om_elf_object_p (bfd
*abfd
)
7132 /* Set the right machine number for an K1OM elf64 file. */
7133 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
7137 #undef TARGET_LITTLE_SYM
7138 #define TARGET_LITTLE_SYM k1om_elf64_vec
7139 #undef TARGET_LITTLE_NAME
7140 #define TARGET_LITTLE_NAME "elf64-k1om"
7142 #define ELF_ARCH bfd_arch_k1om
7144 #undef ELF_MACHINE_CODE
7145 #define ELF_MACHINE_CODE EM_K1OM
7150 #define elf64_bed elf64_k1om_bed
7152 #undef elf_backend_object_p
7153 #define elf_backend_object_p elf64_k1om_elf_object_p
7155 #undef elf_backend_static_tls_alignment
7157 #undef elf_backend_want_plt_sym
7158 #define elf_backend_want_plt_sym 0
7160 #include "elf64-target.h"
7162 /* FreeBSD K1OM support. */
7164 #undef TARGET_LITTLE_SYM
7165 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
7166 #undef TARGET_LITTLE_NAME
7167 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
7170 #define ELF_OSABI ELFOSABI_FREEBSD
7173 #define elf64_bed elf64_k1om_fbsd_bed
7175 #include "elf64-target.h"
7177 /* 32bit x86-64 support. */
7179 #undef TARGET_LITTLE_SYM
7180 #define TARGET_LITTLE_SYM x86_64_elf32_vec
7181 #undef TARGET_LITTLE_NAME
7182 #define TARGET_LITTLE_NAME "elf32-x86-64"
7186 #define ELF_ARCH bfd_arch_i386
7188 #undef ELF_MACHINE_CODE
7189 #define ELF_MACHINE_CODE EM_X86_64
7193 #undef elf_backend_object_p
7194 #define elf_backend_object_p \
7195 elf32_x86_64_elf_object_p
7197 #undef elf_backend_bfd_from_remote_memory
7198 #define elf_backend_bfd_from_remote_memory \
7199 _bfd_elf32_bfd_from_remote_memory
7201 #undef elf_backend_size_info
7202 #define elf_backend_size_info \
7203 _bfd_elf32_size_info
7205 #include "elf32-target.h"