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
);
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
1881 || ((h
->root
.type
== bfd_link_hash_defined
1882 || h
->root
.type
== bfd_link_hash_defweak
)
1883 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)))
1885 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */
1886 if (require_reloc_pc32
)
1890 tsec
= h
->root
.u
.def
.section
;
1891 toff
= h
->root
.u
.def
.value
;
1898 /* Don't convert GOTPCREL relocation against large section. */
1899 if (elf_section_data (tsec
) != NULL
1900 && (elf_section_flags (tsec
) & SHF_X86_64_LARGE
) != 0)
1903 /* We can only estimate relocation overflow for R_X86_64_PC32. */
1907 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
1909 /* At this stage in linking, no SEC_MERGE symbol has been
1910 adjusted, so all references to such symbols need to be
1911 passed through _bfd_merged_section_offset. (Later, in
1912 relocate_section, all SEC_MERGE symbols *except* for
1913 section symbols have been adjusted.)
1915 gas may reduce relocations against symbols in SEC_MERGE
1916 sections to a relocation against the section symbol when
1917 the original addend was zero. When the reloc is against
1918 a section symbol we should include the addend in the
1919 offset passed to _bfd_merged_section_offset, since the
1920 location of interest is the original symbol. On the
1921 other hand, an access to "sym+addend" where "sym" is not
1922 a section symbol should not include the addend; Such an
1923 access is presumed to be an offset from "sym"; The
1924 location of interest is just "sym". */
1925 if (symtype
== STT_SECTION
)
1928 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
1929 elf_section_data (tsec
)->sec_info
,
1932 if (symtype
!= STT_SECTION
)
1938 /* Don't convert if R_X86_64_PC32 relocation overflows. */
1939 if (tsec
->output_section
== sec
->output_section
)
1941 if ((toff
- roff
+ 0x80000000) > 0xffffffff)
1946 bfd_signed_vma distance
;
1948 /* At this point, we don't know the load addresses of TSEC
1949 section nor SEC section. We estimate the distrance between
1950 SEC and TSEC. We store the estimated distances in the
1951 compressed_size field of the output section, which is only
1952 used to decompress the compressed input section. */
1953 if (sec
->output_section
->compressed_size
== 0)
1956 bfd_size_type size
= 0;
1957 for (asect
= link_info
->output_bfd
->sections
;
1959 asect
= asect
->next
)
1960 /* Skip debug sections since compressed_size is used to
1961 compress debug sections. */
1962 if ((asect
->flags
& SEC_DEBUGGING
) == 0)
1965 for (i
= asect
->map_head
.s
;
1969 size
= align_power (size
, i
->alignment_power
);
1972 asect
->compressed_size
= size
;
1976 /* Don't convert GOTPCREL relocations if TSEC isn't placed
1978 distance
= (tsec
->output_section
->compressed_size
1979 - sec
->output_section
->compressed_size
);
1983 /* Take PT_GNU_RELRO segment into account by adding
1985 if ((toff
+ distance
+ get_elf_backend_data (abfd
)->maxpagesize
1986 - roff
+ 0x80000000) > 0xffffffff)
1993 /* We have "call/jmp *foo@GOTPCREL(%rip)". */
1998 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
2000 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2003 /* Convert to "jmp foo nop". */
2006 nop_offset
= irel
->r_offset
+ 3;
2007 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
2008 irel
->r_offset
-= 1;
2009 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
2013 struct elf_x86_64_link_hash_entry
*eh
2014 = (struct elf_x86_64_link_hash_entry
*) h
;
2016 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
2019 /* To support TLS optimization, always use addr32 prefix for
2020 "call *__tls_get_addr@GOTPCREL(%rip)". */
2021 if (eh
&& eh
->tls_get_addr
== 1)
2024 nop_offset
= irel
->r_offset
- 2;
2028 nop
= link_info
->call_nop_byte
;
2029 if (link_info
->call_nop_as_suffix
)
2031 nop_offset
= irel
->r_offset
+ 3;
2032 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
2033 irel
->r_offset
-= 1;
2034 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
2037 nop_offset
= irel
->r_offset
- 2;
2040 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
2041 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
2042 r_type
= R_X86_64_PC32
;
2047 unsigned int rex_mask
= REX_R
;
2049 if (r_type
== R_X86_64_REX_GOTPCRELX
)
2050 rex
= bfd_get_8 (abfd
, contents
+ roff
- 3);
2058 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
2059 "lea foo(%rip), %reg". */
2061 r_type
= R_X86_64_PC32
;
2065 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
2066 "mov $foo, %reg". */
2068 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2069 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
2070 if ((rex
& REX_W
) != 0
2071 && ABI_64_P (link_info
->output_bfd
))
2073 /* Keep the REX_W bit in REX byte for LP64. */
2074 r_type
= R_X86_64_32S
;
2075 goto rewrite_modrm_rex
;
2079 /* If the REX_W bit in REX byte isn't needed,
2080 use R_X86_64_32 and clear the W bit to avoid
2081 sign-extend imm32 to imm64. */
2082 r_type
= R_X86_64_32
;
2083 /* Clear the W bit in REX byte. */
2085 goto rewrite_modrm_rex
;
2091 /* R_X86_64_PC32 isn't supported. */
2095 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2098 /* Convert "test %reg, foo@GOTPCREL(%rip)" to
2099 "test $foo, %reg". */
2100 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
2105 /* Convert "binop foo@GOTPCREL(%rip), %reg" to
2106 "binop $foo, %reg". */
2107 modrm
= 0xc0 | (modrm
& 0x38) >> 3 | (opcode
& 0x3c);
2111 /* Use R_X86_64_32 with 32-bit operand to avoid relocation
2112 overflow when sign-extending imm32 to imm64. */
2113 r_type
= (rex
& REX_W
) != 0 ? R_X86_64_32S
: R_X86_64_32
;
2116 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
2120 /* Move the R bit to the B bit in REX byte. */
2121 rex
= (rex
& ~rex_mask
) | (rex
& REX_R
) >> 2;
2122 bfd_put_8 (abfd
, rex
, contents
+ roff
- 3);
2125 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */
2129 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
2132 irel
->r_info
= htab
->r_info (r_symndx
, r_type
);
2139 /* Look through the relocs for a section during the first phase, and
2140 calculate needed space in the global offset table, procedure
2141 linkage table, and dynamic reloc sections. */
2144 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
2146 const Elf_Internal_Rela
*relocs
)
2148 struct elf_x86_64_link_hash_table
*htab
;
2149 Elf_Internal_Shdr
*symtab_hdr
;
2150 struct elf_link_hash_entry
**sym_hashes
;
2151 const Elf_Internal_Rela
*rel
;
2152 const Elf_Internal_Rela
*rel_end
;
2155 bfd_boolean use_plt_got
;
2157 if (bfd_link_relocatable (info
))
2160 /* Don't do anything special with non-loaded, non-alloced sections.
2161 In particular, any relocs in such sections should not affect GOT
2162 and PLT reference counting (ie. we don't allow them to create GOT
2163 or PLT entries), there's no possibility or desire to optimize TLS
2164 relocs, and there's not much point in propagating relocs to shared
2165 libs that the dynamic linker won't relocate. */
2166 if ((sec
->flags
& SEC_ALLOC
) == 0)
2169 BFD_ASSERT (is_x86_64_elf (abfd
));
2171 htab
= elf_x86_64_hash_table (info
);
2174 sec
->check_relocs_failed
= 1;
2178 /* Get the section contents. */
2179 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2180 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2181 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2183 sec
->check_relocs_failed
= 1;
2187 use_plt_got
= get_elf_x86_64_backend_data (abfd
) == &elf_x86_64_arch_bed
;
2189 symtab_hdr
= &elf_symtab_hdr (abfd
);
2190 sym_hashes
= elf_sym_hashes (abfd
);
2194 rel_end
= relocs
+ sec
->reloc_count
;
2195 for (rel
= relocs
; rel
< rel_end
; rel
++)
2197 unsigned int r_type
;
2198 unsigned long r_symndx
;
2199 struct elf_link_hash_entry
*h
;
2200 struct elf_x86_64_link_hash_entry
*eh
;
2201 Elf_Internal_Sym
*isym
;
2203 bfd_boolean size_reloc
;
2205 r_symndx
= htab
->r_sym (rel
->r_info
);
2206 r_type
= ELF32_R_TYPE (rel
->r_info
);
2208 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
2210 _bfd_error_handler (_("%B: bad symbol index: %d"),
2215 if (r_symndx
< symtab_hdr
->sh_info
)
2217 /* A local symbol. */
2218 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2223 /* Check relocation against local STT_GNU_IFUNC symbol. */
2224 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
2226 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
2231 /* Fake a STT_GNU_IFUNC symbol. */
2232 h
->type
= STT_GNU_IFUNC
;
2235 h
->forced_local
= 1;
2236 h
->root
.type
= bfd_link_hash_defined
;
2244 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2245 while (h
->root
.type
== bfd_link_hash_indirect
2246 || h
->root
.type
== bfd_link_hash_warning
)
2247 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2250 /* Check invalid x32 relocations. */
2251 if (!ABI_64_P (abfd
))
2257 case R_X86_64_DTPOFF64
:
2258 case R_X86_64_TPOFF64
:
2260 case R_X86_64_GOTOFF64
:
2261 case R_X86_64_GOT64
:
2262 case R_X86_64_GOTPCREL64
:
2263 case R_X86_64_GOTPC64
:
2264 case R_X86_64_GOTPLT64
:
2265 case R_X86_64_PLTOFF64
:
2268 name
= h
->root
.root
.string
;
2270 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
2273 (_("%B: relocation %s against symbol `%s' isn't "
2274 "supported in x32 mode"), abfd
,
2275 x86_64_elf_howto_table
[r_type
].name
, name
);
2276 bfd_set_error (bfd_error_bad_value
);
2289 case R_X86_64_PC32_BND
:
2290 case R_X86_64_PLT32_BND
:
2292 case R_X86_64_PLT32
:
2295 /* MPX PLT is supported only if elf_x86_64_arch_bed
2296 is used in 64-bit mode. */
2299 && (get_elf_x86_64_backend_data (abfd
)
2300 == &elf_x86_64_arch_bed
))
2302 elf_x86_64_hash_entry (h
)->has_bnd_reloc
= 1;
2304 /* Create the second PLT for Intel MPX support. */
2305 if (htab
->plt_bnd
== NULL
)
2307 unsigned int plt_bnd_align
;
2308 const struct elf_backend_data
*bed
;
2310 bed
= get_elf_backend_data (info
->output_bfd
);
2311 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry
) == 8
2312 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2313 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2316 if (htab
->elf
.dynobj
== NULL
)
2317 htab
->elf
.dynobj
= abfd
;
2319 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2321 (bed
->dynamic_sec_flags
2326 if (htab
->plt_bnd
== NULL
2327 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2337 case R_X86_64_GOTPCREL
:
2338 case R_X86_64_GOTPCRELX
:
2339 case R_X86_64_REX_GOTPCRELX
:
2340 case R_X86_64_GOTPCREL64
:
2341 if (htab
->elf
.dynobj
== NULL
)
2342 htab
->elf
.dynobj
= abfd
;
2343 /* Create the ifunc sections for static executables. */
2344 if (h
->type
== STT_GNU_IFUNC
2345 && !_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
,
2351 /* It is referenced by a non-shared object. */
2353 h
->root
.non_ir_ref
= 1;
2355 if (h
->type
== STT_GNU_IFUNC
)
2356 elf_tdata (info
->output_bfd
)->has_gnu_symbols
2357 |= elf_gnu_symbol_ifunc
;
2360 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, contents
,
2361 symtab_hdr
, sym_hashes
,
2362 &r_type
, GOT_UNKNOWN
,
2363 rel
, rel_end
, h
, r_symndx
, FALSE
))
2366 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2369 case R_X86_64_TLSLD
:
2370 htab
->tls_ld_got
.refcount
+= 1;
2373 case R_X86_64_TPOFF32
:
2374 if (!bfd_link_executable (info
) && ABI_64_P (abfd
))
2375 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
2376 &x86_64_elf_howto_table
[r_type
]);
2378 eh
->has_got_reloc
= 1;
2381 case R_X86_64_GOTTPOFF
:
2382 if (!bfd_link_executable (info
))
2383 info
->flags
|= DF_STATIC_TLS
;
2386 case R_X86_64_GOT32
:
2387 case R_X86_64_GOTPCREL
:
2388 case R_X86_64_GOTPCRELX
:
2389 case R_X86_64_REX_GOTPCRELX
:
2390 case R_X86_64_TLSGD
:
2391 case R_X86_64_GOT64
:
2392 case R_X86_64_GOTPCREL64
:
2393 case R_X86_64_GOTPLT64
:
2394 case R_X86_64_GOTPC32_TLSDESC
:
2395 case R_X86_64_TLSDESC_CALL
:
2396 /* This symbol requires a global offset table entry. */
2398 int tls_type
, old_tls_type
;
2402 default: tls_type
= GOT_NORMAL
; break;
2403 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
2404 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
2405 case R_X86_64_GOTPC32_TLSDESC
:
2406 case R_X86_64_TLSDESC_CALL
:
2407 tls_type
= GOT_TLS_GDESC
; break;
2412 h
->got
.refcount
+= 1;
2413 old_tls_type
= eh
->tls_type
;
2417 bfd_signed_vma
*local_got_refcounts
;
2419 /* This is a global offset table entry for a local symbol. */
2420 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2421 if (local_got_refcounts
== NULL
)
2425 size
= symtab_hdr
->sh_info
;
2426 size
*= sizeof (bfd_signed_vma
)
2427 + sizeof (bfd_vma
) + sizeof (char);
2428 local_got_refcounts
= ((bfd_signed_vma
*)
2429 bfd_zalloc (abfd
, size
));
2430 if (local_got_refcounts
== NULL
)
2432 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2433 elf_x86_64_local_tlsdesc_gotent (abfd
)
2434 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
2435 elf_x86_64_local_got_tls_type (abfd
)
2436 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
2438 local_got_refcounts
[r_symndx
] += 1;
2440 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
2443 /* If a TLS symbol is accessed using IE at least once,
2444 there is no point to use dynamic model for it. */
2445 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
2446 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
2447 || tls_type
!= GOT_TLS_IE
))
2449 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
2450 tls_type
= old_tls_type
;
2451 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
2452 && GOT_TLS_GD_ANY_P (tls_type
))
2453 tls_type
|= old_tls_type
;
2457 name
= h
->root
.root
.string
;
2459 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
2462 (_("%B: '%s' accessed both as normal and thread local symbol"),
2464 bfd_set_error (bfd_error_bad_value
);
2469 if (old_tls_type
!= tls_type
)
2472 eh
->tls_type
= tls_type
;
2474 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
2479 case R_X86_64_GOTOFF64
:
2480 case R_X86_64_GOTPC32
:
2481 case R_X86_64_GOTPC64
:
2484 eh
->has_got_reloc
= 1;
2485 if (htab
->elf
.sgot
== NULL
)
2487 if (htab
->elf
.dynobj
== NULL
)
2488 htab
->elf
.dynobj
= abfd
;
2489 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
2495 case R_X86_64_PLT32
:
2496 case R_X86_64_PLT32_BND
:
2497 /* This symbol requires a procedure linkage table entry. We
2498 actually build the entry in adjust_dynamic_symbol,
2499 because this might be a case of linking PIC code which is
2500 never referenced by a dynamic object, in which case we
2501 don't need to generate a procedure linkage table entry
2504 /* If this is a local symbol, we resolve it directly without
2505 creating a procedure linkage table entry. */
2509 eh
->has_got_reloc
= 1;
2511 h
->plt
.refcount
+= 1;
2514 case R_X86_64_PLTOFF64
:
2515 /* This tries to form the 'address' of a function relative
2516 to GOT. For global symbols we need a PLT entry. */
2520 h
->plt
.refcount
+= 1;
2524 case R_X86_64_SIZE32
:
2525 case R_X86_64_SIZE64
:
2530 if (!ABI_64_P (abfd
))
2536 /* Check relocation overflow as these relocs may lead to
2537 run-time relocation overflow. Don't error out for
2538 sections we don't care about, such as debug sections or
2539 when relocation overflow check is disabled. */
2540 if (!info
->no_reloc_overflow_check
2541 && (bfd_link_pic (info
)
2542 || (bfd_link_executable (info
)
2546 && (sec
->flags
& SEC_READONLY
) == 0)))
2547 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
2548 &x86_64_elf_howto_table
[r_type
]);
2554 case R_X86_64_PC32_BND
:
2558 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2559 eh
->has_non_got_reloc
= 1;
2560 /* We are called after all symbols have been resolved. Only
2561 relocation against STT_GNU_IFUNC symbol must go through
2564 && (bfd_link_executable (info
)
2565 || h
->type
== STT_GNU_IFUNC
))
2567 /* If this reloc is in a read-only section, we might
2568 need a copy reloc. We can't check reliably at this
2569 stage whether the section is read-only, as input
2570 sections have not yet been mapped to output sections.
2571 Tentatively set the flag for now, and correct in
2572 adjust_dynamic_symbol. */
2575 /* We may need a .plt entry if the symbol is a function
2576 defined in a shared lib or is a STT_GNU_IFUNC function
2577 referenced from the code or read-only section. */
2579 || (sec
->flags
& (SEC_CODE
| SEC_READONLY
)) != 0)
2580 h
->plt
.refcount
+= 1;
2582 if (r_type
== R_X86_64_PC32
)
2584 /* Since something like ".long foo - ." may be used
2585 as pointer, make sure that PLT is used if foo is
2586 a function defined in a shared library. */
2587 if ((sec
->flags
& SEC_CODE
) == 0)
2588 h
->pointer_equality_needed
= 1;
2590 else if (r_type
!= R_X86_64_PC32_BND
2591 && r_type
!= R_X86_64_PC64
)
2593 h
->pointer_equality_needed
= 1;
2594 /* At run-time, R_X86_64_64 can be resolved for both
2595 x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2596 can only be resolved for x32. */
2597 if ((sec
->flags
& SEC_READONLY
) == 0
2598 && (r_type
== R_X86_64_64
2599 || (!ABI_64_P (abfd
)
2600 && (r_type
== R_X86_64_32
2601 || r_type
== R_X86_64_32S
))))
2602 eh
->func_pointer_refcount
+= 1;
2608 /* If we are creating a shared library, and this is a reloc
2609 against a global symbol, or a non PC relative reloc
2610 against a local symbol, then we need to copy the reloc
2611 into the shared library. However, if we are linking with
2612 -Bsymbolic, we do not need to copy a reloc against a
2613 global symbol which is defined in an object we are
2614 including in the link (i.e., DEF_REGULAR is set). At
2615 this point we have not seen all the input files, so it is
2616 possible that DEF_REGULAR is not set now but will be set
2617 later (it is never cleared). In case of a weak definition,
2618 DEF_REGULAR may be cleared later by a strong definition in
2619 a shared library. We account for that possibility below by
2620 storing information in the relocs_copied field of the hash
2621 table entry. A similar situation occurs when creating
2622 shared libraries and symbol visibility changes render the
2625 If on the other hand, we are creating an executable, we
2626 may need to keep relocations for symbols satisfied by a
2627 dynamic library if we manage to avoid copy relocs for the
2630 Generate dynamic pointer relocation against STT_GNU_IFUNC
2631 symbol in the non-code section. */
2632 if ((bfd_link_pic (info
)
2633 && (! IS_X86_64_PCREL_TYPE (r_type
)
2635 && (! (bfd_link_pie (info
)
2636 || SYMBOLIC_BIND (info
, h
))
2637 || h
->root
.type
== bfd_link_hash_defweak
2638 || !h
->def_regular
))))
2640 && h
->type
== STT_GNU_IFUNC
2641 && r_type
== htab
->pointer_r_type
2642 && (sec
->flags
& SEC_CODE
) == 0)
2643 || (ELIMINATE_COPY_RELOCS
2644 && !bfd_link_pic (info
)
2646 && (h
->root
.type
== bfd_link_hash_defweak
2647 || !h
->def_regular
)))
2649 struct elf_dyn_relocs
*p
;
2650 struct elf_dyn_relocs
**head
;
2652 /* We must copy these reloc types into the output file.
2653 Create a reloc section in dynobj and make room for
2657 if (htab
->elf
.dynobj
== NULL
)
2658 htab
->elf
.dynobj
= abfd
;
2660 sreloc
= _bfd_elf_make_dynamic_reloc_section
2661 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
2662 abfd
, /*rela?*/ TRUE
);
2668 /* If this is a global symbol, we count the number of
2669 relocations we need for this symbol. */
2671 head
= &eh
->dyn_relocs
;
2674 /* Track dynamic relocs needed for local syms too.
2675 We really need local syms available to do this
2680 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2685 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2689 /* Beware of type punned pointers vs strict aliasing
2691 vpp
= &(elf_section_data (s
)->local_dynrel
);
2692 head
= (struct elf_dyn_relocs
**)vpp
;
2696 if (p
== NULL
|| p
->sec
!= sec
)
2698 bfd_size_type amt
= sizeof *p
;
2700 p
= ((struct elf_dyn_relocs
*)
2701 bfd_alloc (htab
->elf
.dynobj
, amt
));
2712 /* Count size relocation as PC-relative relocation. */
2713 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
2718 /* This relocation describes the C++ object vtable hierarchy.
2719 Reconstruct it for later use during GC. */
2720 case R_X86_64_GNU_VTINHERIT
:
2721 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2725 /* This relocation describes which C++ vtable entries are actually
2726 used. Record for later use during GC. */
2727 case R_X86_64_GNU_VTENTRY
:
2728 BFD_ASSERT (h
!= NULL
);
2730 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2740 && h
->plt
.refcount
> 0
2741 && (((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2742 || h
->got
.refcount
> 0)
2743 && htab
->plt_got
== NULL
)
2745 /* Create the GOT procedure linkage table. */
2746 unsigned int plt_got_align
;
2747 const struct elf_backend_data
*bed
;
2749 bed
= get_elf_backend_data (info
->output_bfd
);
2750 BFD_ASSERT (sizeof (elf_x86_64_legacy_plt2_entry
) == 8
2751 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2752 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2755 if (htab
->elf
.dynobj
== NULL
)
2756 htab
->elf
.dynobj
= abfd
;
2758 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2760 (bed
->dynamic_sec_flags
2765 if (htab
->plt_got
== NULL
2766 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2772 if ((r_type
== R_X86_64_GOTPCREL
2773 || r_type
== R_X86_64_GOTPCRELX
2774 || r_type
== R_X86_64_REX_GOTPCRELX
)
2775 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2776 sec
->need_convert_load
= 1;
2779 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2781 if (!info
->keep_memory
)
2785 /* Cache the section contents for elf_link_input_bfd. */
2786 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2793 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2795 sec
->check_relocs_failed
= 1;
2799 /* Return the section that should be marked against GC for a given
2803 elf_x86_64_gc_mark_hook (asection
*sec
,
2804 struct bfd_link_info
*info
,
2805 Elf_Internal_Rela
*rel
,
2806 struct elf_link_hash_entry
*h
,
2807 Elf_Internal_Sym
*sym
)
2810 switch (ELF32_R_TYPE (rel
->r_info
))
2812 case R_X86_64_GNU_VTINHERIT
:
2813 case R_X86_64_GNU_VTENTRY
:
2817 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2820 /* Remove undefined weak symbol from the dynamic symbol table if it
2821 is resolved to 0. */
2824 elf_x86_64_fixup_symbol (struct bfd_link_info
*info
,
2825 struct elf_link_hash_entry
*h
)
2827 if (h
->dynindx
!= -1
2828 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2829 elf_x86_64_hash_entry (h
)->has_got_reloc
,
2830 elf_x86_64_hash_entry (h
)))
2833 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2839 /* Adjust a symbol defined by a dynamic object and referenced by a
2840 regular object. The current definition is in some section of the
2841 dynamic object, but we're not including those sections. We have to
2842 change the definition to something the rest of the link can
2846 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2847 struct elf_link_hash_entry
*h
)
2849 struct elf_x86_64_link_hash_table
*htab
;
2851 struct elf_x86_64_link_hash_entry
*eh
;
2852 struct elf_dyn_relocs
*p
;
2854 /* STT_GNU_IFUNC symbol must go through PLT. */
2855 if (h
->type
== STT_GNU_IFUNC
)
2857 /* All local STT_GNU_IFUNC references must be treate as local
2858 calls via local PLT. */
2860 && SYMBOL_CALLS_LOCAL (info
, h
))
2862 bfd_size_type pc_count
= 0, count
= 0;
2863 struct elf_dyn_relocs
**pp
;
2865 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2866 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2868 pc_count
+= p
->pc_count
;
2869 p
->count
-= p
->pc_count
;
2878 if (pc_count
|| count
)
2883 /* Increment PLT reference count only for PC-relative
2886 if (h
->plt
.refcount
<= 0)
2887 h
->plt
.refcount
= 1;
2889 h
->plt
.refcount
+= 1;
2894 if (h
->plt
.refcount
<= 0)
2896 h
->plt
.offset
= (bfd_vma
) -1;
2902 /* If this is a function, put it in the procedure linkage table. We
2903 will fill in the contents of the procedure linkage table later,
2904 when we know the address of the .got section. */
2905 if (h
->type
== STT_FUNC
2908 if (h
->plt
.refcount
<= 0
2909 || SYMBOL_CALLS_LOCAL (info
, h
)
2910 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2911 && h
->root
.type
== bfd_link_hash_undefweak
))
2913 /* This case can occur if we saw a PLT32 reloc in an input
2914 file, but the symbol was never referred to by a dynamic
2915 object, or if all references were garbage collected. In
2916 such a case, we don't actually need to build a procedure
2917 linkage table, and we can just do a PC32 reloc instead. */
2918 h
->plt
.offset
= (bfd_vma
) -1;
2925 /* It's possible that we incorrectly decided a .plt reloc was
2926 needed for an R_X86_64_PC32 reloc to a non-function sym in
2927 check_relocs. We can't decide accurately between function and
2928 non-function syms in check-relocs; Objects loaded later in
2929 the link may change h->type. So fix it now. */
2930 h
->plt
.offset
= (bfd_vma
) -1;
2932 /* If this is a weak symbol, and there is a real definition, the
2933 processor independent code will have arranged for us to see the
2934 real definition first, and we can just use the same value. */
2935 if (h
->u
.weakdef
!= NULL
)
2937 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2938 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2939 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2940 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2941 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2943 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2944 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2945 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
2950 /* This is a reference to a symbol defined by a dynamic object which
2951 is not a function. */
2953 /* If we are creating a shared library, we must presume that the
2954 only references to the symbol are via the global offset table.
2955 For such cases we need not do anything here; the relocations will
2956 be handled correctly by relocate_section. */
2957 if (!bfd_link_executable (info
))
2960 /* If there are no references to this symbol that do not use the
2961 GOT, we don't need to generate a copy reloc. */
2962 if (!h
->non_got_ref
)
2965 /* If -z nocopyreloc was given, we won't generate them either. */
2966 if (info
->nocopyreloc
)
2972 if (ELIMINATE_COPY_RELOCS
)
2974 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2975 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2977 s
= p
->sec
->output_section
;
2978 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2982 /* If we didn't find any dynamic relocs in read-only sections, then
2983 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2991 /* We must allocate the symbol in our .dynbss section, which will
2992 become part of the .bss section of the executable. There will be
2993 an entry for this symbol in the .dynsym section. The dynamic
2994 object will contain position independent code, so all references
2995 from the dynamic object to this symbol will go through the global
2996 offset table. The dynamic linker will use the .dynsym entry to
2997 determine the address it must put in the global offset table, so
2998 both the dynamic object and the regular object will refer to the
2999 same memory location for the variable. */
3001 htab
= elf_x86_64_hash_table (info
);
3005 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
3006 to copy the initial value out of the dynamic object and into the
3007 runtime process image. */
3008 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
3010 const struct elf_backend_data
*bed
;
3011 bed
= get_elf_backend_data (info
->output_bfd
);
3012 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
3018 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
3021 /* Allocate space in .plt, .got and associated reloc sections for
3025 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
3027 struct bfd_link_info
*info
;
3028 struct elf_x86_64_link_hash_table
*htab
;
3029 struct elf_x86_64_link_hash_entry
*eh
;
3030 struct elf_dyn_relocs
*p
;
3031 const struct elf_backend_data
*bed
;
3032 unsigned int plt_entry_size
;
3033 bfd_boolean resolved_to_zero
;
3035 if (h
->root
.type
== bfd_link_hash_indirect
)
3038 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3040 info
= (struct bfd_link_info
*) inf
;
3041 htab
= elf_x86_64_hash_table (info
);
3044 bed
= get_elf_backend_data (info
->output_bfd
);
3045 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
3047 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
3051 /* We can't use the GOT PLT if pointer equality is needed since
3052 finish_dynamic_symbol won't clear symbol value and the dynamic
3053 linker won't update the GOT slot. We will get into an infinite
3054 loop at run-time. */
3055 if (htab
->plt_got
!= NULL
3056 && h
->type
!= STT_GNU_IFUNC
3057 && !h
->pointer_equality_needed
3058 && h
->plt
.refcount
> 0
3059 && h
->got
.refcount
> 0)
3061 /* Don't use the regular PLT if there are both GOT and GOTPLT
3063 h
->plt
.offset
= (bfd_vma
) -1;
3065 /* Use the GOT PLT. */
3066 eh
->plt_got
.refcount
= 1;
3069 /* Clear the reference count of function pointer relocations if
3070 symbol isn't a normal function. */
3071 if (h
->type
!= STT_FUNC
)
3072 eh
->func_pointer_refcount
= 0;
3074 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
3075 here if it is defined and referenced in a non-shared object. */
3076 if (h
->type
== STT_GNU_IFUNC
3079 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
3081 &htab
->readonly_dynrelocs_against_ifunc
,
3084 GOT_ENTRY_SIZE
, TRUE
))
3086 asection
*s
= htab
->plt_bnd
;
3087 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
3089 /* Use the .plt.bnd section if it is created. */
3090 eh
->plt_bnd
.offset
= s
->size
;
3092 /* Make room for this entry in the .plt.bnd section. */
3093 s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
3101 /* Don't create the PLT entry if there are only function pointer
3102 relocations which can be resolved at run-time. */
3103 else if (htab
->elf
.dynamic_sections_created
3104 && (h
->plt
.refcount
> eh
->func_pointer_refcount
3105 || eh
->plt_got
.refcount
> 0))
3107 bfd_boolean use_plt_got
;
3109 /* Clear the reference count of function pointer relocations
3111 eh
->func_pointer_refcount
= 0;
3113 if ((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
3115 /* Don't use the regular PLT for DF_BIND_NOW. */
3116 h
->plt
.offset
= (bfd_vma
) -1;
3118 /* Use the GOT PLT. */
3119 h
->got
.refcount
= 1;
3120 eh
->plt_got
.refcount
= 1;
3123 use_plt_got
= eh
->plt_got
.refcount
> 0;
3125 /* Make sure this symbol is output as a dynamic symbol.
3126 Undefined weak syms won't yet be marked as dynamic. */
3127 if (h
->dynindx
== -1
3129 && !resolved_to_zero
)
3131 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3135 if (bfd_link_pic (info
)
3136 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
3138 asection
*s
= htab
->elf
.splt
;
3139 asection
*bnd_s
= htab
->plt_bnd
;
3140 asection
*got_s
= htab
->plt_got
;
3142 /* If this is the first .plt entry, make room for the special
3143 first entry. The .plt section is used by prelink to undo
3144 prelinking for dynamic relocations. */
3146 s
->size
= plt_entry_size
;
3149 eh
->plt_got
.offset
= got_s
->size
;
3152 h
->plt
.offset
= s
->size
;
3154 eh
->plt_bnd
.offset
= bnd_s
->size
;
3157 /* If this symbol is not defined in a regular file, and we are
3158 not generating a shared library, then set the symbol to this
3159 location in the .plt. This is required to make function
3160 pointers compare as equal between the normal executable and
3161 the shared library. */
3162 if (! bfd_link_pic (info
)
3167 /* We need to make a call to the entry of the GOT PLT
3168 instead of regular PLT entry. */
3169 h
->root
.u
.def
.section
= got_s
;
3170 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
3176 /* We need to make a call to the entry of the second
3177 PLT instead of regular PLT entry. */
3178 h
->root
.u
.def
.section
= bnd_s
;
3179 h
->root
.u
.def
.value
= eh
->plt_bnd
.offset
;
3183 h
->root
.u
.def
.section
= s
;
3184 h
->root
.u
.def
.value
= h
->plt
.offset
;
3189 /* Make room for this entry. */
3191 got_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
3194 s
->size
+= plt_entry_size
;
3196 bnd_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
3198 /* We also need to make an entry in the .got.plt section,
3199 which will be placed in the .got section by the linker
3201 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
3203 /* There should be no PLT relocation against resolved
3204 undefined weak symbol in executable. */
3205 if (!resolved_to_zero
)
3207 /* We also need to make an entry in the .rela.plt
3209 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
3210 htab
->elf
.srelplt
->reloc_count
++;
3216 eh
->plt_got
.offset
= (bfd_vma
) -1;
3217 h
->plt
.offset
= (bfd_vma
) -1;
3223 eh
->plt_got
.offset
= (bfd_vma
) -1;
3224 h
->plt
.offset
= (bfd_vma
) -1;
3228 eh
->tlsdesc_got
= (bfd_vma
) -1;
3230 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
3231 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
3232 if (h
->got
.refcount
> 0
3233 && bfd_link_executable (info
)
3235 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
3237 h
->got
.offset
= (bfd_vma
) -1;
3239 else if (h
->got
.refcount
> 0)
3243 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
3245 /* Make sure this symbol is output as a dynamic symbol.
3246 Undefined weak syms won't yet be marked as dynamic. */
3247 if (h
->dynindx
== -1
3249 && !resolved_to_zero
)
3251 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3255 if (GOT_TLS_GDESC_P (tls_type
))
3257 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
3258 - elf_x86_64_compute_jump_table_size (htab
);
3259 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3260 h
->got
.offset
= (bfd_vma
) -2;
3262 if (! GOT_TLS_GDESC_P (tls_type
)
3263 || GOT_TLS_GD_P (tls_type
))
3266 h
->got
.offset
= s
->size
;
3267 s
->size
+= GOT_ENTRY_SIZE
;
3268 if (GOT_TLS_GD_P (tls_type
))
3269 s
->size
+= GOT_ENTRY_SIZE
;
3271 dyn
= htab
->elf
.dynamic_sections_created
;
3272 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
3273 and two if global. R_X86_64_GOTTPOFF needs one dynamic
3274 relocation. No dynamic relocation against resolved undefined
3275 weak symbol in executable. */
3276 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
3277 || tls_type
== GOT_TLS_IE
)
3278 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3279 else if (GOT_TLS_GD_P (tls_type
))
3280 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
3281 else if (! GOT_TLS_GDESC_P (tls_type
)
3282 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3283 && !resolved_to_zero
)
3284 || h
->root
.type
!= bfd_link_hash_undefweak
)
3285 && (bfd_link_pic (info
)
3286 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
3287 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3288 if (GOT_TLS_GDESC_P (tls_type
))
3290 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
3291 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3295 h
->got
.offset
= (bfd_vma
) -1;
3297 if (eh
->dyn_relocs
== NULL
)
3300 /* In the shared -Bsymbolic case, discard space allocated for
3301 dynamic pc-relative relocs against symbols which turn out to be
3302 defined in regular objects. For the normal shared case, discard
3303 space for pc-relative relocs that have become local due to symbol
3304 visibility changes. */
3306 if (bfd_link_pic (info
))
3308 /* Relocs that use pc_count are those that appear on a call
3309 insn, or certain REL relocs that can generated via assembly.
3310 We want calls to protected symbols to resolve directly to the
3311 function rather than going via the plt. If people want
3312 function pointer comparisons to work as expected then they
3313 should avoid writing weird assembly. */
3314 if (SYMBOL_CALLS_LOCAL (info
, h
))
3316 struct elf_dyn_relocs
**pp
;
3318 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3320 p
->count
-= p
->pc_count
;
3329 /* Also discard relocs on undefined weak syms with non-default
3330 visibility or in PIE. */
3331 if (eh
->dyn_relocs
!= NULL
)
3333 if (h
->root
.type
== bfd_link_hash_undefweak
)
3335 /* Undefined weak symbol is never bound locally in shared
3337 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3338 || resolved_to_zero
)
3339 eh
->dyn_relocs
= NULL
;
3340 else if (h
->dynindx
== -1
3341 && ! h
->forced_local
3342 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3345 /* For PIE, discard space for pc-relative relocs against
3346 symbols which turn out to need copy relocs. */
3347 else if (bfd_link_executable (info
)
3348 && (h
->needs_copy
|| eh
->needs_copy
)
3352 struct elf_dyn_relocs
**pp
;
3354 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3356 if (p
->pc_count
!= 0)
3364 else if (ELIMINATE_COPY_RELOCS
)
3366 /* For the non-shared case, discard space for relocs against
3367 symbols which turn out to need copy relocs or are not
3368 dynamic. Keep dynamic relocations for run-time function
3369 pointer initialization. */
3371 if ((!h
->non_got_ref
3372 || eh
->func_pointer_refcount
> 0
3373 || (h
->root
.type
== bfd_link_hash_undefweak
3374 && !resolved_to_zero
))
3377 || (htab
->elf
.dynamic_sections_created
3378 && (h
->root
.type
== bfd_link_hash_undefweak
3379 || h
->root
.type
== bfd_link_hash_undefined
))))
3381 /* Make sure this symbol is output as a dynamic symbol.
3382 Undefined weak syms won't yet be marked as dynamic. */
3383 if (h
->dynindx
== -1
3384 && ! h
->forced_local
3385 && ! resolved_to_zero
3386 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3389 /* If that succeeded, we know we'll be keeping all the
3391 if (h
->dynindx
!= -1)
3395 eh
->dyn_relocs
= NULL
;
3396 eh
->func_pointer_refcount
= 0;
3401 /* Finally, allocate space. */
3402 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3406 sreloc
= elf_section_data (p
->sec
)->sreloc
;
3408 BFD_ASSERT (sreloc
!= NULL
);
3410 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3416 /* Allocate space in .plt, .got and associated reloc sections for
3417 local dynamic relocs. */
3420 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
3422 struct elf_link_hash_entry
*h
3423 = (struct elf_link_hash_entry
*) *slot
;
3425 if (h
->type
!= STT_GNU_IFUNC
3429 || h
->root
.type
!= bfd_link_hash_defined
)
3432 return elf_x86_64_allocate_dynrelocs (h
, inf
);
3435 /* Find any dynamic relocs that apply to read-only sections. */
3438 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
3441 struct elf_x86_64_link_hash_entry
*eh
;
3442 struct elf_dyn_relocs
*p
;
3444 /* Skip local IFUNC symbols. */
3445 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
3448 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3449 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3451 asection
*s
= p
->sec
->output_section
;
3453 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
3455 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3457 info
->flags
|= DF_TEXTREL
;
3459 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3460 || info
->error_textrel
)
3461 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
3462 p
->sec
->owner
, h
->root
.root
.string
,
3465 /* Not an error, just cut short the traversal. */
3472 /* Convert load via the GOT slot to load immediate. */
3475 elf_x86_64_convert_load (bfd
*abfd
, asection
*sec
,
3476 struct bfd_link_info
*link_info
)
3478 Elf_Internal_Shdr
*symtab_hdr
;
3479 Elf_Internal_Rela
*internal_relocs
;
3480 Elf_Internal_Rela
*irel
, *irelend
;
3482 struct elf_x86_64_link_hash_table
*htab
;
3483 bfd_boolean changed
;
3484 bfd_signed_vma
*local_got_refcounts
;
3486 /* Don't even try to convert non-ELF outputs. */
3487 if (!is_elf_hash_table (link_info
->hash
))
3490 /* Nothing to do if there is no need or no output. */
3491 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
3492 || sec
->need_convert_load
== 0
3493 || bfd_is_abs_section (sec
->output_section
))
3496 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3498 /* Load the relocations for this section. */
3499 internal_relocs
= (_bfd_elf_link_read_relocs
3500 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
3501 link_info
->keep_memory
));
3502 if (internal_relocs
== NULL
)
3506 htab
= elf_x86_64_hash_table (link_info
);
3507 local_got_refcounts
= elf_local_got_refcounts (abfd
);
3509 /* Get the section contents. */
3510 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
3511 contents
= elf_section_data (sec
)->this_hdr
.contents
;
3514 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
3518 irelend
= internal_relocs
+ sec
->reloc_count
;
3519 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3521 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
3522 unsigned int r_symndx
;
3523 struct elf_link_hash_entry
*h
;
3524 bfd_boolean converted
;
3526 if (r_type
!= R_X86_64_GOTPCRELX
3527 && r_type
!= R_X86_64_REX_GOTPCRELX
3528 && r_type
!= R_X86_64_GOTPCREL
)
3531 r_symndx
= htab
->r_sym (irel
->r_info
);
3532 if (r_symndx
< symtab_hdr
->sh_info
)
3533 h
= elf_x86_64_get_local_sym_hash (htab
, sec
->owner
,
3534 (const Elf_Internal_Rela
*) irel
,
3538 h
= elf_sym_hashes (abfd
)[r_symndx
- symtab_hdr
->sh_info
];
3539 while (h
->root
.type
== bfd_link_hash_indirect
3540 || h
->root
.type
== bfd_link_hash_warning
)
3541 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3544 /* STT_GNU_IFUNC must keep GOTPCREL relocations. */
3545 if (h
!= NULL
&& h
->type
== STT_GNU_IFUNC
)
3549 if (!elf_x86_64_convert_load_reloc (abfd
, sec
, contents
, irel
, h
,
3550 &converted
, link_info
))
3555 changed
= converted
;
3558 if (h
->got
.refcount
> 0)
3559 h
->got
.refcount
-= 1;
3563 if (local_got_refcounts
!= NULL
3564 && local_got_refcounts
[r_symndx
] > 0)
3565 local_got_refcounts
[r_symndx
] -= 1;
3570 if (contents
!= NULL
3571 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3573 if (!changed
&& !link_info
->keep_memory
)
3577 /* Cache the section contents for elf_link_input_bfd. */
3578 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3582 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3585 free (internal_relocs
);
3587 elf_section_data (sec
)->relocs
= internal_relocs
;
3593 if (contents
!= NULL
3594 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3596 if (internal_relocs
!= NULL
3597 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3598 free (internal_relocs
);
3602 /* Set the sizes of the dynamic sections. */
3605 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
3606 struct bfd_link_info
*info
)
3608 struct elf_x86_64_link_hash_table
*htab
;
3613 const struct elf_backend_data
*bed
;
3615 htab
= elf_x86_64_hash_table (info
);
3618 bed
= get_elf_backend_data (output_bfd
);
3620 dynobj
= htab
->elf
.dynobj
;
3624 /* Set up .got offsets for local syms, and space for local dynamic
3626 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3628 bfd_signed_vma
*local_got
;
3629 bfd_signed_vma
*end_local_got
;
3630 char *local_tls_type
;
3631 bfd_vma
*local_tlsdesc_gotent
;
3632 bfd_size_type locsymcount
;
3633 Elf_Internal_Shdr
*symtab_hdr
;
3636 if (! is_x86_64_elf (ibfd
))
3639 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3641 struct elf_dyn_relocs
*p
;
3643 if (!elf_x86_64_convert_load (ibfd
, s
, info
))
3646 for (p
= (struct elf_dyn_relocs
*)
3647 (elf_section_data (s
)->local_dynrel
);
3651 if (!bfd_is_abs_section (p
->sec
)
3652 && bfd_is_abs_section (p
->sec
->output_section
))
3654 /* Input section has been discarded, either because
3655 it is a copy of a linkonce section or due to
3656 linker script /DISCARD/, so we'll be discarding
3659 else if (p
->count
!= 0)
3661 srel
= elf_section_data (p
->sec
)->sreloc
;
3662 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3663 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3664 && (info
->flags
& DF_TEXTREL
) == 0)
3666 info
->flags
|= DF_TEXTREL
;
3667 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3668 || info
->error_textrel
)
3669 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3670 p
->sec
->owner
, p
->sec
);
3676 local_got
= elf_local_got_refcounts (ibfd
);
3680 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3681 locsymcount
= symtab_hdr
->sh_info
;
3682 end_local_got
= local_got
+ locsymcount
;
3683 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
3684 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
3686 srel
= htab
->elf
.srelgot
;
3687 for (; local_got
< end_local_got
;
3688 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3690 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3693 if (GOT_TLS_GDESC_P (*local_tls_type
))
3695 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3696 - elf_x86_64_compute_jump_table_size (htab
);
3697 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3698 *local_got
= (bfd_vma
) -2;
3700 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3701 || GOT_TLS_GD_P (*local_tls_type
))
3703 *local_got
= s
->size
;
3704 s
->size
+= GOT_ENTRY_SIZE
;
3705 if (GOT_TLS_GD_P (*local_tls_type
))
3706 s
->size
+= GOT_ENTRY_SIZE
;
3708 if (bfd_link_pic (info
)
3709 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3710 || *local_tls_type
== GOT_TLS_IE
)
3712 if (GOT_TLS_GDESC_P (*local_tls_type
))
3714 htab
->elf
.srelplt
->size
3715 += bed
->s
->sizeof_rela
;
3716 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3718 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3719 || GOT_TLS_GD_P (*local_tls_type
))
3720 srel
->size
+= bed
->s
->sizeof_rela
;
3724 *local_got
= (bfd_vma
) -1;
3728 if (htab
->tls_ld_got
.refcount
> 0)
3730 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3732 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
3733 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
3734 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3737 htab
->tls_ld_got
.offset
= -1;
3739 /* Allocate global sym .plt and .got entries, and space for global
3740 sym dynamic relocs. */
3741 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
3744 /* Allocate .plt and .got entries, and space for local symbols. */
3745 htab_traverse (htab
->loc_hash_table
,
3746 elf_x86_64_allocate_local_dynrelocs
,
3749 /* For every jump slot reserved in the sgotplt, reloc_count is
3750 incremented. However, when we reserve space for TLS descriptors,
3751 it's not incremented, so in order to compute the space reserved
3752 for them, it suffices to multiply the reloc count by the jump
3755 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3756 so that R_X86_64_IRELATIVE entries come last. */
3757 if (htab
->elf
.srelplt
)
3759 htab
->sgotplt_jump_table_size
3760 = elf_x86_64_compute_jump_table_size (htab
);
3761 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3763 else if (htab
->elf
.irelplt
)
3764 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3766 if (htab
->tlsdesc_plt
)
3768 /* If we're not using lazy TLS relocations, don't generate the
3769 PLT and GOT entries they require. */
3770 if ((info
->flags
& DF_BIND_NOW
))
3771 htab
->tlsdesc_plt
= 0;
3774 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
3775 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
3776 /* Reserve room for the initial entry.
3777 FIXME: we could probably do away with it in this case. */
3778 if (htab
->elf
.splt
->size
== 0)
3779 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3780 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
3781 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3785 if (htab
->elf
.sgotplt
)
3787 /* Don't allocate .got.plt section if there are no GOT nor PLT
3788 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3789 if ((htab
->elf
.hgot
== NULL
3790 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3791 && (htab
->elf
.sgotplt
->size
3792 == get_elf_backend_data (output_bfd
)->got_header_size
)
3793 && (htab
->elf
.splt
== NULL
3794 || htab
->elf
.splt
->size
== 0)
3795 && (htab
->elf
.sgot
== NULL
3796 || htab
->elf
.sgot
->size
== 0)
3797 && (htab
->elf
.iplt
== NULL
3798 || htab
->elf
.iplt
->size
== 0)
3799 && (htab
->elf
.igotplt
== NULL
3800 || htab
->elf
.igotplt
->size
== 0))
3801 htab
->elf
.sgotplt
->size
= 0;
3804 if (htab
->plt_eh_frame
!= NULL
3805 && htab
->elf
.splt
!= NULL
3806 && htab
->elf
.splt
->size
!= 0
3807 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3808 && _bfd_elf_eh_frame_present (info
))
3810 const struct elf_x86_64_backend_data
*arch_data
3811 = get_elf_x86_64_arch_data (bed
);
3812 htab
->plt_eh_frame
->size
= arch_data
->eh_frame_plt_size
;
3815 /* We now have determined the sizes of the various dynamic sections.
3816 Allocate memory for them. */
3818 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3820 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3823 if (s
== htab
->elf
.splt
3824 || s
== htab
->elf
.sgot
3825 || s
== htab
->elf
.sgotplt
3826 || s
== htab
->elf
.iplt
3827 || s
== htab
->elf
.igotplt
3828 || s
== htab
->plt_bnd
3829 || s
== htab
->plt_got
3830 || s
== htab
->plt_eh_frame
3831 || s
== htab
->sdynbss
)
3833 /* Strip this section if we don't need it; see the
3836 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3838 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
3841 /* We use the reloc_count field as a counter if we need
3842 to copy relocs into the output file. */
3843 if (s
!= htab
->elf
.srelplt
)
3848 /* It's not one of our sections, so don't allocate space. */
3854 /* If we don't need this section, strip it from the
3855 output file. This is mostly to handle .rela.bss and
3856 .rela.plt. We must create both sections in
3857 create_dynamic_sections, because they must be created
3858 before the linker maps input sections to output
3859 sections. The linker does that before
3860 adjust_dynamic_symbol is called, and it is that
3861 function which decides whether anything needs to go
3862 into these sections. */
3864 s
->flags
|= SEC_EXCLUDE
;
3868 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3871 /* Allocate memory for the section contents. We use bfd_zalloc
3872 here in case unused entries are not reclaimed before the
3873 section's contents are written out. This should not happen,
3874 but this way if it does, we get a R_X86_64_NONE reloc instead
3876 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3877 if (s
->contents
== NULL
)
3881 if (htab
->plt_eh_frame
!= NULL
3882 && htab
->plt_eh_frame
->contents
!= NULL
)
3884 const struct elf_x86_64_backend_data
*arch_data
3885 = get_elf_x86_64_arch_data (bed
);
3887 memcpy (htab
->plt_eh_frame
->contents
,
3888 arch_data
->eh_frame_plt
, htab
->plt_eh_frame
->size
);
3889 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3890 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3893 if (htab
->elf
.dynamic_sections_created
)
3895 /* Add some entries to the .dynamic section. We fill in the
3896 values later, in elf_x86_64_finish_dynamic_sections, but we
3897 must add the entries now so that we get the correct size for
3898 the .dynamic section. The DT_DEBUG entry is filled in by the
3899 dynamic linker and used by the debugger. */
3900 #define add_dynamic_entry(TAG, VAL) \
3901 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3903 if (bfd_link_executable (info
))
3905 if (!add_dynamic_entry (DT_DEBUG
, 0))
3909 if (htab
->elf
.splt
->size
!= 0)
3911 /* DT_PLTGOT is used by prelink even if there is no PLT
3913 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3916 if (htab
->elf
.srelplt
->size
!= 0)
3918 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3919 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3920 || !add_dynamic_entry (DT_JMPREL
, 0))
3924 if (htab
->tlsdesc_plt
3925 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3926 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3932 if (!add_dynamic_entry (DT_RELA
, 0)
3933 || !add_dynamic_entry (DT_RELASZ
, 0)
3934 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3937 /* If any dynamic relocs apply to a read-only section,
3938 then we need a DT_TEXTREL entry. */
3939 if ((info
->flags
& DF_TEXTREL
) == 0)
3940 elf_link_hash_traverse (&htab
->elf
,
3941 elf_x86_64_readonly_dynrelocs
,
3944 if ((info
->flags
& DF_TEXTREL
) != 0)
3946 if (htab
->readonly_dynrelocs_against_ifunc
)
3948 info
->callbacks
->einfo
3949 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3950 bfd_set_error (bfd_error_bad_value
);
3954 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3959 #undef add_dynamic_entry
3965 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3966 struct bfd_link_info
*info
)
3968 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3972 struct elf_link_hash_entry
*tlsbase
;
3974 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3975 "_TLS_MODULE_BASE_",
3976 FALSE
, FALSE
, FALSE
);
3978 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3980 struct elf_x86_64_link_hash_table
*htab
;
3981 struct bfd_link_hash_entry
*bh
= NULL
;
3982 const struct elf_backend_data
*bed
3983 = get_elf_backend_data (output_bfd
);
3985 htab
= elf_x86_64_hash_table (info
);
3989 if (!(_bfd_generic_link_add_one_symbol
3990 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3991 tls_sec
, 0, NULL
, FALSE
,
3992 bed
->collect
, &bh
)))
3995 htab
->tls_module_base
= bh
;
3997 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3998 tlsbase
->def_regular
= 1;
3999 tlsbase
->other
= STV_HIDDEN
;
4000 tlsbase
->root
.linker_def
= 1;
4001 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
4008 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
4009 executables. Rather than setting it to the beginning of the TLS
4010 section, we have to set it to the end. This function may be called
4011 multiple times, it is idempotent. */
4014 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
4016 struct elf_x86_64_link_hash_table
*htab
;
4017 struct bfd_link_hash_entry
*base
;
4019 if (!bfd_link_executable (info
))
4022 htab
= elf_x86_64_hash_table (info
);
4026 base
= htab
->tls_module_base
;
4030 base
->u
.def
.value
= htab
->elf
.tls_size
;
4033 /* Return the base VMA address which should be subtracted from real addresses
4034 when resolving @dtpoff relocation.
4035 This is PT_TLS segment p_vaddr. */
4038 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
4040 /* If tls_sec is NULL, we should have signalled an error already. */
4041 if (elf_hash_table (info
)->tls_sec
== NULL
)
4043 return elf_hash_table (info
)->tls_sec
->vma
;
4046 /* Return the relocation value for @tpoff relocation
4047 if STT_TLS virtual address is ADDRESS. */
4050 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
4052 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
4053 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
4054 bfd_vma static_tls_size
;
4056 /* If tls_segment is NULL, we should have signalled an error already. */
4057 if (htab
->tls_sec
== NULL
)
4060 /* Consider special static TLS alignment requirements. */
4061 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
4062 return address
- static_tls_size
- htab
->tls_sec
->vma
;
4065 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
4069 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
4071 /* Opcode Instruction
4074 0x0f 0x8x conditional jump */
4076 && (contents
[offset
- 1] == 0xe8
4077 || contents
[offset
- 1] == 0xe9))
4079 && contents
[offset
- 2] == 0x0f
4080 && (contents
[offset
- 1] & 0xf0) == 0x80));
4083 /* Relocate an x86_64 ELF section. */
4086 elf_x86_64_relocate_section (bfd
*output_bfd
,
4087 struct bfd_link_info
*info
,
4089 asection
*input_section
,
4091 Elf_Internal_Rela
*relocs
,
4092 Elf_Internal_Sym
*local_syms
,
4093 asection
**local_sections
)
4095 struct elf_x86_64_link_hash_table
*htab
;
4096 Elf_Internal_Shdr
*symtab_hdr
;
4097 struct elf_link_hash_entry
**sym_hashes
;
4098 bfd_vma
*local_got_offsets
;
4099 bfd_vma
*local_tlsdesc_gotents
;
4100 Elf_Internal_Rela
*rel
;
4101 Elf_Internal_Rela
*wrel
;
4102 Elf_Internal_Rela
*relend
;
4103 const unsigned int plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
4105 BFD_ASSERT (is_x86_64_elf (input_bfd
));
4107 /* Skip if check_relocs failed. */
4108 if (input_section
->check_relocs_failed
)
4111 htab
= elf_x86_64_hash_table (info
);
4114 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
4115 sym_hashes
= elf_sym_hashes (input_bfd
);
4116 local_got_offsets
= elf_local_got_offsets (input_bfd
);
4117 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
4119 elf_x86_64_set_tls_module_base (info
);
4121 rel
= wrel
= relocs
;
4122 relend
= relocs
+ input_section
->reloc_count
;
4123 for (; rel
< relend
; wrel
++, rel
++)
4125 unsigned int r_type
;
4126 reloc_howto_type
*howto
;
4127 unsigned long r_symndx
;
4128 struct elf_link_hash_entry
*h
;
4129 struct elf_x86_64_link_hash_entry
*eh
;
4130 Elf_Internal_Sym
*sym
;
4132 bfd_vma off
, offplt
, plt_offset
;
4134 bfd_boolean unresolved_reloc
;
4135 bfd_reloc_status_type r
;
4137 asection
*base_got
, *resolved_plt
;
4139 bfd_boolean resolved_to_zero
;
4141 r_type
= ELF32_R_TYPE (rel
->r_info
);
4142 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
4143 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
4150 if (r_type
>= (int) R_X86_64_standard
)
4153 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
4154 input_bfd
, input_section
, r_type
);
4155 bfd_set_error (bfd_error_bad_value
);
4159 if (r_type
!= (int) R_X86_64_32
4160 || ABI_64_P (output_bfd
))
4161 howto
= x86_64_elf_howto_table
+ r_type
;
4163 howto
= (x86_64_elf_howto_table
4164 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
4165 r_symndx
= htab
->r_sym (rel
->r_info
);
4169 unresolved_reloc
= FALSE
;
4170 if (r_symndx
< symtab_hdr
->sh_info
)
4172 sym
= local_syms
+ r_symndx
;
4173 sec
= local_sections
[r_symndx
];
4175 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
4177 st_size
= sym
->st_size
;
4179 /* Relocate against local STT_GNU_IFUNC symbol. */
4180 if (!bfd_link_relocatable (info
)
4181 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
4183 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
4188 /* Set STT_GNU_IFUNC symbol value. */
4189 h
->root
.u
.def
.value
= sym
->st_value
;
4190 h
->root
.u
.def
.section
= sec
;
4195 bfd_boolean warned ATTRIBUTE_UNUSED
;
4196 bfd_boolean ignored ATTRIBUTE_UNUSED
;
4198 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
4199 r_symndx
, symtab_hdr
, sym_hashes
,
4201 unresolved_reloc
, warned
, ignored
);
4205 if (sec
!= NULL
&& discarded_section (sec
))
4207 _bfd_clear_contents (howto
, input_bfd
, input_section
,
4208 contents
+ rel
->r_offset
);
4209 wrel
->r_offset
= rel
->r_offset
;
4213 /* For ld -r, remove relocations in debug sections against
4214 sections defined in discarded sections. Not done for
4215 eh_frame editing code expects to be present. */
4216 if (bfd_link_relocatable (info
)
4217 && (input_section
->flags
& SEC_DEBUGGING
))
4223 if (bfd_link_relocatable (info
))
4230 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
4232 if (r_type
== R_X86_64_64
)
4234 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
4235 zero-extend it to 64bit if addend is zero. */
4236 r_type
= R_X86_64_32
;
4237 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4239 else if (r_type
== R_X86_64_SIZE64
)
4241 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
4242 zero-extend it to 64bit if addend is zero. */
4243 r_type
= R_X86_64_SIZE32
;
4244 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4248 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
4250 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
4251 it here if it is defined in a non-shared object. */
4253 && h
->type
== STT_GNU_IFUNC
4259 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4261 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4262 sections because such sections are not SEC_ALLOC and
4263 thus ld.so will not process them. */
4264 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
4274 case R_X86_64_GOTPCREL
:
4275 case R_X86_64_GOTPCRELX
:
4276 case R_X86_64_REX_GOTPCRELX
:
4277 case R_X86_64_GOTPCREL64
:
4278 base_got
= htab
->elf
.sgot
;
4279 off
= h
->got
.offset
;
4281 if (base_got
== NULL
)
4284 if (off
== (bfd_vma
) -1)
4286 /* We can't use h->got.offset here to save state, or
4287 even just remember the offset, as finish_dynamic_symbol
4288 would use that as offset into .got. */
4290 if (h
->plt
.offset
== (bfd_vma
) -1)
4293 if (htab
->elf
.splt
!= NULL
)
4295 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4296 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4297 base_got
= htab
->elf
.sgotplt
;
4301 plt_index
= h
->plt
.offset
/ plt_entry_size
;
4302 off
= plt_index
* GOT_ENTRY_SIZE
;
4303 base_got
= htab
->elf
.igotplt
;
4306 if (h
->dynindx
== -1
4310 /* This references the local defitionion. We must
4311 initialize this entry in the global offset table.
4312 Since the offset must always be a multiple of 8,
4313 we use the least significant bit to record
4314 whether we have initialized it already.
4316 When doing a dynamic link, we create a .rela.got
4317 relocation entry to initialize the value. This
4318 is done in the finish_dynamic_symbol routine. */
4323 bfd_put_64 (output_bfd
, relocation
,
4324 base_got
->contents
+ off
);
4325 /* Note that this is harmless for the GOTPLT64
4326 case, as -1 | 1 still is -1. */
4332 relocation
= (base_got
->output_section
->vma
4333 + base_got
->output_offset
+ off
);
4338 if (h
->plt
.offset
== (bfd_vma
) -1)
4340 /* Handle static pointers of STT_GNU_IFUNC symbols. */
4341 if (r_type
== htab
->pointer_r_type
4342 && (input_section
->flags
& SEC_CODE
) == 0)
4343 goto do_ifunc_pointer
;
4344 goto bad_ifunc_reloc
;
4347 /* STT_GNU_IFUNC symbol must go through PLT. */
4348 if (htab
->elf
.splt
!= NULL
)
4350 if (htab
->plt_bnd
!= NULL
)
4352 resolved_plt
= htab
->plt_bnd
;
4353 plt_offset
= eh
->plt_bnd
.offset
;
4357 resolved_plt
= htab
->elf
.splt
;
4358 plt_offset
= h
->plt
.offset
;
4363 resolved_plt
= htab
->elf
.iplt
;
4364 plt_offset
= h
->plt
.offset
;
4367 relocation
= (resolved_plt
->output_section
->vma
4368 + resolved_plt
->output_offset
+ plt_offset
);
4374 if (h
->root
.root
.string
)
4375 name
= h
->root
.root
.string
;
4377 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4380 (_("%B: relocation %s against STT_GNU_IFUNC "
4381 "symbol `%s' isn't supported"), input_bfd
,
4383 bfd_set_error (bfd_error_bad_value
);
4387 if (bfd_link_pic (info
))
4392 if (ABI_64_P (output_bfd
))
4397 if (rel
->r_addend
!= 0)
4399 if (h
->root
.root
.string
)
4400 name
= h
->root
.root
.string
;
4402 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4405 (_("%B: relocation %s against STT_GNU_IFUNC "
4406 "symbol `%s' has non-zero addend: %d"),
4407 input_bfd
, howto
->name
, name
, rel
->r_addend
);
4408 bfd_set_error (bfd_error_bad_value
);
4412 /* Generate dynamic relcoation only when there is a
4413 non-GOT reference in a shared object or there is no
4415 if ((bfd_link_pic (info
) && h
->non_got_ref
)
4416 || h
->plt
.offset
== (bfd_vma
) -1)
4418 Elf_Internal_Rela outrel
;
4421 /* Need a dynamic relocation to get the real function
4423 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
4427 if (outrel
.r_offset
== (bfd_vma
) -1
4428 || outrel
.r_offset
== (bfd_vma
) -2)
4431 outrel
.r_offset
+= (input_section
->output_section
->vma
4432 + input_section
->output_offset
);
4434 if (h
->dynindx
== -1
4436 || bfd_link_executable (info
))
4438 /* This symbol is resolved locally. */
4439 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4440 outrel
.r_addend
= (h
->root
.u
.def
.value
4441 + h
->root
.u
.def
.section
->output_section
->vma
4442 + h
->root
.u
.def
.section
->output_offset
);
4446 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4447 outrel
.r_addend
= 0;
4450 /* Dynamic relocations are stored in
4451 1. .rela.ifunc section in PIC object.
4452 2. .rela.got section in dynamic executable.
4453 3. .rela.iplt section in static executable. */
4454 if (bfd_link_pic (info
))
4455 sreloc
= htab
->elf
.irelifunc
;
4456 else if (htab
->elf
.splt
!= NULL
)
4457 sreloc
= htab
->elf
.srelgot
;
4459 sreloc
= htab
->elf
.irelplt
;
4460 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4462 /* If this reloc is against an external symbol, we
4463 do not want to fiddle with the addend. Otherwise,
4464 we need to include the symbol value so that it
4465 becomes an addend for the dynamic reloc. For an
4466 internal symbol, we have updated addend. */
4471 case R_X86_64_PC32_BND
:
4473 case R_X86_64_PLT32
:
4474 case R_X86_64_PLT32_BND
:
4479 resolved_to_zero
= (eh
!= NULL
4480 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
4484 /* When generating a shared object, the relocations handled here are
4485 copied into the output file to be resolved at run time. */
4488 case R_X86_64_GOT32
:
4489 case R_X86_64_GOT64
:
4490 /* Relocation is to the entry for this symbol in the global
4492 case R_X86_64_GOTPCREL
:
4493 case R_X86_64_GOTPCRELX
:
4494 case R_X86_64_REX_GOTPCRELX
:
4495 case R_X86_64_GOTPCREL64
:
4496 /* Use global offset table entry as symbol value. */
4497 case R_X86_64_GOTPLT64
:
4498 /* This is obsolete and treated the the same as GOT64. */
4499 base_got
= htab
->elf
.sgot
;
4501 if (htab
->elf
.sgot
== NULL
)
4508 off
= h
->got
.offset
;
4510 && h
->plt
.offset
!= (bfd_vma
)-1
4511 && off
== (bfd_vma
)-1)
4513 /* We can't use h->got.offset here to save
4514 state, or even just remember the offset, as
4515 finish_dynamic_symbol would use that as offset into
4517 bfd_vma plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4518 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4519 base_got
= htab
->elf
.sgotplt
;
4522 dyn
= htab
->elf
.dynamic_sections_created
;
4524 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
4525 || (bfd_link_pic (info
)
4526 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4527 || (ELF_ST_VISIBILITY (h
->other
)
4528 && h
->root
.type
== bfd_link_hash_undefweak
))
4530 /* This is actually a static link, or it is a -Bsymbolic
4531 link and the symbol is defined locally, or the symbol
4532 was forced to be local because of a version file. We
4533 must initialize this entry in the global offset table.
4534 Since the offset must always be a multiple of 8, we
4535 use the least significant bit to record whether we
4536 have initialized it already.
4538 When doing a dynamic link, we create a .rela.got
4539 relocation entry to initialize the value. This is
4540 done in the finish_dynamic_symbol routine. */
4545 bfd_put_64 (output_bfd
, relocation
,
4546 base_got
->contents
+ off
);
4547 /* Note that this is harmless for the GOTPLT64 case,
4548 as -1 | 1 still is -1. */
4553 unresolved_reloc
= FALSE
;
4557 if (local_got_offsets
== NULL
)
4560 off
= local_got_offsets
[r_symndx
];
4562 /* The offset must always be a multiple of 8. We use
4563 the least significant bit to record whether we have
4564 already generated the necessary reloc. */
4569 bfd_put_64 (output_bfd
, relocation
,
4570 base_got
->contents
+ off
);
4572 if (bfd_link_pic (info
))
4575 Elf_Internal_Rela outrel
;
4577 /* We need to generate a R_X86_64_RELATIVE reloc
4578 for the dynamic linker. */
4579 s
= htab
->elf
.srelgot
;
4583 outrel
.r_offset
= (base_got
->output_section
->vma
4584 + base_got
->output_offset
4586 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4587 outrel
.r_addend
= relocation
;
4588 elf_append_rela (output_bfd
, s
, &outrel
);
4591 local_got_offsets
[r_symndx
] |= 1;
4595 if (off
>= (bfd_vma
) -2)
4598 relocation
= base_got
->output_section
->vma
4599 + base_got
->output_offset
+ off
;
4600 if (r_type
!= R_X86_64_GOTPCREL
4601 && r_type
!= R_X86_64_GOTPCRELX
4602 && r_type
!= R_X86_64_REX_GOTPCRELX
4603 && r_type
!= R_X86_64_GOTPCREL64
)
4604 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4605 - htab
->elf
.sgotplt
->output_offset
;
4609 case R_X86_64_GOTOFF64
:
4610 /* Relocation is relative to the start of the global offset
4613 /* Check to make sure it isn't a protected function or data
4614 symbol for shared library since it may not be local when
4615 used as function address or with copy relocation. We also
4616 need to make sure that a symbol is referenced locally. */
4617 if (bfd_link_pic (info
) && h
)
4619 if (!h
->def_regular
)
4623 switch (ELF_ST_VISIBILITY (h
->other
))
4626 v
= _("hidden symbol");
4629 v
= _("internal symbol");
4632 v
= _("protected symbol");
4640 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s `%s' can not be used when making a shared object"),
4641 input_bfd
, v
, h
->root
.root
.string
);
4642 bfd_set_error (bfd_error_bad_value
);
4645 else if (!bfd_link_executable (info
)
4646 && !SYMBOL_REFERENCES_LOCAL (info
, h
)
4647 && (h
->type
== STT_FUNC
4648 || h
->type
== STT_OBJECT
)
4649 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4652 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s `%s' can not be used when making a shared object"),
4654 h
->type
== STT_FUNC
? "function" : "data",
4655 h
->root
.root
.string
);
4656 bfd_set_error (bfd_error_bad_value
);
4661 /* Note that sgot is not involved in this
4662 calculation. We always want the start of .got.plt. If we
4663 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4664 permitted by the ABI, we might have to change this
4666 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4667 + htab
->elf
.sgotplt
->output_offset
;
4670 case R_X86_64_GOTPC32
:
4671 case R_X86_64_GOTPC64
:
4672 /* Use global offset table as symbol value. */
4673 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4674 + htab
->elf
.sgotplt
->output_offset
;
4675 unresolved_reloc
= FALSE
;
4678 case R_X86_64_PLTOFF64
:
4679 /* Relocation is PLT entry relative to GOT. For local
4680 symbols it's the symbol itself relative to GOT. */
4682 /* See PLT32 handling. */
4683 && h
->plt
.offset
!= (bfd_vma
) -1
4684 && htab
->elf
.splt
!= NULL
)
4686 if (htab
->plt_bnd
!= NULL
)
4688 resolved_plt
= htab
->plt_bnd
;
4689 plt_offset
= eh
->plt_bnd
.offset
;
4693 resolved_plt
= htab
->elf
.splt
;
4694 plt_offset
= h
->plt
.offset
;
4697 relocation
= (resolved_plt
->output_section
->vma
4698 + resolved_plt
->output_offset
4700 unresolved_reloc
= FALSE
;
4703 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4704 + htab
->elf
.sgotplt
->output_offset
;
4707 case R_X86_64_PLT32
:
4708 case R_X86_64_PLT32_BND
:
4709 /* Relocation is to the entry for this symbol in the
4710 procedure linkage table. */
4712 /* Resolve a PLT32 reloc against a local symbol directly,
4713 without using the procedure linkage table. */
4717 if ((h
->plt
.offset
== (bfd_vma
) -1
4718 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4719 || htab
->elf
.splt
== NULL
)
4721 /* We didn't make a PLT entry for this symbol. This
4722 happens when statically linking PIC code, or when
4723 using -Bsymbolic. */
4727 if (h
->plt
.offset
!= (bfd_vma
) -1)
4729 if (htab
->plt_bnd
!= NULL
)
4731 resolved_plt
= htab
->plt_bnd
;
4732 plt_offset
= eh
->plt_bnd
.offset
;
4736 resolved_plt
= htab
->elf
.splt
;
4737 plt_offset
= h
->plt
.offset
;
4742 /* Use the GOT PLT. */
4743 resolved_plt
= htab
->plt_got
;
4744 plt_offset
= eh
->plt_got
.offset
;
4747 relocation
= (resolved_plt
->output_section
->vma
4748 + resolved_plt
->output_offset
4750 unresolved_reloc
= FALSE
;
4753 case R_X86_64_SIZE32
:
4754 case R_X86_64_SIZE64
:
4755 /* Set to symbol size. */
4756 relocation
= st_size
;
4762 case R_X86_64_PC32_BND
:
4763 /* Don't complain about -fPIC if the symbol is undefined when
4764 building executable unless it is unresolved weak symbol. */
4765 if ((input_section
->flags
& SEC_ALLOC
) != 0
4766 && (input_section
->flags
& SEC_READONLY
) != 0
4768 && ((bfd_link_executable (info
)
4769 && h
->root
.type
== bfd_link_hash_undefweak
4770 && !resolved_to_zero
)
4771 || (bfd_link_pic (info
)
4772 && !(bfd_link_pie (info
)
4773 && h
->root
.type
== bfd_link_hash_undefined
))))
4775 bfd_boolean fail
= FALSE
;
4777 = ((r_type
== R_X86_64_PC32
4778 || r_type
== R_X86_64_PC32_BND
)
4779 && is_32bit_relative_branch (contents
, rel
->r_offset
));
4781 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
4783 /* Symbol is referenced locally. Make sure it is
4784 defined locally or for a branch. */
4785 fail
= !h
->def_regular
&& !branch
;
4787 else if (!(bfd_link_pie (info
)
4788 && (h
->needs_copy
|| eh
->needs_copy
)))
4790 /* Symbol doesn't need copy reloc and isn't referenced
4791 locally. We only allow branch to symbol with
4792 non-default visibility. */
4794 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
4798 return elf_x86_64_need_pic (input_bfd
, input_section
,
4799 h
, NULL
, NULL
, howto
);
4808 /* FIXME: The ABI says the linker should make sure the value is
4809 the same when it's zeroextended to 64 bit. */
4812 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4815 /* Don't copy a pc-relative relocation into the output file
4816 if the symbol needs copy reloc or the symbol is undefined
4817 when building executable. Copy dynamic function pointer
4818 relocations. Don't generate dynamic relocations against
4819 resolved undefined weak symbols in PIE. */
4820 if ((bfd_link_pic (info
)
4821 && !(bfd_link_pie (info
)
4825 || h
->root
.type
== bfd_link_hash_undefined
)
4826 && (IS_X86_64_PCREL_TYPE (r_type
)
4827 || r_type
== R_X86_64_SIZE32
4828 || r_type
== R_X86_64_SIZE64
))
4830 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4831 && !resolved_to_zero
)
4832 || h
->root
.type
!= bfd_link_hash_undefweak
))
4833 && ((! IS_X86_64_PCREL_TYPE (r_type
)
4834 && r_type
!= R_X86_64_SIZE32
4835 && r_type
!= R_X86_64_SIZE64
)
4836 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
4837 || (ELIMINATE_COPY_RELOCS
4838 && !bfd_link_pic (info
)
4842 || eh
->func_pointer_refcount
> 0
4843 || (h
->root
.type
== bfd_link_hash_undefweak
4844 && !resolved_to_zero
))
4845 && ((h
->def_dynamic
&& !h
->def_regular
)
4846 /* Undefined weak symbol is bound locally when
4848 || h
->root
.type
== bfd_link_hash_undefined
)))
4850 Elf_Internal_Rela outrel
;
4851 bfd_boolean skip
, relocate
;
4854 /* When generating a shared object, these relocations
4855 are copied into the output file to be resolved at run
4861 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4863 if (outrel
.r_offset
== (bfd_vma
) -1)
4865 else if (outrel
.r_offset
== (bfd_vma
) -2)
4866 skip
= TRUE
, relocate
= TRUE
;
4868 outrel
.r_offset
+= (input_section
->output_section
->vma
4869 + input_section
->output_offset
);
4872 memset (&outrel
, 0, sizeof outrel
);
4874 /* h->dynindx may be -1 if this symbol was marked to
4878 && (IS_X86_64_PCREL_TYPE (r_type
)
4879 || !(bfd_link_executable (info
)
4880 || SYMBOLIC_BIND (info
, h
))
4881 || ! h
->def_regular
))
4883 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4884 outrel
.r_addend
= rel
->r_addend
;
4888 /* This symbol is local, or marked to become local.
4889 When relocation overflow check is disabled, we
4890 convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */
4891 if (r_type
== htab
->pointer_r_type
4892 || (r_type
== R_X86_64_32
4893 && info
->no_reloc_overflow_check
))
4896 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4897 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4899 else if (r_type
== R_X86_64_64
4900 && !ABI_64_P (output_bfd
))
4903 outrel
.r_info
= htab
->r_info (0,
4904 R_X86_64_RELATIVE64
);
4905 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4906 /* Check addend overflow. */
4907 if ((outrel
.r_addend
& 0x80000000)
4908 != (rel
->r_addend
& 0x80000000))
4911 int addend
= rel
->r_addend
;
4912 if (h
&& h
->root
.root
.string
)
4913 name
= h
->root
.root
.string
;
4915 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4919 (_("%B: addend -0x%x in relocation %s against "
4920 "symbol `%s' at 0x%lx in section `%A' is "
4922 input_bfd
, input_section
, addend
,
4924 (unsigned long) rel
->r_offset
);
4927 (_("%B: addend 0x%x in relocation %s against "
4928 "symbol `%s' at 0x%lx in section `%A' is "
4930 input_bfd
, input_section
, addend
,
4932 (unsigned long) rel
->r_offset
);
4933 bfd_set_error (bfd_error_bad_value
);
4941 if (bfd_is_abs_section (sec
))
4943 else if (sec
== NULL
|| sec
->owner
== NULL
)
4945 bfd_set_error (bfd_error_bad_value
);
4952 /* We are turning this relocation into one
4953 against a section symbol. It would be
4954 proper to subtract the symbol's value,
4955 osec->vma, from the emitted reloc addend,
4956 but ld.so expects buggy relocs. */
4957 osec
= sec
->output_section
;
4958 sindx
= elf_section_data (osec
)->dynindx
;
4961 asection
*oi
= htab
->elf
.text_index_section
;
4962 sindx
= elf_section_data (oi
)->dynindx
;
4964 BFD_ASSERT (sindx
!= 0);
4967 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
4968 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4972 sreloc
= elf_section_data (input_section
)->sreloc
;
4974 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4976 r
= bfd_reloc_notsupported
;
4977 goto check_relocation_error
;
4980 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4982 /* If this reloc is against an external symbol, we do
4983 not want to fiddle with the addend. Otherwise, we
4984 need to include the symbol value so that it becomes
4985 an addend for the dynamic reloc. */
4992 case R_X86_64_TLSGD
:
4993 case R_X86_64_GOTPC32_TLSDESC
:
4994 case R_X86_64_TLSDESC_CALL
:
4995 case R_X86_64_GOTTPOFF
:
4996 tls_type
= GOT_UNKNOWN
;
4997 if (h
== NULL
&& local_got_offsets
)
4998 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
5000 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
5002 if (! elf_x86_64_tls_transition (info
, input_bfd
,
5003 input_section
, contents
,
5004 symtab_hdr
, sym_hashes
,
5005 &r_type
, tls_type
, rel
,
5006 relend
, h
, r_symndx
, TRUE
))
5009 if (r_type
== R_X86_64_TPOFF32
)
5011 bfd_vma roff
= rel
->r_offset
;
5013 BFD_ASSERT (! unresolved_reloc
);
5015 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5017 /* GD->LE transition. For 64bit, change
5018 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5019 .word 0x6666; rex64; call __tls_get_addr@PLT
5021 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5023 call *__tls_get_addr@GOTPCREL(%rip)
5024 which may be converted to
5025 addr32 call __tls_get_addr
5028 leaq foo@tpoff(%rax), %rax
5030 leaq foo@tlsgd(%rip), %rdi
5031 .word 0x6666; rex64; call __tls_get_addr@PLT
5033 leaq foo@tlsgd(%rip), %rdi
5035 call *__tls_get_addr@GOTPCREL(%rip)
5036 which may be converted to
5037 addr32 call __tls_get_addr
5040 leaq foo@tpoff(%rax), %rax
5041 For largepic, change:
5042 leaq foo@tlsgd(%rip), %rdi
5043 movabsq $__tls_get_addr@pltoff, %rax
5048 leaq foo@tpoff(%rax), %rax
5049 nopw 0x0(%rax,%rax,1) */
5051 if (ABI_64_P (output_bfd
))
5053 if (contents
[roff
+ 5] == 0xb8)
5055 memcpy (contents
+ roff
- 3,
5056 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
5057 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5061 memcpy (contents
+ roff
- 4,
5062 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5066 memcpy (contents
+ roff
- 3,
5067 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5069 bfd_put_32 (output_bfd
,
5070 elf_x86_64_tpoff (info
, relocation
),
5071 contents
+ roff
+ 8 + largepic
);
5072 /* Skip R_X86_64_PC32, R_X86_64_PLT32,
5073 R_X86_64_GOTPCRELX and R_X86_64_PLTOFF64. */
5078 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5080 /* GDesc -> LE transition.
5081 It's originally something like:
5082 leaq x@tlsdesc(%rip), %rax
5085 movl $x@tpoff, %rax. */
5087 unsigned int val
, type
;
5089 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5090 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5091 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
5092 contents
+ roff
- 3);
5093 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
5094 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
5095 contents
+ roff
- 1);
5096 bfd_put_32 (output_bfd
,
5097 elf_x86_64_tpoff (info
, relocation
),
5101 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5103 /* GDesc -> LE transition.
5108 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5109 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5112 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
5114 /* IE->LE transition:
5115 For 64bit, originally it can be one of:
5116 movq foo@gottpoff(%rip), %reg
5117 addq foo@gottpoff(%rip), %reg
5120 leaq foo(%reg), %reg
5122 For 32bit, originally it can be one of:
5123 movq foo@gottpoff(%rip), %reg
5124 addl foo@gottpoff(%rip), %reg
5127 leal foo(%reg), %reg
5130 unsigned int val
, type
, reg
;
5133 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5136 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
5137 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5143 bfd_put_8 (output_bfd
, 0x49,
5144 contents
+ roff
- 3);
5145 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5146 bfd_put_8 (output_bfd
, 0x41,
5147 contents
+ roff
- 3);
5148 bfd_put_8 (output_bfd
, 0xc7,
5149 contents
+ roff
- 2);
5150 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5151 contents
+ roff
- 1);
5155 /* addq/addl -> addq/addl - addressing with %rsp/%r12
5158 bfd_put_8 (output_bfd
, 0x49,
5159 contents
+ roff
- 3);
5160 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5161 bfd_put_8 (output_bfd
, 0x41,
5162 contents
+ roff
- 3);
5163 bfd_put_8 (output_bfd
, 0x81,
5164 contents
+ roff
- 2);
5165 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5166 contents
+ roff
- 1);
5170 /* addq/addl -> leaq/leal */
5172 bfd_put_8 (output_bfd
, 0x4d,
5173 contents
+ roff
- 3);
5174 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5175 bfd_put_8 (output_bfd
, 0x45,
5176 contents
+ roff
- 3);
5177 bfd_put_8 (output_bfd
, 0x8d,
5178 contents
+ roff
- 2);
5179 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
5180 contents
+ roff
- 1);
5182 bfd_put_32 (output_bfd
,
5183 elf_x86_64_tpoff (info
, relocation
),
5191 if (htab
->elf
.sgot
== NULL
)
5196 off
= h
->got
.offset
;
5197 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
5201 if (local_got_offsets
== NULL
)
5204 off
= local_got_offsets
[r_symndx
];
5205 offplt
= local_tlsdesc_gotents
[r_symndx
];
5212 Elf_Internal_Rela outrel
;
5216 if (htab
->elf
.srelgot
== NULL
)
5219 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
5221 if (GOT_TLS_GDESC_P (tls_type
))
5223 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
5224 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
5225 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
5226 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5227 + htab
->elf
.sgotplt
->output_offset
5229 + htab
->sgotplt_jump_table_size
);
5230 sreloc
= htab
->elf
.srelplt
;
5232 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5234 outrel
.r_addend
= 0;
5235 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5238 sreloc
= htab
->elf
.srelgot
;
5240 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5241 + htab
->elf
.sgot
->output_offset
+ off
);
5243 if (GOT_TLS_GD_P (tls_type
))
5244 dr_type
= R_X86_64_DTPMOD64
;
5245 else if (GOT_TLS_GDESC_P (tls_type
))
5248 dr_type
= R_X86_64_TPOFF64
;
5250 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
5251 outrel
.r_addend
= 0;
5252 if ((dr_type
== R_X86_64_TPOFF64
5253 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
5254 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5255 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
5257 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5259 if (GOT_TLS_GD_P (tls_type
))
5263 BFD_ASSERT (! unresolved_reloc
);
5264 bfd_put_64 (output_bfd
,
5265 relocation
- elf_x86_64_dtpoff_base (info
),
5266 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5270 bfd_put_64 (output_bfd
, 0,
5271 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5272 outrel
.r_info
= htab
->r_info (indx
,
5274 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
5275 elf_append_rela (output_bfd
, sreloc
,
5284 local_got_offsets
[r_symndx
] |= 1;
5287 if (off
>= (bfd_vma
) -2
5288 && ! GOT_TLS_GDESC_P (tls_type
))
5290 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
5292 if (r_type
== R_X86_64_GOTPC32_TLSDESC
5293 || r_type
== R_X86_64_TLSDESC_CALL
)
5294 relocation
= htab
->elf
.sgotplt
->output_section
->vma
5295 + htab
->elf
.sgotplt
->output_offset
5296 + offplt
+ htab
->sgotplt_jump_table_size
;
5298 relocation
= htab
->elf
.sgot
->output_section
->vma
5299 + htab
->elf
.sgot
->output_offset
+ off
;
5300 unresolved_reloc
= FALSE
;
5304 bfd_vma roff
= rel
->r_offset
;
5306 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5308 /* GD->IE transition. For 64bit, change
5309 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5310 .word 0x6666; rex64; call __tls_get_addr@PLT
5312 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5314 call *__tls_get_addr@GOTPCREL(%rip
5315 which may be converted to
5316 addr32 call __tls_get_addr
5319 addq foo@gottpoff(%rip), %rax
5321 leaq foo@tlsgd(%rip), %rdi
5322 .word 0x6666; rex64; call __tls_get_addr@PLT
5324 leaq foo@tlsgd(%rip), %rdi
5326 call *__tls_get_addr@GOTPCREL(%rip)
5327 which may be converted to
5328 addr32 call __tls_get_addr
5331 addq foo@gottpoff(%rip), %rax
5332 For largepic, change:
5333 leaq foo@tlsgd(%rip), %rdi
5334 movabsq $__tls_get_addr@pltoff, %rax
5339 addq foo@gottpoff(%rax), %rax
5340 nopw 0x0(%rax,%rax,1) */
5342 if (ABI_64_P (output_bfd
))
5344 if (contents
[roff
+ 5] == 0xb8)
5346 memcpy (contents
+ roff
- 3,
5347 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
5348 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5352 memcpy (contents
+ roff
- 4,
5353 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5357 memcpy (contents
+ roff
- 3,
5358 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5361 relocation
= (htab
->elf
.sgot
->output_section
->vma
5362 + htab
->elf
.sgot
->output_offset
+ off
5365 - input_section
->output_section
->vma
5366 - input_section
->output_offset
5368 bfd_put_32 (output_bfd
, relocation
,
5369 contents
+ roff
+ 8 + largepic
);
5370 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5375 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5377 /* GDesc -> IE transition.
5378 It's originally something like:
5379 leaq x@tlsdesc(%rip), %rax
5382 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
5384 /* Now modify the instruction as appropriate. To
5385 turn a leaq into a movq in the form we use it, it
5386 suffices to change the second byte from 0x8d to
5388 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
5390 bfd_put_32 (output_bfd
,
5391 htab
->elf
.sgot
->output_section
->vma
5392 + htab
->elf
.sgot
->output_offset
+ off
5394 - input_section
->output_section
->vma
5395 - input_section
->output_offset
5400 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5402 /* GDesc -> IE transition.
5409 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5410 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5418 case R_X86_64_TLSLD
:
5419 if (! elf_x86_64_tls_transition (info
, input_bfd
,
5420 input_section
, contents
,
5421 symtab_hdr
, sym_hashes
,
5422 &r_type
, GOT_UNKNOWN
, rel
,
5423 relend
, h
, r_symndx
, TRUE
))
5426 if (r_type
!= R_X86_64_TLSLD
)
5428 /* LD->LE transition:
5429 leaq foo@tlsld(%rip), %rdi
5430 call __tls_get_addr@PLT
5431 For 64bit, we change it into:
5432 .word 0x6666; .byte 0x66; movq %fs:0, %rax
5433 For 32bit, we change it into:
5434 nopl 0x0(%rax); movl %fs:0, %eax
5436 leaq foo@tlsld(%rip), %rdi;
5437 call *__tls_get_addr@GOTPCREL(%rip)
5438 which may be converted to
5439 addr32 call __tls_get_addr
5440 For 64bit, we change it into:
5441 .word 0x6666; .word 0x6666; movq %fs:0, %rax
5442 For 32bit, we change it into:
5443 nopw 0x0(%rax); movl %fs:0, %eax
5444 For largepic, change:
5445 leaq foo@tlsgd(%rip), %rdi
5446 movabsq $__tls_get_addr@pltoff, %rax
5450 data16 data16 data16 nopw %cs:0x0(%rax,%rax,1)
5453 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
5454 if (ABI_64_P (output_bfd
))
5456 if (contents
[rel
->r_offset
+ 5] == 0xb8)
5457 memcpy (contents
+ rel
->r_offset
- 3,
5458 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
5459 "\x64\x48\x8b\x04\x25\0\0\0", 22);
5460 else if (contents
[rel
->r_offset
+ 4] == 0xff
5461 || contents
[rel
->r_offset
+ 4] == 0x67)
5462 memcpy (contents
+ rel
->r_offset
- 3,
5463 "\x66\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0",
5466 memcpy (contents
+ rel
->r_offset
- 3,
5467 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
5471 if (contents
[rel
->r_offset
+ 4] == 0xff)
5472 memcpy (contents
+ rel
->r_offset
- 3,
5473 "\x66\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0",
5476 memcpy (contents
+ rel
->r_offset
- 3,
5477 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
5479 /* Skip R_X86_64_PC32, R_X86_64_PLT32, R_X86_64_GOTPCRELX
5480 and R_X86_64_PLTOFF64. */
5486 if (htab
->elf
.sgot
== NULL
)
5489 off
= htab
->tls_ld_got
.offset
;
5494 Elf_Internal_Rela outrel
;
5496 if (htab
->elf
.srelgot
== NULL
)
5499 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5500 + htab
->elf
.sgot
->output_offset
+ off
);
5502 bfd_put_64 (output_bfd
, 0,
5503 htab
->elf
.sgot
->contents
+ off
);
5504 bfd_put_64 (output_bfd
, 0,
5505 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5506 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
5507 outrel
.r_addend
= 0;
5508 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
5510 htab
->tls_ld_got
.offset
|= 1;
5512 relocation
= htab
->elf
.sgot
->output_section
->vma
5513 + htab
->elf
.sgot
->output_offset
+ off
;
5514 unresolved_reloc
= FALSE
;
5517 case R_X86_64_DTPOFF32
:
5518 if (!bfd_link_executable (info
)
5519 || (input_section
->flags
& SEC_CODE
) == 0)
5520 relocation
-= elf_x86_64_dtpoff_base (info
);
5522 relocation
= elf_x86_64_tpoff (info
, relocation
);
5525 case R_X86_64_TPOFF32
:
5526 case R_X86_64_TPOFF64
:
5527 BFD_ASSERT (bfd_link_executable (info
));
5528 relocation
= elf_x86_64_tpoff (info
, relocation
);
5531 case R_X86_64_DTPOFF64
:
5532 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
5533 relocation
-= elf_x86_64_dtpoff_base (info
);
5540 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5541 because such sections are not SEC_ALLOC and thus ld.so will
5542 not process them. */
5543 if (unresolved_reloc
5544 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
5546 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5547 rel
->r_offset
) != (bfd_vma
) -1)
5550 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5553 (long) rel
->r_offset
,
5555 h
->root
.root
.string
);
5560 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5561 contents
, rel
->r_offset
,
5562 relocation
, rel
->r_addend
);
5564 check_relocation_error
:
5565 if (r
!= bfd_reloc_ok
)
5570 name
= h
->root
.root
.string
;
5573 name
= bfd_elf_string_from_elf_section (input_bfd
,
5574 symtab_hdr
->sh_link
,
5579 name
= bfd_section_name (input_bfd
, sec
);
5582 if (r
== bfd_reloc_overflow
)
5583 (*info
->callbacks
->reloc_overflow
)
5584 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5585 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
5589 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5590 input_bfd
, input_section
,
5591 (long) rel
->r_offset
, name
, (int) r
);
5602 Elf_Internal_Shdr
*rel_hdr
;
5603 size_t deleted
= rel
- wrel
;
5605 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
5606 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5607 if (rel_hdr
->sh_size
== 0)
5609 /* It is too late to remove an empty reloc section. Leave
5611 ??? What is wrong with an empty section??? */
5612 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
5615 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5616 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5617 input_section
->reloc_count
-= deleted
;
5623 /* Finish up dynamic symbol handling. We set the contents of various
5624 dynamic sections here. */
5627 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
5628 struct bfd_link_info
*info
,
5629 struct elf_link_hash_entry
*h
,
5630 Elf_Internal_Sym
*sym
)
5632 struct elf_x86_64_link_hash_table
*htab
;
5633 const struct elf_x86_64_backend_data
*abed
;
5634 bfd_boolean use_plt_bnd
;
5635 struct elf_x86_64_link_hash_entry
*eh
;
5636 bfd_boolean local_undefweak
;
5638 htab
= elf_x86_64_hash_table (info
);
5642 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5643 section only if there is .plt section. */
5644 use_plt_bnd
= htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
;
5646 ? &elf_x86_64_bnd_arch_bed
5647 : get_elf_x86_64_backend_data (output_bfd
));
5649 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
5651 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5652 resolved undefined weak symbols in executable so that their
5653 references have value 0 at run-time. */
5654 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
5658 if (h
->plt
.offset
!= (bfd_vma
) -1)
5661 bfd_vma got_offset
, plt_offset
, plt_plt_offset
, plt_got_offset
;
5662 bfd_vma plt_plt_insn_end
, plt_got_insn_size
;
5663 Elf_Internal_Rela rela
;
5665 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
5666 const struct elf_backend_data
*bed
;
5667 bfd_vma plt_got_pcrel_offset
;
5669 /* When building a static executable, use .iplt, .igot.plt and
5670 .rela.iplt sections for STT_GNU_IFUNC symbols. */
5671 if (htab
->elf
.splt
!= NULL
)
5673 plt
= htab
->elf
.splt
;
5674 gotplt
= htab
->elf
.sgotplt
;
5675 relplt
= htab
->elf
.srelplt
;
5679 plt
= htab
->elf
.iplt
;
5680 gotplt
= htab
->elf
.igotplt
;
5681 relplt
= htab
->elf
.irelplt
;
5684 /* This symbol has an entry in the procedure linkage table. Set
5686 if ((h
->dynindx
== -1
5688 && !((h
->forced_local
|| bfd_link_executable (info
))
5690 && h
->type
== STT_GNU_IFUNC
))
5696 /* Get the index in the procedure linkage table which
5697 corresponds to this symbol. This is the index of this symbol
5698 in all the symbols for which we are making plt entries. The
5699 first entry in the procedure linkage table is reserved.
5701 Get the offset into the .got table of the entry that
5702 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
5703 bytes. The first three are reserved for the dynamic linker.
5705 For static executables, we don't reserve anything. */
5707 if (plt
== htab
->elf
.splt
)
5709 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
5710 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
5714 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
5715 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
5718 plt_plt_insn_end
= abed
->plt_plt_insn_end
;
5719 plt_plt_offset
= abed
->plt_plt_offset
;
5720 plt_got_insn_size
= abed
->plt_got_insn_size
;
5721 plt_got_offset
= abed
->plt_got_offset
;
5724 /* Use the second PLT with BND relocations. */
5725 const bfd_byte
*plt_entry
, *plt2_entry
;
5727 if (eh
->has_bnd_reloc
)
5729 plt_entry
= elf_x86_64_bnd_plt_entry
;
5730 plt2_entry
= elf_x86_64_bnd_plt2_entry
;
5734 plt_entry
= elf_x86_64_legacy_plt_entry
;
5735 plt2_entry
= elf_x86_64_legacy_plt2_entry
;
5737 /* Subtract 1 since there is no BND prefix. */
5738 plt_plt_insn_end
-= 1;
5739 plt_plt_offset
-= 1;
5740 plt_got_insn_size
-= 1;
5741 plt_got_offset
-= 1;
5744 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry
)
5745 == sizeof (elf_x86_64_legacy_plt_entry
));
5747 /* Fill in the entry in the procedure linkage table. */
5748 memcpy (plt
->contents
+ h
->plt
.offset
,
5749 plt_entry
, sizeof (elf_x86_64_legacy_plt_entry
));
5750 /* Fill in the entry in the second PLT. */
5751 memcpy (htab
->plt_bnd
->contents
+ eh
->plt_bnd
.offset
,
5752 plt2_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5754 resolved_plt
= htab
->plt_bnd
;
5755 plt_offset
= eh
->plt_bnd
.offset
;
5759 /* Fill in the entry in the procedure linkage table. */
5760 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
5761 abed
->plt_entry_size
);
5764 plt_offset
= h
->plt
.offset
;
5767 /* Insert the relocation positions of the plt section. */
5769 /* Put offset the PC-relative instruction referring to the GOT entry,
5770 subtracting the size of that instruction. */
5771 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
5772 + gotplt
->output_offset
5774 - resolved_plt
->output_section
->vma
5775 - resolved_plt
->output_offset
5777 - plt_got_insn_size
);
5779 /* Check PC-relative offset overflow in PLT entry. */
5780 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
5781 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5782 output_bfd
, h
->root
.root
.string
);
5784 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
5785 resolved_plt
->contents
+ plt_offset
+ plt_got_offset
);
5787 /* Fill in the entry in the global offset table, initially this
5788 points to the second part of the PLT entry. Leave the entry
5789 as zero for undefined weak symbol in PIE. No PLT relocation
5790 against undefined weak symbol in PIE. */
5791 if (!local_undefweak
)
5793 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5794 + plt
->output_offset
5796 + abed
->plt_lazy_offset
),
5797 gotplt
->contents
+ got_offset
);
5799 /* Fill in the entry in the .rela.plt section. */
5800 rela
.r_offset
= (gotplt
->output_section
->vma
5801 + gotplt
->output_offset
5803 if (h
->dynindx
== -1
5804 || ((bfd_link_executable (info
)
5805 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5807 && h
->type
== STT_GNU_IFUNC
))
5809 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5810 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
5811 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
5812 rela
.r_addend
= (h
->root
.u
.def
.value
5813 + h
->root
.u
.def
.section
->output_section
->vma
5814 + h
->root
.u
.def
.section
->output_offset
);
5815 /* R_X86_64_IRELATIVE comes last. */
5816 plt_index
= htab
->next_irelative_index
--;
5820 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
5822 plt_index
= htab
->next_jump_slot_index
++;
5825 /* Don't fill PLT entry for static executables. */
5826 if (plt
== htab
->elf
.splt
)
5828 bfd_vma plt0_offset
= h
->plt
.offset
+ plt_plt_insn_end
;
5830 /* Put relocation index. */
5831 bfd_put_32 (output_bfd
, plt_index
,
5832 (plt
->contents
+ h
->plt
.offset
5833 + abed
->plt_reloc_offset
));
5835 /* Put offset for jmp .PLT0 and check for overflow. We don't
5836 check relocation index for overflow since branch displacement
5837 will overflow first. */
5838 if (plt0_offset
> 0x80000000)
5839 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5840 output_bfd
, h
->root
.root
.string
);
5841 bfd_put_32 (output_bfd
, - plt0_offset
,
5842 plt
->contents
+ h
->plt
.offset
+ plt_plt_offset
);
5845 bed
= get_elf_backend_data (output_bfd
);
5846 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
5847 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
5850 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5852 bfd_vma got_offset
, plt_offset
, plt_got_offset
, plt_got_insn_size
;
5853 asection
*plt
, *got
;
5854 bfd_boolean got_after_plt
;
5855 int32_t got_pcrel_offset
;
5856 const bfd_byte
*got_plt_entry
;
5858 /* Set the entry in the GOT procedure linkage table. */
5859 plt
= htab
->plt_got
;
5860 got
= htab
->elf
.sgot
;
5861 got_offset
= h
->got
.offset
;
5863 if (got_offset
== (bfd_vma
) -1
5864 || h
->type
== STT_GNU_IFUNC
5869 /* Use the second PLT entry template for the GOT PLT since they
5870 are the identical. */
5871 plt_got_insn_size
= elf_x86_64_bnd_arch_bed
.plt_got_insn_size
;
5872 plt_got_offset
= elf_x86_64_bnd_arch_bed
.plt_got_offset
;
5873 if (eh
->has_bnd_reloc
)
5874 got_plt_entry
= elf_x86_64_bnd_plt2_entry
;
5877 got_plt_entry
= elf_x86_64_legacy_plt2_entry
;
5879 /* Subtract 1 since there is no BND prefix. */
5880 plt_got_insn_size
-= 1;
5881 plt_got_offset
-= 1;
5884 /* Fill in the entry in the GOT procedure linkage table. */
5885 plt_offset
= eh
->plt_got
.offset
;
5886 memcpy (plt
->contents
+ plt_offset
,
5887 got_plt_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5889 /* Put offset the PC-relative instruction referring to the GOT
5890 entry, subtracting the size of that instruction. */
5891 got_pcrel_offset
= (got
->output_section
->vma
5892 + got
->output_offset
5894 - plt
->output_section
->vma
5895 - plt
->output_offset
5897 - plt_got_insn_size
);
5899 /* Check PC-relative offset overflow in GOT PLT entry. */
5900 got_after_plt
= got
->output_section
->vma
> plt
->output_section
->vma
;
5901 if ((got_after_plt
&& got_pcrel_offset
< 0)
5902 || (!got_after_plt
&& got_pcrel_offset
> 0))
5903 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
5904 output_bfd
, h
->root
.root
.string
);
5906 bfd_put_32 (output_bfd
, got_pcrel_offset
,
5907 plt
->contents
+ plt_offset
+ plt_got_offset
);
5910 if (!local_undefweak
5912 && (h
->plt
.offset
!= (bfd_vma
) -1
5913 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5915 /* Mark the symbol as undefined, rather than as defined in
5916 the .plt section. Leave the value if there were any
5917 relocations where pointer equality matters (this is a clue
5918 for the dynamic linker, to make function pointer
5919 comparisons work between an application and shared
5920 library), otherwise set it to zero. If a function is only
5921 called from a binary, there is no need to slow down
5922 shared libraries because of that. */
5923 sym
->st_shndx
= SHN_UNDEF
;
5924 if (!h
->pointer_equality_needed
)
5928 /* Don't generate dynamic GOT relocation against undefined weak
5929 symbol in executable. */
5930 if (h
->got
.offset
!= (bfd_vma
) -1
5931 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
5932 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
5933 && !local_undefweak
)
5935 Elf_Internal_Rela rela
;
5936 asection
*relgot
= htab
->elf
.srelgot
;
5938 /* This symbol has an entry in the global offset table. Set it
5940 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5943 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5944 + htab
->elf
.sgot
->output_offset
5945 + (h
->got
.offset
&~ (bfd_vma
) 1));
5947 /* If this is a static link, or it is a -Bsymbolic link and the
5948 symbol is defined locally or was forced to be local because
5949 of a version file, we just want to emit a RELATIVE reloc.
5950 The entry in the global offset table will already have been
5951 initialized in the relocate_section function. */
5953 && h
->type
== STT_GNU_IFUNC
)
5955 if (h
->plt
.offset
== (bfd_vma
) -1)
5957 /* STT_GNU_IFUNC is referenced without PLT. */
5958 if (htab
->elf
.splt
== NULL
)
5960 /* use .rel[a].iplt section to store .got relocations
5961 in static executable. */
5962 relgot
= htab
->elf
.irelplt
;
5964 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
5966 rela
.r_info
= htab
->r_info (0,
5967 R_X86_64_IRELATIVE
);
5968 rela
.r_addend
= (h
->root
.u
.def
.value
5969 + h
->root
.u
.def
.section
->output_section
->vma
5970 + h
->root
.u
.def
.section
->output_offset
);
5975 else if (bfd_link_pic (info
))
5977 /* Generate R_X86_64_GLOB_DAT. */
5984 if (!h
->pointer_equality_needed
)
5987 /* For non-shared object, we can't use .got.plt, which
5988 contains the real function addres if we need pointer
5989 equality. We load the GOT entry with the PLT entry. */
5990 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5991 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5992 + plt
->output_offset
5994 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5998 else if (bfd_link_pic (info
)
5999 && SYMBOL_REFERENCES_LOCAL (info
, h
))
6001 if (!h
->def_regular
)
6003 BFD_ASSERT((h
->got
.offset
& 1) != 0);
6004 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
6005 rela
.r_addend
= (h
->root
.u
.def
.value
6006 + h
->root
.u
.def
.section
->output_section
->vma
6007 + h
->root
.u
.def
.section
->output_offset
);
6011 BFD_ASSERT((h
->got
.offset
& 1) == 0);
6013 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6014 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
6015 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
6019 elf_append_rela (output_bfd
, relgot
, &rela
);
6024 Elf_Internal_Rela rela
;
6026 /* This symbol needs a copy reloc. Set it up. */
6028 if (h
->dynindx
== -1
6029 || (h
->root
.type
!= bfd_link_hash_defined
6030 && h
->root
.type
!= bfd_link_hash_defweak
)
6031 || htab
->srelbss
== NULL
)
6034 rela
.r_offset
= (h
->root
.u
.def
.value
6035 + h
->root
.u
.def
.section
->output_section
->vma
6036 + h
->root
.u
.def
.section
->output_offset
);
6037 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
6039 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
6045 /* Finish up local dynamic symbol handling. We set the contents of
6046 various dynamic sections here. */
6049 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
6051 struct elf_link_hash_entry
*h
6052 = (struct elf_link_hash_entry
*) *slot
;
6053 struct bfd_link_info
*info
6054 = (struct bfd_link_info
*) inf
;
6056 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
6060 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
6061 here since undefined weak symbol may not be dynamic and may not be
6062 called for elf_x86_64_finish_dynamic_symbol. */
6065 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
6068 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
6069 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
6071 if (h
->root
.type
!= bfd_link_hash_undefweak
6072 || h
->dynindx
!= -1)
6075 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
6079 /* Used to decide how to sort relocs in an optimal manner for the
6080 dynamic linker, before writing them out. */
6082 static enum elf_reloc_type_class
6083 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info
,
6084 const asection
*rel_sec ATTRIBUTE_UNUSED
,
6085 const Elf_Internal_Rela
*rela
)
6087 bfd
*abfd
= info
->output_bfd
;
6088 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6089 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
6091 if (htab
->elf
.dynsym
!= NULL
6092 && htab
->elf
.dynsym
->contents
!= NULL
)
6094 /* Check relocation against STT_GNU_IFUNC symbol if there are
6096 unsigned long r_symndx
= htab
->r_sym (rela
->r_info
);
6097 if (r_symndx
!= STN_UNDEF
)
6099 Elf_Internal_Sym sym
;
6100 if (!bed
->s
->swap_symbol_in (abfd
,
6101 (htab
->elf
.dynsym
->contents
6102 + r_symndx
* bed
->s
->sizeof_sym
),
6106 if (ELF_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
6107 return reloc_class_ifunc
;
6111 switch ((int) ELF32_R_TYPE (rela
->r_info
))
6113 case R_X86_64_IRELATIVE
:
6114 return reloc_class_ifunc
;
6115 case R_X86_64_RELATIVE
:
6116 case R_X86_64_RELATIVE64
:
6117 return reloc_class_relative
;
6118 case R_X86_64_JUMP_SLOT
:
6119 return reloc_class_plt
;
6121 return reloc_class_copy
;
6123 return reloc_class_normal
;
6127 /* Finish up the dynamic sections. */
6130 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
6131 struct bfd_link_info
*info
)
6133 struct elf_x86_64_link_hash_table
*htab
;
6136 const struct elf_x86_64_backend_data
*abed
;
6138 htab
= elf_x86_64_hash_table (info
);
6142 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
6143 section only if there is .plt section. */
6144 abed
= (htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
6145 ? &elf_x86_64_bnd_arch_bed
6146 : get_elf_x86_64_backend_data (output_bfd
));
6148 dynobj
= htab
->elf
.dynobj
;
6149 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
6151 if (htab
->elf
.dynamic_sections_created
)
6153 bfd_byte
*dyncon
, *dynconend
;
6154 const struct elf_backend_data
*bed
;
6155 bfd_size_type sizeof_dyn
;
6157 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
6160 bed
= get_elf_backend_data (dynobj
);
6161 sizeof_dyn
= bed
->s
->sizeof_dyn
;
6162 dyncon
= sdyn
->contents
;
6163 dynconend
= sdyn
->contents
+ sdyn
->size
;
6164 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
6166 Elf_Internal_Dyn dyn
;
6169 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
6177 s
= htab
->elf
.sgotplt
;
6178 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
6182 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
6186 s
= htab
->elf
.srelplt
->output_section
;
6187 dyn
.d_un
.d_val
= s
->size
;
6191 /* The procedure linkage table relocs (DT_JMPREL) should
6192 not be included in the overall relocs (DT_RELA).
6193 Therefore, we override the DT_RELASZ entry here to
6194 make it not include the JMPREL relocs. Since the
6195 linker script arranges for .rela.plt to follow all
6196 other relocation sections, we don't have to worry
6197 about changing the DT_RELA entry. */
6198 if (htab
->elf
.srelplt
!= NULL
)
6200 s
= htab
->elf
.srelplt
->output_section
;
6201 dyn
.d_un
.d_val
-= s
->size
;
6205 case DT_TLSDESC_PLT
:
6207 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6208 + htab
->tlsdesc_plt
;
6211 case DT_TLSDESC_GOT
:
6213 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6214 + htab
->tlsdesc_got
;
6218 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
6221 /* Fill in the special first entry in the procedure linkage table. */
6222 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
6224 /* Fill in the first entry in the procedure linkage table. */
6225 memcpy (htab
->elf
.splt
->contents
,
6226 abed
->plt0_entry
, abed
->plt_entry_size
);
6227 /* Add offset for pushq GOT+8(%rip), since the instruction
6228 uses 6 bytes subtract this value. */
6229 bfd_put_32 (output_bfd
,
6230 (htab
->elf
.sgotplt
->output_section
->vma
6231 + htab
->elf
.sgotplt
->output_offset
6233 - htab
->elf
.splt
->output_section
->vma
6234 - htab
->elf
.splt
->output_offset
6236 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
6237 /* Add offset for the PC-relative instruction accessing GOT+16,
6238 subtracting the offset to the end of that instruction. */
6239 bfd_put_32 (output_bfd
,
6240 (htab
->elf
.sgotplt
->output_section
->vma
6241 + htab
->elf
.sgotplt
->output_offset
6243 - htab
->elf
.splt
->output_section
->vma
6244 - htab
->elf
.splt
->output_offset
6245 - abed
->plt0_got2_insn_end
),
6246 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
6248 elf_section_data (htab
->elf
.splt
->output_section
)
6249 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
6251 if (htab
->tlsdesc_plt
)
6253 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6254 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
6256 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
6257 abed
->plt0_entry
, abed
->plt_entry_size
);
6259 /* Add offset for pushq GOT+8(%rip), since the
6260 instruction uses 6 bytes subtract this value. */
6261 bfd_put_32 (output_bfd
,
6262 (htab
->elf
.sgotplt
->output_section
->vma
6263 + htab
->elf
.sgotplt
->output_offset
6265 - htab
->elf
.splt
->output_section
->vma
6266 - htab
->elf
.splt
->output_offset
6269 htab
->elf
.splt
->contents
6270 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
6271 /* Add offset for the PC-relative instruction accessing GOT+TDG,
6272 where TGD stands for htab->tlsdesc_got, subtracting the offset
6273 to the end of that instruction. */
6274 bfd_put_32 (output_bfd
,
6275 (htab
->elf
.sgot
->output_section
->vma
6276 + htab
->elf
.sgot
->output_offset
6278 - htab
->elf
.splt
->output_section
->vma
6279 - htab
->elf
.splt
->output_offset
6281 - abed
->plt0_got2_insn_end
),
6282 htab
->elf
.splt
->contents
6283 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
6288 if (htab
->plt_bnd
!= NULL
)
6289 elf_section_data (htab
->plt_bnd
->output_section
)
6290 ->this_hdr
.sh_entsize
= sizeof (elf_x86_64_bnd_plt2_entry
);
6292 if (htab
->elf
.sgotplt
)
6294 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
6297 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
6301 /* Fill in the first three entries in the global offset table. */
6302 if (htab
->elf
.sgotplt
->size
> 0)
6304 /* Set the first entry in the global offset table to the address of
6305 the dynamic section. */
6307 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
6309 bfd_put_64 (output_bfd
,
6310 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
6311 htab
->elf
.sgotplt
->contents
);
6312 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
6313 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
6314 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
6317 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
6321 /* Adjust .eh_frame for .plt section. */
6322 if (htab
->plt_eh_frame
!= NULL
6323 && htab
->plt_eh_frame
->contents
!= NULL
)
6325 if (htab
->elf
.splt
!= NULL
6326 && htab
->elf
.splt
->size
!= 0
6327 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
6328 && htab
->elf
.splt
->output_section
!= NULL
6329 && htab
->plt_eh_frame
->output_section
!= NULL
)
6331 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
6332 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
6333 + htab
->plt_eh_frame
->output_offset
6334 + PLT_FDE_START_OFFSET
;
6335 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6336 htab
->plt_eh_frame
->contents
6337 + PLT_FDE_START_OFFSET
);
6339 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
6341 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6343 htab
->plt_eh_frame
->contents
))
6348 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
6349 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
6352 /* Fill PLT entries for undefined weak symbols in PIE. */
6353 if (bfd_link_pie (info
))
6354 bfd_hash_traverse (&info
->hash
->table
,
6355 elf_x86_64_pie_finish_undefweak_symbol
,
6361 /* Fill PLT/GOT entries and allocate dynamic relocations for local
6362 STT_GNU_IFUNC symbols, which aren't in the ELF linker hash table.
6363 It has to be done before elf_link_sort_relocs is called so that
6364 dynamic relocations are properly sorted. */
6367 elf_x86_64_output_arch_local_syms
6368 (bfd
*output_bfd ATTRIBUTE_UNUSED
,
6369 struct bfd_link_info
*info
,
6370 void *flaginfo ATTRIBUTE_UNUSED
,
6371 int (*func
) (void *, const char *,
6374 struct elf_link_hash_entry
*) ATTRIBUTE_UNUSED
)
6376 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
6380 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
6381 htab_traverse (htab
->loc_hash_table
,
6382 elf_x86_64_finish_local_dynamic_symbol
,
6388 /* Return an array of PLT entry symbol values. */
6391 elf_x86_64_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
6394 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
6397 bfd_vma
*plt_sym_val
;
6399 bfd_byte
*plt_contents
;
6400 const struct elf_x86_64_backend_data
*bed
;
6401 Elf_Internal_Shdr
*hdr
;
6404 /* Get the .plt section contents. PLT passed down may point to the
6405 .plt.bnd section. Make sure that PLT always points to the .plt
6407 plt_bnd
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6412 plt
= bfd_get_section_by_name (abfd
, ".plt");
6415 bed
= &elf_x86_64_bnd_arch_bed
;
6418 bed
= get_elf_x86_64_backend_data (abfd
);
6420 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
6421 if (plt_contents
== NULL
)
6423 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
6424 plt_contents
, 0, plt
->size
))
6427 free (plt_contents
);
6431 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
6432 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
6435 hdr
= &elf_section_data (relplt
)->this_hdr
;
6436 count
= relplt
->size
/ hdr
->sh_entsize
;
6438 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
6439 if (plt_sym_val
== NULL
)
6442 for (i
= 0; i
< count
; i
++)
6443 plt_sym_val
[i
] = -1;
6445 plt_offset
= bed
->plt_entry_size
;
6446 p
= relplt
->relocation
;
6447 for (i
= 0; i
< count
; i
++, p
++)
6451 /* Skip unknown relocation. */
6452 if (p
->howto
== NULL
)
6455 if (p
->howto
->type
!= R_X86_64_JUMP_SLOT
6456 && p
->howto
->type
!= R_X86_64_IRELATIVE
)
6459 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
6460 + bed
->plt_reloc_offset
));
6461 if (reloc_index
< count
)
6465 /* This is the index in .plt section. */
6466 long plt_index
= plt_offset
/ bed
->plt_entry_size
;
6467 /* Store VMA + the offset in .plt.bnd section. */
6468 plt_sym_val
[reloc_index
] =
6470 + (plt_index
- 1) * sizeof (elf_x86_64_legacy_plt2_entry
));
6473 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
6475 plt_offset
+= bed
->plt_entry_size
;
6477 /* PR binutils/18437: Skip extra relocations in the .rela.plt
6479 if (plt_offset
>= plt
->size
)
6483 free (plt_contents
);
6488 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
6492 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
6499 /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
6500 as PLT if it exists. */
6501 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6503 plt
= bfd_get_section_by_name (abfd
, ".plt");
6504 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
6505 dynsymcount
, dynsyms
, ret
,
6507 elf_x86_64_get_plt_sym_val
);
6510 /* Handle an x86-64 specific section when reading an object file. This
6511 is called when elfcode.h finds a section with an unknown type. */
6514 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
6515 const char *name
, int shindex
)
6517 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
6520 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
6526 /* Hook called by the linker routine which adds symbols from an object
6527 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
6531 elf_x86_64_add_symbol_hook (bfd
*abfd
,
6532 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6533 Elf_Internal_Sym
*sym
,
6534 const char **namep ATTRIBUTE_UNUSED
,
6535 flagword
*flagsp ATTRIBUTE_UNUSED
,
6541 switch (sym
->st_shndx
)
6543 case SHN_X86_64_LCOMMON
:
6544 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
6547 lcomm
= bfd_make_section_with_flags (abfd
,
6551 | SEC_LINKER_CREATED
));
6554 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
6557 *valp
= sym
->st_size
;
6565 /* Given a BFD section, try to locate the corresponding ELF section
6569 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
6570 asection
*sec
, int *index_return
)
6572 if (sec
== &_bfd_elf_large_com_section
)
6574 *index_return
= SHN_X86_64_LCOMMON
;
6580 /* Process a symbol. */
6583 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
6586 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
6588 switch (elfsym
->internal_elf_sym
.st_shndx
)
6590 case SHN_X86_64_LCOMMON
:
6591 asym
->section
= &_bfd_elf_large_com_section
;
6592 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
6593 /* Common symbol doesn't set BSF_GLOBAL. */
6594 asym
->flags
&= ~BSF_GLOBAL
;
6600 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
6602 return (sym
->st_shndx
== SHN_COMMON
6603 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
6607 elf_x86_64_common_section_index (asection
*sec
)
6609 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6612 return SHN_X86_64_LCOMMON
;
6616 elf_x86_64_common_section (asection
*sec
)
6618 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6619 return bfd_com_section_ptr
;
6621 return &_bfd_elf_large_com_section
;
6625 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
6626 const Elf_Internal_Sym
*sym
,
6631 const asection
*oldsec
)
6633 /* A normal common symbol and a large common symbol result in a
6634 normal common symbol. We turn the large common symbol into a
6637 && h
->root
.type
== bfd_link_hash_common
6639 && bfd_is_com_section (*psec
)
6642 if (sym
->st_shndx
== SHN_COMMON
6643 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
6645 h
->root
.u
.c
.p
->section
6646 = bfd_make_section_old_way (oldbfd
, "COMMON");
6647 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
6649 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
6650 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
6651 *psec
= bfd_com_section_ptr
;
6658 elf_x86_64_additional_program_headers (bfd
*abfd
,
6659 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6664 /* Check to see if we need a large readonly segment. */
6665 s
= bfd_get_section_by_name (abfd
, ".lrodata");
6666 if (s
&& (s
->flags
& SEC_LOAD
))
6669 /* Check to see if we need a large data segment. Since .lbss sections
6670 is placed right after the .bss section, there should be no need for
6671 a large data segment just because of .lbss. */
6672 s
= bfd_get_section_by_name (abfd
, ".ldata");
6673 if (s
&& (s
->flags
& SEC_LOAD
))
6679 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6682 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
6684 if (h
->plt
.offset
!= (bfd_vma
) -1
6686 && !h
->pointer_equality_needed
)
6689 return _bfd_elf_hash_symbol (h
);
6692 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
6695 elf_x86_64_relocs_compatible (const bfd_target
*input
,
6696 const bfd_target
*output
)
6698 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
6699 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
6700 && _bfd_elf_relocs_compatible (input
, output
));
6703 static const struct bfd_elf_special_section
6704 elf_x86_64_special_sections
[]=
6706 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6707 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6708 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
6709 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6710 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6711 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6712 { NULL
, 0, 0, 0, 0 }
6715 #define TARGET_LITTLE_SYM x86_64_elf64_vec
6716 #define TARGET_LITTLE_NAME "elf64-x86-64"
6717 #define ELF_ARCH bfd_arch_i386
6718 #define ELF_TARGET_ID X86_64_ELF_DATA
6719 #define ELF_MACHINE_CODE EM_X86_64
6720 #define ELF_MAXPAGESIZE 0x200000
6721 #define ELF_MINPAGESIZE 0x1000
6722 #define ELF_COMMONPAGESIZE 0x1000
6724 #define elf_backend_can_gc_sections 1
6725 #define elf_backend_can_refcount 1
6726 #define elf_backend_want_got_plt 1
6727 #define elf_backend_plt_readonly 1
6728 #define elf_backend_want_plt_sym 0
6729 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
6730 #define elf_backend_rela_normal 1
6731 #define elf_backend_plt_alignment 4
6732 #define elf_backend_extern_protected_data 1
6733 #define elf_backend_caches_rawsize 1
6735 #define elf_info_to_howto elf_x86_64_info_to_howto
6737 #define bfd_elf64_bfd_link_hash_table_create \
6738 elf_x86_64_link_hash_table_create
6739 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
6740 #define bfd_elf64_bfd_reloc_name_lookup \
6741 elf_x86_64_reloc_name_lookup
6743 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
6744 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
6745 #define elf_backend_check_relocs elf_x86_64_check_relocs
6746 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
6747 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
6748 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
6749 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
6750 #define elf_backend_output_arch_local_syms elf_x86_64_output_arch_local_syms
6751 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
6752 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
6753 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
6755 #define elf_backend_write_core_note elf_x86_64_write_core_note
6757 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
6758 #define elf_backend_relocate_section elf_x86_64_relocate_section
6759 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
6760 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
6761 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
6762 #define elf_backend_object_p elf64_x86_64_elf_object_p
6763 #define bfd_elf64_mkobject elf_x86_64_mkobject
6764 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
6766 #define elf_backend_section_from_shdr \
6767 elf_x86_64_section_from_shdr
6769 #define elf_backend_section_from_bfd_section \
6770 elf_x86_64_elf_section_from_bfd_section
6771 #define elf_backend_add_symbol_hook \
6772 elf_x86_64_add_symbol_hook
6773 #define elf_backend_symbol_processing \
6774 elf_x86_64_symbol_processing
6775 #define elf_backend_common_section_index \
6776 elf_x86_64_common_section_index
6777 #define elf_backend_common_section \
6778 elf_x86_64_common_section
6779 #define elf_backend_common_definition \
6780 elf_x86_64_common_definition
6781 #define elf_backend_merge_symbol \
6782 elf_x86_64_merge_symbol
6783 #define elf_backend_special_sections \
6784 elf_x86_64_special_sections
6785 #define elf_backend_additional_program_headers \
6786 elf_x86_64_additional_program_headers
6787 #define elf_backend_hash_symbol \
6788 elf_x86_64_hash_symbol
6789 #define elf_backend_omit_section_dynsym \
6790 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6791 #define elf_backend_fixup_symbol \
6792 elf_x86_64_fixup_symbol
6794 #include "elf64-target.h"
6796 /* CloudABI support. */
6798 #undef TARGET_LITTLE_SYM
6799 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
6800 #undef TARGET_LITTLE_NAME
6801 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
6804 #define ELF_OSABI ELFOSABI_CLOUDABI
6807 #define elf64_bed elf64_x86_64_cloudabi_bed
6809 #include "elf64-target.h"
6811 /* FreeBSD support. */
6813 #undef TARGET_LITTLE_SYM
6814 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
6815 #undef TARGET_LITTLE_NAME
6816 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
6819 #define ELF_OSABI ELFOSABI_FREEBSD
6822 #define elf64_bed elf64_x86_64_fbsd_bed
6824 #include "elf64-target.h"
6826 /* Solaris 2 support. */
6828 #undef TARGET_LITTLE_SYM
6829 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
6830 #undef TARGET_LITTLE_NAME
6831 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
6833 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6834 objects won't be recognized. */
6838 #define elf64_bed elf64_x86_64_sol2_bed
6840 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
6842 #undef elf_backend_static_tls_alignment
6843 #define elf_backend_static_tls_alignment 16
6845 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6847 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6849 #undef elf_backend_want_plt_sym
6850 #define elf_backend_want_plt_sym 1
6852 #undef elf_backend_strtab_flags
6853 #define elf_backend_strtab_flags SHF_STRINGS
6856 elf64_x86_64_copy_solaris_special_section_fields (const bfd
*ibfd ATTRIBUTE_UNUSED
,
6857 bfd
*obfd ATTRIBUTE_UNUSED
,
6858 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
6859 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
6861 /* PR 19938: FIXME: Need to add code for setting the sh_info
6862 and sh_link fields of Solaris specific section types. */
6866 #undef elf_backend_copy_special_section_fields
6867 #define elf_backend_copy_special_section_fields elf64_x86_64_copy_solaris_special_section_fields
6869 #include "elf64-target.h"
6871 /* Native Client support. */
6874 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
6876 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
6877 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
6881 #undef TARGET_LITTLE_SYM
6882 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
6883 #undef TARGET_LITTLE_NAME
6884 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
6886 #define elf64_bed elf64_x86_64_nacl_bed
6888 #undef ELF_MAXPAGESIZE
6889 #undef ELF_MINPAGESIZE
6890 #undef ELF_COMMONPAGESIZE
6891 #define ELF_MAXPAGESIZE 0x10000
6892 #define ELF_MINPAGESIZE 0x10000
6893 #define ELF_COMMONPAGESIZE 0x10000
6895 /* Restore defaults. */
6897 #undef elf_backend_static_tls_alignment
6898 #undef elf_backend_want_plt_sym
6899 #define elf_backend_want_plt_sym 0
6900 #undef elf_backend_strtab_flags
6901 #undef elf_backend_copy_special_section_fields
6903 /* NaCl uses substantially different PLT entries for the same effects. */
6905 #undef elf_backend_plt_alignment
6906 #define elf_backend_plt_alignment 5
6907 #define NACL_PLT_ENTRY_SIZE 64
6908 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6910 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
6912 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
6913 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
6914 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6915 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6916 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6918 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
6919 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
6921 /* 32 bytes of nop to pad out to the standard size. */
6922 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6923 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6924 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6925 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6926 0x66, /* excess data16 prefix */
6930 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6932 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
6933 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6934 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6935 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6937 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
6938 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6939 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6941 /* Lazy GOT entries point here (32-byte aligned). */
6942 0x68, /* pushq immediate */
6943 0, 0, 0, 0, /* replaced with index into relocation table. */
6944 0xe9, /* jmp relative */
6945 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
6947 /* 22 bytes of nop to pad out to the standard size. */
6948 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6949 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6950 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
6953 /* .eh_frame covering the .plt section. */
6955 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
6957 #if (PLT_CIE_LENGTH != 20 \
6958 || PLT_FDE_LENGTH != 36 \
6959 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6960 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6961 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
6963 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6964 0, 0, 0, 0, /* CIE ID */
6965 1, /* CIE version */
6966 'z', 'R', 0, /* Augmentation string */
6967 1, /* Code alignment factor */
6968 0x78, /* Data alignment factor */
6969 16, /* Return address column */
6970 1, /* Augmentation size */
6971 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6972 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
6973 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
6974 DW_CFA_nop
, DW_CFA_nop
,
6976 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6977 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
6978 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
6979 0, 0, 0, 0, /* .plt size goes here */
6980 0, /* Augmentation size */
6981 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
6982 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6983 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
6984 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6985 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6986 13, /* Block length */
6987 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
6988 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
6989 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6990 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
6991 DW_CFA_nop
, DW_CFA_nop
6994 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
6996 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
6997 elf_x86_64_nacl_plt_entry
, /* plt_entry */
6998 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6999 2, /* plt0_got1_offset */
7000 9, /* plt0_got2_offset */
7001 13, /* plt0_got2_insn_end */
7002 3, /* plt_got_offset */
7003 33, /* plt_reloc_offset */
7004 38, /* plt_plt_offset */
7005 7, /* plt_got_insn_size */
7006 42, /* plt_plt_insn_end */
7007 32, /* plt_lazy_offset */
7008 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
7009 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
7012 #undef elf_backend_arch_data
7013 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
7015 #undef elf_backend_object_p
7016 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
7017 #undef elf_backend_modify_segment_map
7018 #define elf_backend_modify_segment_map nacl_modify_segment_map
7019 #undef elf_backend_modify_program_headers
7020 #define elf_backend_modify_program_headers nacl_modify_program_headers
7021 #undef elf_backend_final_write_processing
7022 #define elf_backend_final_write_processing nacl_final_write_processing
7024 #include "elf64-target.h"
7026 /* Native Client x32 support. */
7029 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
7031 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
7032 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
7036 #undef TARGET_LITTLE_SYM
7037 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
7038 #undef TARGET_LITTLE_NAME
7039 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
7041 #define elf32_bed elf32_x86_64_nacl_bed
7043 #define bfd_elf32_bfd_link_hash_table_create \
7044 elf_x86_64_link_hash_table_create
7045 #define bfd_elf32_bfd_reloc_type_lookup \
7046 elf_x86_64_reloc_type_lookup
7047 #define bfd_elf32_bfd_reloc_name_lookup \
7048 elf_x86_64_reloc_name_lookup
7049 #define bfd_elf32_mkobject \
7051 #define bfd_elf32_get_synthetic_symtab \
7052 elf_x86_64_get_synthetic_symtab
7054 #undef elf_backend_object_p
7055 #define elf_backend_object_p \
7056 elf32_x86_64_nacl_elf_object_p
7058 #undef elf_backend_bfd_from_remote_memory
7059 #define elf_backend_bfd_from_remote_memory \
7060 _bfd_elf32_bfd_from_remote_memory
7062 #undef elf_backend_size_info
7063 #define elf_backend_size_info \
7064 _bfd_elf32_size_info
7066 #include "elf32-target.h"
7068 /* Restore defaults. */
7069 #undef elf_backend_object_p
7070 #define elf_backend_object_p elf64_x86_64_elf_object_p
7071 #undef elf_backend_bfd_from_remote_memory
7072 #undef elf_backend_size_info
7073 #undef elf_backend_modify_segment_map
7074 #undef elf_backend_modify_program_headers
7075 #undef elf_backend_final_write_processing
7077 /* Intel L1OM support. */
7080 elf64_l1om_elf_object_p (bfd
*abfd
)
7082 /* Set the right machine number for an L1OM elf64 file. */
7083 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
7087 #undef TARGET_LITTLE_SYM
7088 #define TARGET_LITTLE_SYM l1om_elf64_vec
7089 #undef TARGET_LITTLE_NAME
7090 #define TARGET_LITTLE_NAME "elf64-l1om"
7092 #define ELF_ARCH bfd_arch_l1om
7094 #undef ELF_MACHINE_CODE
7095 #define ELF_MACHINE_CODE EM_L1OM
7100 #define elf64_bed elf64_l1om_bed
7102 #undef elf_backend_object_p
7103 #define elf_backend_object_p elf64_l1om_elf_object_p
7105 /* Restore defaults. */
7106 #undef ELF_MAXPAGESIZE
7107 #undef ELF_MINPAGESIZE
7108 #undef ELF_COMMONPAGESIZE
7109 #define ELF_MAXPAGESIZE 0x200000
7110 #define ELF_MINPAGESIZE 0x1000
7111 #define ELF_COMMONPAGESIZE 0x1000
7112 #undef elf_backend_plt_alignment
7113 #define elf_backend_plt_alignment 4
7114 #undef elf_backend_arch_data
7115 #define elf_backend_arch_data &elf_x86_64_arch_bed
7117 #include "elf64-target.h"
7119 /* FreeBSD L1OM support. */
7121 #undef TARGET_LITTLE_SYM
7122 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
7123 #undef TARGET_LITTLE_NAME
7124 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
7127 #define ELF_OSABI ELFOSABI_FREEBSD
7130 #define elf64_bed elf64_l1om_fbsd_bed
7132 #include "elf64-target.h"
7134 /* Intel K1OM support. */
7137 elf64_k1om_elf_object_p (bfd
*abfd
)
7139 /* Set the right machine number for an K1OM elf64 file. */
7140 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
7144 #undef TARGET_LITTLE_SYM
7145 #define TARGET_LITTLE_SYM k1om_elf64_vec
7146 #undef TARGET_LITTLE_NAME
7147 #define TARGET_LITTLE_NAME "elf64-k1om"
7149 #define ELF_ARCH bfd_arch_k1om
7151 #undef ELF_MACHINE_CODE
7152 #define ELF_MACHINE_CODE EM_K1OM
7157 #define elf64_bed elf64_k1om_bed
7159 #undef elf_backend_object_p
7160 #define elf_backend_object_p elf64_k1om_elf_object_p
7162 #undef elf_backend_static_tls_alignment
7164 #undef elf_backend_want_plt_sym
7165 #define elf_backend_want_plt_sym 0
7167 #include "elf64-target.h"
7169 /* FreeBSD K1OM support. */
7171 #undef TARGET_LITTLE_SYM
7172 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
7173 #undef TARGET_LITTLE_NAME
7174 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
7177 #define ELF_OSABI ELFOSABI_FREEBSD
7180 #define elf64_bed elf64_k1om_fbsd_bed
7182 #include "elf64-target.h"
7184 /* 32bit x86-64 support. */
7186 #undef TARGET_LITTLE_SYM
7187 #define TARGET_LITTLE_SYM x86_64_elf32_vec
7188 #undef TARGET_LITTLE_NAME
7189 #define TARGET_LITTLE_NAME "elf32-x86-64"
7193 #define ELF_ARCH bfd_arch_i386
7195 #undef ELF_MACHINE_CODE
7196 #define ELF_MACHINE_CODE EM_X86_64
7200 #undef elf_backend_object_p
7201 #define elf_backend_object_p \
7202 elf32_x86_64_elf_object_p
7204 #undef elf_backend_bfd_from_remote_memory
7205 #define elf_backend_bfd_from_remote_memory \
7206 _bfd_elf32_bfd_from_remote_memory
7208 #undef elf_backend_size_info
7209 #define elf_backend_size_info \
7210 _bfd_elf32_size_info
7212 #include "elf32-target.h"