1 /* X86-64 specific support for ELF
2 Copyright (C) 2000-2016 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka <jh@suse.cz>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
28 #include "bfd_stdint.h"
32 #include "libiberty.h"
34 #include "opcode/i386.h"
35 #include "elf/x86-64.h"
42 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
43 #define MINUS_ONE (~ (bfd_vma) 0)
45 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
46 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
47 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
48 since they are the same. */
50 #define ABI_64_P(abfd) \
51 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
53 /* The relocation "howto" table. Order of fields:
54 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
55 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
56 static reloc_howto_type x86_64_elf_howto_table
[] =
58 HOWTO(R_X86_64_NONE
, 0, 3, 0, FALSE
, 0, complain_overflow_dont
,
59 bfd_elf_generic_reloc
, "R_X86_64_NONE", FALSE
, 0x00000000, 0x00000000,
61 HOWTO(R_X86_64_64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
62 bfd_elf_generic_reloc
, "R_X86_64_64", FALSE
, MINUS_ONE
, MINUS_ONE
,
64 HOWTO(R_X86_64_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
65 bfd_elf_generic_reloc
, "R_X86_64_PC32", FALSE
, 0xffffffff, 0xffffffff,
67 HOWTO(R_X86_64_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
68 bfd_elf_generic_reloc
, "R_X86_64_GOT32", FALSE
, 0xffffffff, 0xffffffff,
70 HOWTO(R_X86_64_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
71 bfd_elf_generic_reloc
, "R_X86_64_PLT32", FALSE
, 0xffffffff, 0xffffffff,
73 HOWTO(R_X86_64_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
74 bfd_elf_generic_reloc
, "R_X86_64_COPY", FALSE
, 0xffffffff, 0xffffffff,
76 HOWTO(R_X86_64_GLOB_DAT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
77 bfd_elf_generic_reloc
, "R_X86_64_GLOB_DAT", FALSE
, MINUS_ONE
,
79 HOWTO(R_X86_64_JUMP_SLOT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
80 bfd_elf_generic_reloc
, "R_X86_64_JUMP_SLOT", FALSE
, MINUS_ONE
,
82 HOWTO(R_X86_64_RELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
83 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE", FALSE
, MINUS_ONE
,
85 HOWTO(R_X86_64_GOTPCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
86 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL", FALSE
, 0xffffffff,
88 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
89 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
91 HOWTO(R_X86_64_32S
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
92 bfd_elf_generic_reloc
, "R_X86_64_32S", FALSE
, 0xffffffff, 0xffffffff,
94 HOWTO(R_X86_64_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
95 bfd_elf_generic_reloc
, "R_X86_64_16", FALSE
, 0xffff, 0xffff, FALSE
),
96 HOWTO(R_X86_64_PC16
,0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
97 bfd_elf_generic_reloc
, "R_X86_64_PC16", FALSE
, 0xffff, 0xffff, TRUE
),
98 HOWTO(R_X86_64_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
99 bfd_elf_generic_reloc
, "R_X86_64_8", FALSE
, 0xff, 0xff, FALSE
),
100 HOWTO(R_X86_64_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
101 bfd_elf_generic_reloc
, "R_X86_64_PC8", FALSE
, 0xff, 0xff, TRUE
),
102 HOWTO(R_X86_64_DTPMOD64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
103 bfd_elf_generic_reloc
, "R_X86_64_DTPMOD64", FALSE
, MINUS_ONE
,
105 HOWTO(R_X86_64_DTPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
106 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF64", FALSE
, MINUS_ONE
,
108 HOWTO(R_X86_64_TPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
109 bfd_elf_generic_reloc
, "R_X86_64_TPOFF64", FALSE
, MINUS_ONE
,
111 HOWTO(R_X86_64_TLSGD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
112 bfd_elf_generic_reloc
, "R_X86_64_TLSGD", FALSE
, 0xffffffff,
114 HOWTO(R_X86_64_TLSLD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
115 bfd_elf_generic_reloc
, "R_X86_64_TLSLD", FALSE
, 0xffffffff,
117 HOWTO(R_X86_64_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
118 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF32", FALSE
, 0xffffffff,
120 HOWTO(R_X86_64_GOTTPOFF
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
121 bfd_elf_generic_reloc
, "R_X86_64_GOTTPOFF", FALSE
, 0xffffffff,
123 HOWTO(R_X86_64_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
124 bfd_elf_generic_reloc
, "R_X86_64_TPOFF32", FALSE
, 0xffffffff,
126 HOWTO(R_X86_64_PC64
, 0, 4, 64, TRUE
, 0, complain_overflow_bitfield
,
127 bfd_elf_generic_reloc
, "R_X86_64_PC64", FALSE
, MINUS_ONE
, MINUS_ONE
,
129 HOWTO(R_X86_64_GOTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
130 bfd_elf_generic_reloc
, "R_X86_64_GOTOFF64",
131 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
132 HOWTO(R_X86_64_GOTPC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
133 bfd_elf_generic_reloc
, "R_X86_64_GOTPC32",
134 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
135 HOWTO(R_X86_64_GOT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
136 bfd_elf_generic_reloc
, "R_X86_64_GOT64", FALSE
, MINUS_ONE
, MINUS_ONE
,
138 HOWTO(R_X86_64_GOTPCREL64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
139 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL64", FALSE
, MINUS_ONE
,
141 HOWTO(R_X86_64_GOTPC64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
142 bfd_elf_generic_reloc
, "R_X86_64_GOTPC64",
143 FALSE
, MINUS_ONE
, MINUS_ONE
, TRUE
),
144 HOWTO(R_X86_64_GOTPLT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
145 bfd_elf_generic_reloc
, "R_X86_64_GOTPLT64", FALSE
, MINUS_ONE
,
147 HOWTO(R_X86_64_PLTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
148 bfd_elf_generic_reloc
, "R_X86_64_PLTOFF64", FALSE
, MINUS_ONE
,
150 HOWTO(R_X86_64_SIZE32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
151 bfd_elf_generic_reloc
, "R_X86_64_SIZE32", FALSE
, 0xffffffff, 0xffffffff,
153 HOWTO(R_X86_64_SIZE64
, 0, 4, 64, FALSE
, 0, complain_overflow_unsigned
,
154 bfd_elf_generic_reloc
, "R_X86_64_SIZE64", FALSE
, MINUS_ONE
, MINUS_ONE
,
156 HOWTO(R_X86_64_GOTPC32_TLSDESC
, 0, 2, 32, TRUE
, 0,
157 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
158 "R_X86_64_GOTPC32_TLSDESC",
159 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
160 HOWTO(R_X86_64_TLSDESC_CALL
, 0, 0, 0, FALSE
, 0,
161 complain_overflow_dont
, bfd_elf_generic_reloc
,
162 "R_X86_64_TLSDESC_CALL",
164 HOWTO(R_X86_64_TLSDESC
, 0, 4, 64, FALSE
, 0,
165 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
167 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
168 HOWTO(R_X86_64_IRELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
169 bfd_elf_generic_reloc
, "R_X86_64_IRELATIVE", FALSE
, MINUS_ONE
,
171 HOWTO(R_X86_64_RELATIVE64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
172 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE64", FALSE
, MINUS_ONE
,
174 HOWTO(R_X86_64_PC32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
175 bfd_elf_generic_reloc
, "R_X86_64_PC32_BND", FALSE
, 0xffffffff, 0xffffffff,
177 HOWTO(R_X86_64_PLT32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
178 bfd_elf_generic_reloc
, "R_X86_64_PLT32_BND", FALSE
, 0xffffffff, 0xffffffff,
180 HOWTO(R_X86_64_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
181 bfd_elf_generic_reloc
, "R_X86_64_GOTPCRELX", FALSE
, 0xffffffff,
183 HOWTO(R_X86_64_REX_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
184 bfd_elf_generic_reloc
, "R_X86_64_REX_GOTPCRELX", FALSE
, 0xffffffff,
187 /* We have a gap in the reloc numbers here.
188 R_X86_64_standard counts the number up to this point, and
189 R_X86_64_vt_offset is the value to subtract from a reloc type of
190 R_X86_64_GNU_VT* to form an index into this table. */
191 #define R_X86_64_standard (R_X86_64_REX_GOTPCRELX + 1)
192 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
194 /* GNU extension to record C++ vtable hierarchy. */
195 HOWTO (R_X86_64_GNU_VTINHERIT
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
196 NULL
, "R_X86_64_GNU_VTINHERIT", FALSE
, 0, 0, FALSE
),
198 /* GNU extension to record C++ vtable member usage. */
199 HOWTO (R_X86_64_GNU_VTENTRY
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
200 _bfd_elf_rel_vtable_reloc_fn
, "R_X86_64_GNU_VTENTRY", FALSE
, 0, 0,
203 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
204 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
205 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
209 #define IS_X86_64_PCREL_TYPE(TYPE) \
210 ( ((TYPE) == R_X86_64_PC8) \
211 || ((TYPE) == R_X86_64_PC16) \
212 || ((TYPE) == R_X86_64_PC32) \
213 || ((TYPE) == R_X86_64_PC32_BND) \
214 || ((TYPE) == R_X86_64_PC64))
216 /* Map BFD relocs to the x86_64 elf relocs. */
219 bfd_reloc_code_real_type bfd_reloc_val
;
220 unsigned char elf_reloc_val
;
223 static const struct elf_reloc_map x86_64_reloc_map
[] =
225 { BFD_RELOC_NONE
, R_X86_64_NONE
, },
226 { BFD_RELOC_64
, R_X86_64_64
, },
227 { BFD_RELOC_32_PCREL
, R_X86_64_PC32
, },
228 { BFD_RELOC_X86_64_GOT32
, R_X86_64_GOT32
,},
229 { BFD_RELOC_X86_64_PLT32
, R_X86_64_PLT32
,},
230 { BFD_RELOC_X86_64_COPY
, R_X86_64_COPY
, },
231 { BFD_RELOC_X86_64_GLOB_DAT
, R_X86_64_GLOB_DAT
, },
232 { BFD_RELOC_X86_64_JUMP_SLOT
, R_X86_64_JUMP_SLOT
, },
233 { BFD_RELOC_X86_64_RELATIVE
, R_X86_64_RELATIVE
, },
234 { BFD_RELOC_X86_64_GOTPCREL
, R_X86_64_GOTPCREL
, },
235 { BFD_RELOC_32
, R_X86_64_32
, },
236 { BFD_RELOC_X86_64_32S
, R_X86_64_32S
, },
237 { BFD_RELOC_16
, R_X86_64_16
, },
238 { BFD_RELOC_16_PCREL
, R_X86_64_PC16
, },
239 { BFD_RELOC_8
, R_X86_64_8
, },
240 { BFD_RELOC_8_PCREL
, R_X86_64_PC8
, },
241 { BFD_RELOC_X86_64_DTPMOD64
, R_X86_64_DTPMOD64
, },
242 { BFD_RELOC_X86_64_DTPOFF64
, R_X86_64_DTPOFF64
, },
243 { BFD_RELOC_X86_64_TPOFF64
, R_X86_64_TPOFF64
, },
244 { BFD_RELOC_X86_64_TLSGD
, R_X86_64_TLSGD
, },
245 { BFD_RELOC_X86_64_TLSLD
, R_X86_64_TLSLD
, },
246 { BFD_RELOC_X86_64_DTPOFF32
, R_X86_64_DTPOFF32
, },
247 { BFD_RELOC_X86_64_GOTTPOFF
, R_X86_64_GOTTPOFF
, },
248 { BFD_RELOC_X86_64_TPOFF32
, R_X86_64_TPOFF32
, },
249 { BFD_RELOC_64_PCREL
, R_X86_64_PC64
, },
250 { BFD_RELOC_X86_64_GOTOFF64
, R_X86_64_GOTOFF64
, },
251 { BFD_RELOC_X86_64_GOTPC32
, R_X86_64_GOTPC32
, },
252 { BFD_RELOC_X86_64_GOT64
, R_X86_64_GOT64
, },
253 { BFD_RELOC_X86_64_GOTPCREL64
,R_X86_64_GOTPCREL64
, },
254 { BFD_RELOC_X86_64_GOTPC64
, R_X86_64_GOTPC64
, },
255 { BFD_RELOC_X86_64_GOTPLT64
, R_X86_64_GOTPLT64
, },
256 { BFD_RELOC_X86_64_PLTOFF64
, R_X86_64_PLTOFF64
, },
257 { BFD_RELOC_SIZE32
, R_X86_64_SIZE32
, },
258 { BFD_RELOC_SIZE64
, R_X86_64_SIZE64
, },
259 { BFD_RELOC_X86_64_GOTPC32_TLSDESC
, R_X86_64_GOTPC32_TLSDESC
, },
260 { BFD_RELOC_X86_64_TLSDESC_CALL
, R_X86_64_TLSDESC_CALL
, },
261 { BFD_RELOC_X86_64_TLSDESC
, R_X86_64_TLSDESC
, },
262 { BFD_RELOC_X86_64_IRELATIVE
, R_X86_64_IRELATIVE
, },
263 { BFD_RELOC_X86_64_PC32_BND
, R_X86_64_PC32_BND
, },
264 { BFD_RELOC_X86_64_PLT32_BND
, R_X86_64_PLT32_BND
, },
265 { BFD_RELOC_X86_64_GOTPCRELX
, R_X86_64_GOTPCRELX
, },
266 { BFD_RELOC_X86_64_REX_GOTPCRELX
, R_X86_64_REX_GOTPCRELX
, },
267 { BFD_RELOC_VTABLE_INHERIT
, R_X86_64_GNU_VTINHERIT
, },
268 { BFD_RELOC_VTABLE_ENTRY
, R_X86_64_GNU_VTENTRY
, },
271 static reloc_howto_type
*
272 elf_x86_64_rtype_to_howto (bfd
*abfd
, unsigned r_type
)
276 if (r_type
== (unsigned int) R_X86_64_32
)
281 i
= ARRAY_SIZE (x86_64_elf_howto_table
) - 1;
283 else if (r_type
< (unsigned int) R_X86_64_GNU_VTINHERIT
284 || r_type
>= (unsigned int) R_X86_64_max
)
286 if (r_type
>= (unsigned int) R_X86_64_standard
)
288 (*_bfd_error_handler
) (_("%B: invalid relocation type %d"),
290 r_type
= R_X86_64_NONE
;
295 i
= r_type
- (unsigned int) R_X86_64_vt_offset
;
296 BFD_ASSERT (x86_64_elf_howto_table
[i
].type
== r_type
);
297 return &x86_64_elf_howto_table
[i
];
300 /* Given a BFD reloc type, return a HOWTO structure. */
301 static reloc_howto_type
*
302 elf_x86_64_reloc_type_lookup (bfd
*abfd
,
303 bfd_reloc_code_real_type code
)
307 for (i
= 0; i
< sizeof (x86_64_reloc_map
) / sizeof (struct elf_reloc_map
);
310 if (x86_64_reloc_map
[i
].bfd_reloc_val
== code
)
311 return elf_x86_64_rtype_to_howto (abfd
,
312 x86_64_reloc_map
[i
].elf_reloc_val
);
317 static reloc_howto_type
*
318 elf_x86_64_reloc_name_lookup (bfd
*abfd
,
323 if (!ABI_64_P (abfd
) && strcasecmp (r_name
, "R_X86_64_32") == 0)
325 /* Get x32 R_X86_64_32. */
326 reloc_howto_type
*reloc
327 = &x86_64_elf_howto_table
[ARRAY_SIZE (x86_64_elf_howto_table
) - 1];
328 BFD_ASSERT (reloc
->type
== (unsigned int) R_X86_64_32
);
332 for (i
= 0; i
< ARRAY_SIZE (x86_64_elf_howto_table
); i
++)
333 if (x86_64_elf_howto_table
[i
].name
!= NULL
334 && strcasecmp (x86_64_elf_howto_table
[i
].name
, r_name
) == 0)
335 return &x86_64_elf_howto_table
[i
];
340 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
343 elf_x86_64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
344 Elf_Internal_Rela
*dst
)
348 r_type
= ELF32_R_TYPE (dst
->r_info
);
349 cache_ptr
->howto
= elf_x86_64_rtype_to_howto (abfd
, r_type
);
350 BFD_ASSERT (r_type
== cache_ptr
->howto
->type
);
353 /* Support for core dump NOTE sections. */
355 elf_x86_64_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
360 switch (note
->descsz
)
365 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
367 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
370 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
378 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
380 elf_tdata (abfd
)->core
->signal
381 = bfd_get_16 (abfd
, note
->descdata
+ 12);
384 elf_tdata (abfd
)->core
->lwpid
385 = bfd_get_32 (abfd
, note
->descdata
+ 32);
394 /* Make a ".reg/999" section. */
395 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
396 size
, note
->descpos
+ offset
);
400 elf_x86_64_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
402 switch (note
->descsz
)
407 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
408 elf_tdata (abfd
)->core
->pid
409 = bfd_get_32 (abfd
, note
->descdata
+ 12);
410 elf_tdata (abfd
)->core
->program
411 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
412 elf_tdata (abfd
)->core
->command
413 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
416 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
417 elf_tdata (abfd
)->core
->pid
418 = bfd_get_32 (abfd
, note
->descdata
+ 24);
419 elf_tdata (abfd
)->core
->program
420 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
421 elf_tdata (abfd
)->core
->command
422 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
425 /* Note that for some reason, a spurious space is tacked
426 onto the end of the args in some (at least one anyway)
427 implementations, so strip it off if it exists. */
430 char *command
= elf_tdata (abfd
)->core
->command
;
431 int n
= strlen (command
);
433 if (0 < n
&& command
[n
- 1] == ' ')
434 command
[n
- 1] = '\0';
442 elf_x86_64_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
,
445 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
447 const char *fname
, *psargs
;
458 va_start (ap
, note_type
);
459 fname
= va_arg (ap
, const char *);
460 psargs
= va_arg (ap
, const char *);
463 if (bed
->s
->elfclass
== ELFCLASS32
)
466 memset (&data
, 0, sizeof (data
));
467 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
468 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
469 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
470 &data
, sizeof (data
));
475 memset (&data
, 0, sizeof (data
));
476 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
477 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
478 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
479 &data
, sizeof (data
));
484 va_start (ap
, note_type
);
485 pid
= va_arg (ap
, long);
486 cursig
= va_arg (ap
, int);
487 gregs
= va_arg (ap
, const void *);
490 if (bed
->s
->elfclass
== ELFCLASS32
)
492 if (bed
->elf_machine_code
== EM_X86_64
)
494 prstatusx32_t prstat
;
495 memset (&prstat
, 0, sizeof (prstat
));
497 prstat
.pr_cursig
= cursig
;
498 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
499 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
500 &prstat
, sizeof (prstat
));
505 memset (&prstat
, 0, sizeof (prstat
));
507 prstat
.pr_cursig
= cursig
;
508 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
509 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
510 &prstat
, sizeof (prstat
));
516 memset (&prstat
, 0, sizeof (prstat
));
518 prstat
.pr_cursig
= cursig
;
519 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
520 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
521 &prstat
, sizeof (prstat
));
528 /* Functions for the x86-64 ELF linker. */
530 /* The name of the dynamic interpreter. This is put in the .interp
533 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
534 #define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
536 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
537 copying dynamic variables from a shared lib into an app's dynbss
538 section, and instead use a dynamic relocation to point into the
540 #define ELIMINATE_COPY_RELOCS 1
542 /* The size in bytes of an entry in the global offset table. */
544 #define GOT_ENTRY_SIZE 8
546 /* The size in bytes of an entry in the procedure linkage table. */
548 #define PLT_ENTRY_SIZE 16
550 /* The first entry in a procedure linkage table looks like this. See the
551 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
553 static const bfd_byte elf_x86_64_plt0_entry
[PLT_ENTRY_SIZE
] =
555 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
556 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
557 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
560 /* Subsequent entries in a procedure linkage table look like this. */
562 static const bfd_byte elf_x86_64_plt_entry
[PLT_ENTRY_SIZE
] =
564 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
565 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
566 0x68, /* pushq immediate */
567 0, 0, 0, 0, /* replaced with index into relocation table. */
568 0xe9, /* jmp relative */
569 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
572 /* The first entry in a procedure linkage table with BND relocations
575 static const bfd_byte elf_x86_64_bnd_plt0_entry
[PLT_ENTRY_SIZE
] =
577 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
578 0xf2, 0xff, 0x25, 16, 0, 0, 0, /* bnd jmpq *GOT+16(%rip) */
579 0x0f, 0x1f, 0 /* nopl (%rax) */
582 /* Subsequent entries for legacy branches in a procedure linkage table
583 with BND relocations look like this. */
585 static const bfd_byte elf_x86_64_legacy_plt_entry
[PLT_ENTRY_SIZE
] =
587 0x68, 0, 0, 0, 0, /* pushq immediate */
588 0xe9, 0, 0, 0, 0, /* jmpq relative */
589 0x66, 0x0f, 0x1f, 0x44, 0, 0 /* nopw (%rax,%rax,1) */
592 /* Subsequent entries for branches with BND prefx in a procedure linkage
593 table with BND relocations look like this. */
595 static const bfd_byte elf_x86_64_bnd_plt_entry
[PLT_ENTRY_SIZE
] =
597 0x68, 0, 0, 0, 0, /* pushq immediate */
598 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
599 0x0f, 0x1f, 0x44, 0, 0 /* nopl 0(%rax,%rax,1) */
602 /* Entries for legacy branches in the second procedure linkage table
605 static const bfd_byte elf_x86_64_legacy_plt2_entry
[8] =
607 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
608 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
609 0x66, 0x90 /* xchg %ax,%ax */
612 /* Entries for branches with BND prefix in the second procedure linkage
613 table look like this. */
615 static const bfd_byte elf_x86_64_bnd_plt2_entry
[8] =
617 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
618 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
622 /* .eh_frame covering the .plt section. */
624 static const bfd_byte elf_x86_64_eh_frame_plt
[] =
626 #define PLT_CIE_LENGTH 20
627 #define PLT_FDE_LENGTH 36
628 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
629 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
630 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
631 0, 0, 0, 0, /* CIE ID */
633 'z', 'R', 0, /* Augmentation string */
634 1, /* Code alignment factor */
635 0x78, /* Data alignment factor */
636 16, /* Return address column */
637 1, /* Augmentation size */
638 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
639 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
640 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
641 DW_CFA_nop
, DW_CFA_nop
,
643 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
644 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
645 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
646 0, 0, 0, 0, /* .plt size goes here */
647 0, /* Augmentation size */
648 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
649 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
650 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
651 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
652 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
653 11, /* Block length */
654 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
655 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
656 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
657 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
658 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
661 /* Architecture-specific backend data for x86-64. */
663 struct elf_x86_64_backend_data
665 /* Templates for the initial PLT entry and for subsequent entries. */
666 const bfd_byte
*plt0_entry
;
667 const bfd_byte
*plt_entry
;
668 unsigned int plt_entry_size
; /* Size of each PLT entry. */
670 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
671 unsigned int plt0_got1_offset
;
672 unsigned int plt0_got2_offset
;
674 /* Offset of the end of the PC-relative instruction containing
676 unsigned int plt0_got2_insn_end
;
678 /* Offsets into plt_entry that are to be replaced with... */
679 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
680 unsigned int plt_reloc_offset
; /* ... offset into relocation table. */
681 unsigned int plt_plt_offset
; /* ... offset to start of .plt. */
683 /* Length of the PC-relative instruction containing plt_got_offset. */
684 unsigned int plt_got_insn_size
;
686 /* Offset of the end of the PC-relative jump to plt0_entry. */
687 unsigned int plt_plt_insn_end
;
689 /* Offset into plt_entry where the initial value of the GOT entry points. */
690 unsigned int plt_lazy_offset
;
692 /* .eh_frame covering the .plt section. */
693 const bfd_byte
*eh_frame_plt
;
694 unsigned int eh_frame_plt_size
;
697 #define get_elf_x86_64_arch_data(bed) \
698 ((const struct elf_x86_64_backend_data *) (bed)->arch_data)
700 #define get_elf_x86_64_backend_data(abfd) \
701 get_elf_x86_64_arch_data (get_elf_backend_data (abfd))
703 #define GET_PLT_ENTRY_SIZE(abfd) \
704 get_elf_x86_64_backend_data (abfd)->plt_entry_size
706 /* These are the standard parameters. */
707 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed
=
709 elf_x86_64_plt0_entry
, /* plt0_entry */
710 elf_x86_64_plt_entry
, /* plt_entry */
711 sizeof (elf_x86_64_plt_entry
), /* plt_entry_size */
712 2, /* plt0_got1_offset */
713 8, /* plt0_got2_offset */
714 12, /* plt0_got2_insn_end */
715 2, /* plt_got_offset */
716 7, /* plt_reloc_offset */
717 12, /* plt_plt_offset */
718 6, /* plt_got_insn_size */
719 PLT_ENTRY_SIZE
, /* plt_plt_insn_end */
720 6, /* plt_lazy_offset */
721 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
722 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
725 static const struct elf_x86_64_backend_data elf_x86_64_bnd_arch_bed
=
727 elf_x86_64_bnd_plt0_entry
, /* plt0_entry */
728 elf_x86_64_bnd_plt_entry
, /* plt_entry */
729 sizeof (elf_x86_64_bnd_plt_entry
), /* plt_entry_size */
730 2, /* plt0_got1_offset */
731 1+8, /* plt0_got2_offset */
732 1+12, /* plt0_got2_insn_end */
733 1+2, /* plt_got_offset */
734 1, /* plt_reloc_offset */
735 7, /* plt_plt_offset */
736 1+6, /* plt_got_insn_size */
737 11, /* plt_plt_insn_end */
738 0, /* plt_lazy_offset */
739 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
740 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
743 #define elf_backend_arch_data &elf_x86_64_arch_bed
745 /* Is a undefined weak symbol which is resolved to 0. Reference to an
746 undefined weak symbol is resolved to 0 when building executable if
748 1. Has non-GOT/non-PLT relocations in text section. Or
749 2. Has no GOT/PLT relocation.
751 #define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, GOT_RELOC, EH) \
752 ((EH)->elf.root.type == bfd_link_hash_undefweak \
753 && bfd_link_executable (INFO) \
754 && (elf_x86_64_hash_table (INFO)->interp == NULL \
756 || (EH)->has_non_got_reloc \
757 || !(INFO)->dynamic_undefined_weak))
759 /* x86-64 ELF linker hash entry. */
761 struct elf_x86_64_link_hash_entry
763 struct elf_link_hash_entry elf
;
765 /* Track dynamic relocs copied for this symbol. */
766 struct elf_dyn_relocs
*dyn_relocs
;
768 #define GOT_UNKNOWN 0
772 #define GOT_TLS_GDESC 4
773 #define GOT_TLS_GD_BOTH_P(type) \
774 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
775 #define GOT_TLS_GD_P(type) \
776 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
777 #define GOT_TLS_GDESC_P(type) \
778 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
779 #define GOT_TLS_GD_ANY_P(type) \
780 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
781 unsigned char tls_type
;
783 /* TRUE if a weak symbol with a real definition needs a copy reloc.
784 When there is a weak symbol with a real definition, the processor
785 independent code will have arranged for us to see the real
786 definition first. We need to copy the needs_copy bit from the
787 real definition and check it when allowing copy reloc in PIE. */
788 unsigned int needs_copy
: 1;
790 /* TRUE if symbol has at least one BND relocation. */
791 unsigned int has_bnd_reloc
: 1;
793 /* TRUE if symbol has GOT or PLT relocations. */
794 unsigned int has_got_reloc
: 1;
796 /* TRUE if symbol has non-GOT/non-PLT relocations in text sections. */
797 unsigned int has_non_got_reloc
: 1;
799 /* 0: symbol isn't __tls_get_addr.
800 1: symbol is __tls_get_addr.
801 2: symbol is unknown. */
802 unsigned int tls_get_addr
: 2;
804 /* Reference count of C/C++ function pointer relocations in read-write
805 section which can be resolved at run-time. */
806 bfd_signed_vma func_pointer_refcount
;
808 /* Information about the GOT PLT entry. Filled when there are both
809 GOT and PLT relocations against the same function. */
810 union gotplt_union plt_got
;
812 /* Information about the second PLT entry. Filled when has_bnd_reloc is
814 union gotplt_union plt_bnd
;
816 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
817 starting at the end of the jump table. */
821 #define elf_x86_64_hash_entry(ent) \
822 ((struct elf_x86_64_link_hash_entry *)(ent))
824 struct elf_x86_64_obj_tdata
826 struct elf_obj_tdata root
;
828 /* tls_type for each local got entry. */
829 char *local_got_tls_type
;
831 /* GOTPLT entries for TLS descriptors. */
832 bfd_vma
*local_tlsdesc_gotent
;
835 #define elf_x86_64_tdata(abfd) \
836 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
838 #define elf_x86_64_local_got_tls_type(abfd) \
839 (elf_x86_64_tdata (abfd)->local_got_tls_type)
841 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
842 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
844 #define is_x86_64_elf(bfd) \
845 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
846 && elf_tdata (bfd) != NULL \
847 && elf_object_id (bfd) == X86_64_ELF_DATA)
850 elf_x86_64_mkobject (bfd
*abfd
)
852 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_x86_64_obj_tdata
),
856 /* x86-64 ELF linker hash table. */
858 struct elf_x86_64_link_hash_table
860 struct elf_link_hash_table elf
;
862 /* Short-cuts to get to dynamic linker sections. */
866 asection
*plt_eh_frame
;
872 bfd_signed_vma refcount
;
876 /* The amount of space used by the jump slots in the GOT. */
877 bfd_vma sgotplt_jump_table_size
;
879 /* Small local sym cache. */
880 struct sym_cache sym_cache
;
882 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
883 bfd_vma (*r_sym
) (bfd_vma
);
884 unsigned int pointer_r_type
;
885 const char *dynamic_interpreter
;
886 int dynamic_interpreter_size
;
888 /* _TLS_MODULE_BASE_ symbol. */
889 struct bfd_link_hash_entry
*tls_module_base
;
891 /* Used by local STT_GNU_IFUNC symbols. */
892 htab_t loc_hash_table
;
893 void * loc_hash_memory
;
895 /* The offset into splt of the PLT entry for the TLS descriptor
896 resolver. Special values are 0, if not necessary (or not found
897 to be necessary yet), and -1 if needed but not determined
900 /* The offset into sgot of the GOT entry used by the PLT entry
904 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
905 bfd_vma next_jump_slot_index
;
906 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
907 bfd_vma next_irelative_index
;
909 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
910 to read-only sections. */
911 bfd_boolean readonly_dynrelocs_against_ifunc
;
914 /* Get the x86-64 ELF linker hash table from a link_info structure. */
916 #define elf_x86_64_hash_table(p) \
917 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
918 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
920 #define elf_x86_64_compute_jump_table_size(htab) \
921 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
923 /* Create an entry in an x86-64 ELF linker hash table. */
925 static struct bfd_hash_entry
*
926 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
927 struct bfd_hash_table
*table
,
930 /* Allocate the structure if it has not already been allocated by a
934 entry
= (struct bfd_hash_entry
*)
935 bfd_hash_allocate (table
,
936 sizeof (struct elf_x86_64_link_hash_entry
));
941 /* Call the allocation method of the superclass. */
942 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
945 struct elf_x86_64_link_hash_entry
*eh
;
947 eh
= (struct elf_x86_64_link_hash_entry
*) entry
;
948 eh
->dyn_relocs
= NULL
;
949 eh
->tls_type
= GOT_UNKNOWN
;
951 eh
->has_bnd_reloc
= 0;
952 eh
->has_got_reloc
= 0;
953 eh
->has_non_got_reloc
= 0;
954 eh
->tls_get_addr
= 2;
955 eh
->func_pointer_refcount
= 0;
956 eh
->plt_bnd
.offset
= (bfd_vma
) -1;
957 eh
->plt_got
.offset
= (bfd_vma
) -1;
958 eh
->tlsdesc_got
= (bfd_vma
) -1;
964 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
965 for local symbol so that we can handle local STT_GNU_IFUNC symbols
966 as global symbol. We reuse indx and dynstr_index for local symbol
967 hash since they aren't used by global symbols in this backend. */
970 elf_x86_64_local_htab_hash (const void *ptr
)
972 struct elf_link_hash_entry
*h
973 = (struct elf_link_hash_entry
*) ptr
;
974 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
977 /* Compare local hash entries. */
980 elf_x86_64_local_htab_eq (const void *ptr1
, const void *ptr2
)
982 struct elf_link_hash_entry
*h1
983 = (struct elf_link_hash_entry
*) ptr1
;
984 struct elf_link_hash_entry
*h2
985 = (struct elf_link_hash_entry
*) ptr2
;
987 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
990 /* Find and/or create a hash entry for local symbol. */
992 static struct elf_link_hash_entry
*
993 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table
*htab
,
994 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
997 struct elf_x86_64_link_hash_entry e
, *ret
;
998 asection
*sec
= abfd
->sections
;
999 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
1000 htab
->r_sym (rel
->r_info
));
1003 e
.elf
.indx
= sec
->id
;
1004 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
1005 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
1006 create
? INSERT
: NO_INSERT
);
1013 ret
= (struct elf_x86_64_link_hash_entry
*) *slot
;
1017 ret
= (struct elf_x86_64_link_hash_entry
*)
1018 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
1019 sizeof (struct elf_x86_64_link_hash_entry
));
1022 memset (ret
, 0, sizeof (*ret
));
1023 ret
->elf
.indx
= sec
->id
;
1024 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
1025 ret
->elf
.dynindx
= -1;
1026 ret
->func_pointer_refcount
= 0;
1027 ret
->plt_got
.offset
= (bfd_vma
) -1;
1033 /* Destroy an X86-64 ELF linker hash table. */
1036 elf_x86_64_link_hash_table_free (bfd
*obfd
)
1038 struct elf_x86_64_link_hash_table
*htab
1039 = (struct elf_x86_64_link_hash_table
*) obfd
->link
.hash
;
1041 if (htab
->loc_hash_table
)
1042 htab_delete (htab
->loc_hash_table
);
1043 if (htab
->loc_hash_memory
)
1044 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
1045 _bfd_elf_link_hash_table_free (obfd
);
1048 /* Create an X86-64 ELF linker hash table. */
1050 static struct bfd_link_hash_table
*
1051 elf_x86_64_link_hash_table_create (bfd
*abfd
)
1053 struct elf_x86_64_link_hash_table
*ret
;
1054 bfd_size_type amt
= sizeof (struct elf_x86_64_link_hash_table
);
1056 ret
= (struct elf_x86_64_link_hash_table
*) bfd_zmalloc (amt
);
1060 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1061 elf_x86_64_link_hash_newfunc
,
1062 sizeof (struct elf_x86_64_link_hash_entry
),
1069 if (ABI_64_P (abfd
))
1071 ret
->r_info
= elf64_r_info
;
1072 ret
->r_sym
= elf64_r_sym
;
1073 ret
->pointer_r_type
= R_X86_64_64
;
1074 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
1075 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
1079 ret
->r_info
= elf32_r_info
;
1080 ret
->r_sym
= elf32_r_sym
;
1081 ret
->pointer_r_type
= R_X86_64_32
;
1082 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
1083 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
1086 ret
->loc_hash_table
= htab_try_create (1024,
1087 elf_x86_64_local_htab_hash
,
1088 elf_x86_64_local_htab_eq
,
1090 ret
->loc_hash_memory
= objalloc_create ();
1091 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1093 elf_x86_64_link_hash_table_free (abfd
);
1096 ret
->elf
.root
.hash_table_free
= elf_x86_64_link_hash_table_free
;
1098 return &ret
->elf
.root
;
1101 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1102 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1106 elf_x86_64_create_dynamic_sections (bfd
*dynobj
,
1107 struct bfd_link_info
*info
)
1109 struct elf_x86_64_link_hash_table
*htab
;
1111 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1114 htab
= elf_x86_64_hash_table (info
);
1118 /* Set the contents of the .interp section to the interpreter. */
1119 if (bfd_link_executable (info
) && !info
->nointerp
)
1121 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
1124 s
->size
= htab
->dynamic_interpreter_size
;
1125 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
1129 htab
->sdynbss
= bfd_get_linker_section (dynobj
, ".dynbss");
1133 if (bfd_link_executable (info
))
1135 /* Always allow copy relocs for building executables. */
1136 asection
*s
= bfd_get_linker_section (dynobj
, ".rela.bss");
1139 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
1140 s
= bfd_make_section_anyway_with_flags (dynobj
,
1142 (bed
->dynamic_sec_flags
1145 || ! bfd_set_section_alignment (dynobj
, s
,
1146 bed
->s
->log_file_align
))
1152 if (!info
->no_ld_generated_unwind_info
1153 && htab
->plt_eh_frame
== NULL
1154 && htab
->elf
.splt
!= NULL
)
1156 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1157 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1158 | SEC_LINKER_CREATED
);
1160 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
1161 if (htab
->plt_eh_frame
== NULL
1162 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 3))
1168 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1171 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
1172 struct elf_link_hash_entry
*dir
,
1173 struct elf_link_hash_entry
*ind
)
1175 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
1177 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
1178 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
1180 if (!edir
->has_bnd_reloc
)
1181 edir
->has_bnd_reloc
= eind
->has_bnd_reloc
;
1183 if (!edir
->has_got_reloc
)
1184 edir
->has_got_reloc
= eind
->has_got_reloc
;
1186 if (!edir
->has_non_got_reloc
)
1187 edir
->has_non_got_reloc
= eind
->has_non_got_reloc
;
1189 if (eind
->dyn_relocs
!= NULL
)
1191 if (edir
->dyn_relocs
!= NULL
)
1193 struct elf_dyn_relocs
**pp
;
1194 struct elf_dyn_relocs
*p
;
1196 /* Add reloc counts against the indirect sym to the direct sym
1197 list. Merge any entries against the same section. */
1198 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1200 struct elf_dyn_relocs
*q
;
1202 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1203 if (q
->sec
== p
->sec
)
1205 q
->pc_count
+= p
->pc_count
;
1206 q
->count
+= p
->count
;
1213 *pp
= edir
->dyn_relocs
;
1216 edir
->dyn_relocs
= eind
->dyn_relocs
;
1217 eind
->dyn_relocs
= NULL
;
1220 if (ind
->root
.type
== bfd_link_hash_indirect
1221 && dir
->got
.refcount
<= 0)
1223 edir
->tls_type
= eind
->tls_type
;
1224 eind
->tls_type
= GOT_UNKNOWN
;
1227 if (ELIMINATE_COPY_RELOCS
1228 && ind
->root
.type
!= bfd_link_hash_indirect
1229 && dir
->dynamic_adjusted
)
1231 /* If called to transfer flags for a weakdef during processing
1232 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1233 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1234 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1235 dir
->ref_regular
|= ind
->ref_regular
;
1236 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1237 dir
->needs_plt
|= ind
->needs_plt
;
1238 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1242 if (eind
->func_pointer_refcount
> 0)
1244 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1245 eind
->func_pointer_refcount
= 0;
1248 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1253 elf64_x86_64_elf_object_p (bfd
*abfd
)
1255 /* Set the right machine number for an x86-64 elf64 file. */
1256 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
1261 elf32_x86_64_elf_object_p (bfd
*abfd
)
1263 /* Set the right machine number for an x86-64 elf32 file. */
1264 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
1268 /* Return TRUE if the TLS access code sequence support transition
1272 elf_x86_64_check_tls_transition (bfd
*abfd
,
1273 struct bfd_link_info
*info
,
1276 Elf_Internal_Shdr
*symtab_hdr
,
1277 struct elf_link_hash_entry
**sym_hashes
,
1278 unsigned int r_type
,
1279 const Elf_Internal_Rela
*rel
,
1280 const Elf_Internal_Rela
*relend
)
1283 unsigned long r_symndx
;
1284 bfd_boolean largepic
= FALSE
;
1285 struct elf_link_hash_entry
*h
;
1287 struct elf_x86_64_link_hash_table
*htab
;
1289 bfd_boolean indirect_call
, tls_get_addr
;
1291 htab
= elf_x86_64_hash_table (info
);
1292 offset
= rel
->r_offset
;
1295 case R_X86_64_TLSGD
:
1296 case R_X86_64_TLSLD
:
1297 if ((rel
+ 1) >= relend
)
1300 if (r_type
== R_X86_64_TLSGD
)
1302 /* Check transition from GD access model. For 64bit, only
1303 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1304 .word 0x6666; rex64; call __tls_get_addr@PLT
1306 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1308 call *__tls_get_addr@GOTPCREL(%rip)
1309 which may be converted to
1310 addr32 call __tls_get_addr
1311 can transit to different access model. For 32bit, only
1312 leaq foo@tlsgd(%rip), %rdi
1313 .word 0x6666; rex64; call __tls_get_addr@PLT
1315 leaq foo@tlsgd(%rip), %rdi
1317 call *__tls_get_addr@GOTPCREL(%rip)
1318 which may be converted to
1319 addr32 call __tls_get_addr
1320 can transit to different access model. For largepic,
1322 leaq foo@tlsgd(%rip), %rdi
1323 movabsq $__tls_get_addr@pltoff, %rax
1327 leaq foo@tlsgd(%rip), %rdi
1328 movabsq $__tls_get_addr@pltoff, %rax
1332 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1334 if ((offset
+ 12) > sec
->size
)
1337 call
= contents
+ offset
+ 4;
1339 || !((call
[1] == 0x48
1347 && call
[3] == 0xe8)))
1349 if (!ABI_64_P (abfd
)
1350 || (offset
+ 19) > sec
->size
1352 || memcmp (call
- 7, leaq
+ 1, 3) != 0
1353 || memcmp (call
, "\x48\xb8", 2) != 0
1357 || !((call
[10] == 0x48 && call
[12] == 0xd8)
1358 || (call
[10] == 0x4c && call
[12] == 0xf8)))
1362 else if (ABI_64_P (abfd
))
1365 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1371 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1374 indirect_call
= call
[2] == 0xff;
1378 /* Check transition from LD access model. Only
1379 leaq foo@tlsld(%rip), %rdi;
1380 call __tls_get_addr@PLT
1382 leaq foo@tlsld(%rip), %rdi;
1383 call *__tls_get_addr@GOTPCREL(%rip)
1384 which may be converted to
1385 addr32 call __tls_get_addr
1386 can transit to different access model. For largepic
1388 leaq foo@tlsld(%rip), %rdi
1389 movabsq $__tls_get_addr@pltoff, %rax
1393 leaq foo@tlsld(%rip), %rdi
1394 movabsq $__tls_get_addr@pltoff, %rax
1398 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1400 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1403 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0)
1406 call
= contents
+ offset
+ 4;
1407 if (!(call
[0] == 0xe8
1408 || (call
[0] == 0xff && call
[1] == 0x15)
1409 || (call
[0] == 0x67 && call
[1] == 0xe8)))
1411 if (!ABI_64_P (abfd
)
1412 || (offset
+ 19) > sec
->size
1413 || memcmp (call
, "\x48\xb8", 2) != 0
1417 || !((call
[10] == 0x48 && call
[12] == 0xd8)
1418 || (call
[10] == 0x4c && call
[12] == 0xf8)))
1422 indirect_call
= call
[0] == 0xff;
1425 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1426 if (r_symndx
< symtab_hdr
->sh_info
)
1429 tls_get_addr
= FALSE
;
1430 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1431 if (h
!= NULL
&& h
->root
.root
.string
!= NULL
)
1433 struct elf_x86_64_link_hash_entry
*eh
1434 = (struct elf_x86_64_link_hash_entry
*) h
;
1435 tls_get_addr
= eh
->tls_get_addr
== 1;
1436 if (eh
->tls_get_addr
> 1)
1438 /* Use strncmp to check __tls_get_addr since
1439 __tls_get_addr may be versioned. */
1440 if (strncmp (h
->root
.root
.string
, "__tls_get_addr", 14)
1443 eh
->tls_get_addr
= 1;
1444 tls_get_addr
= TRUE
;
1447 eh
->tls_get_addr
= 0;
1454 return ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLTOFF64
;
1455 else if (indirect_call
)
1456 return ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_GOTPCRELX
;
1458 return (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1459 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
);
1461 case R_X86_64_GOTTPOFF
:
1462 /* Check transition from IE access model:
1463 mov foo@gottpoff(%rip), %reg
1464 add foo@gottpoff(%rip), %reg
1467 /* Check REX prefix first. */
1468 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1470 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1471 if (val
!= 0x48 && val
!= 0x4c)
1473 /* X32 may have 0x44 REX prefix or no REX prefix. */
1474 if (ABI_64_P (abfd
))
1480 /* X32 may not have any REX prefix. */
1481 if (ABI_64_P (abfd
))
1483 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1487 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1488 if (val
!= 0x8b && val
!= 0x03)
1491 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1492 return (val
& 0xc7) == 5;
1494 case R_X86_64_GOTPC32_TLSDESC
:
1495 /* Check transition from GDesc access model:
1496 leaq x@tlsdesc(%rip), %rax
1498 Make sure it's a leaq adding rip to a 32-bit offset
1499 into any register, although it's probably almost always
1502 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1505 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1506 if ((val
& 0xfb) != 0x48)
1509 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1512 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1513 return (val
& 0xc7) == 0x05;
1515 case R_X86_64_TLSDESC_CALL
:
1516 /* Check transition from GDesc access model:
1517 call *x@tlsdesc(%rax)
1519 if (offset
+ 2 <= sec
->size
)
1521 /* Make sure that it's a call *x@tlsdesc(%rax). */
1522 call
= contents
+ offset
;
1523 return call
[0] == 0xff && call
[1] == 0x10;
1533 /* Return TRUE if the TLS access transition is OK or no transition
1534 will be performed. Update R_TYPE if there is a transition. */
1537 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1538 asection
*sec
, bfd_byte
*contents
,
1539 Elf_Internal_Shdr
*symtab_hdr
,
1540 struct elf_link_hash_entry
**sym_hashes
,
1541 unsigned int *r_type
, int tls_type
,
1542 const Elf_Internal_Rela
*rel
,
1543 const Elf_Internal_Rela
*relend
,
1544 struct elf_link_hash_entry
*h
,
1545 unsigned long r_symndx
,
1546 bfd_boolean from_relocate_section
)
1548 unsigned int from_type
= *r_type
;
1549 unsigned int to_type
= from_type
;
1550 bfd_boolean check
= TRUE
;
1552 /* Skip TLS transition for functions. */
1554 && (h
->type
== STT_FUNC
1555 || h
->type
== STT_GNU_IFUNC
))
1560 case R_X86_64_TLSGD
:
1561 case R_X86_64_GOTPC32_TLSDESC
:
1562 case R_X86_64_TLSDESC_CALL
:
1563 case R_X86_64_GOTTPOFF
:
1564 if (bfd_link_executable (info
))
1567 to_type
= R_X86_64_TPOFF32
;
1569 to_type
= R_X86_64_GOTTPOFF
;
1572 /* When we are called from elf_x86_64_relocate_section, there may
1573 be additional transitions based on TLS_TYPE. */
1574 if (from_relocate_section
)
1576 unsigned int new_to_type
= to_type
;
1578 if (bfd_link_executable (info
)
1581 && tls_type
== GOT_TLS_IE
)
1582 new_to_type
= R_X86_64_TPOFF32
;
1584 if (to_type
== R_X86_64_TLSGD
1585 || to_type
== R_X86_64_GOTPC32_TLSDESC
1586 || to_type
== R_X86_64_TLSDESC_CALL
)
1588 if (tls_type
== GOT_TLS_IE
)
1589 new_to_type
= R_X86_64_GOTTPOFF
;
1592 /* We checked the transition before when we were called from
1593 elf_x86_64_check_relocs. We only want to check the new
1594 transition which hasn't been checked before. */
1595 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1596 to_type
= new_to_type
;
1601 case R_X86_64_TLSLD
:
1602 if (bfd_link_executable (info
))
1603 to_type
= R_X86_64_TPOFF32
;
1610 /* Return TRUE if there is no transition. */
1611 if (from_type
== to_type
)
1614 /* Check if the transition can be performed. */
1616 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1617 symtab_hdr
, sym_hashes
,
1618 from_type
, rel
, relend
))
1620 reloc_howto_type
*from
, *to
;
1623 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1624 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1627 name
= h
->root
.root
.string
;
1630 struct elf_x86_64_link_hash_table
*htab
;
1632 htab
= elf_x86_64_hash_table (info
);
1637 Elf_Internal_Sym
*isym
;
1639 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1641 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1645 (*_bfd_error_handler
)
1646 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1647 "in section `%A' failed"),
1648 abfd
, sec
, from
->name
, to
->name
, name
,
1649 (unsigned long) rel
->r_offset
);
1650 bfd_set_error (bfd_error_bad_value
);
1658 /* Rename some of the generic section flags to better document how they
1660 #define need_convert_load sec_flg0
1661 #define check_relocs_failed sec_flg1
1664 elf_x86_64_need_pic (bfd
*input_bfd
, asection
*sec
,
1665 struct elf_link_hash_entry
*h
,
1666 Elf_Internal_Shdr
*symtab_hdr
,
1667 Elf_Internal_Sym
*isym
,
1668 reloc_howto_type
*howto
)
1671 const char *und
= "";
1672 const char *pic
= "";
1677 name
= h
->root
.root
.string
;
1678 switch (ELF_ST_VISIBILITY (h
->other
))
1681 v
= _("hidden symbol ");
1684 v
= _("internal symbol ");
1687 v
= _("protected symbol ");
1691 pic
= _("; recompile with -fPIC");
1695 if (!h
->def_regular
&& !h
->def_dynamic
)
1696 und
= _("undefined ");
1700 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, isym
, NULL
);
1701 pic
= _("; recompile with -fPIC");
1704 (*_bfd_error_handler
) (_("%B: relocation %s against %s%s`%s' can "
1705 "not be used when making a shared object%s"),
1706 input_bfd
, howto
->name
, und
, v
, name
, pic
);
1707 bfd_set_error (bfd_error_bad_value
);
1708 sec
->check_relocs_failed
= 1;
1712 /* With the local symbol, foo, we convert
1713 mov foo@GOTPCREL(%rip), %reg
1717 call/jmp *foo@GOTPCREL(%rip)
1719 nop call foo/jmp foo nop
1720 When PIC is false, convert
1721 test %reg, foo@GOTPCREL(%rip)
1725 binop foo@GOTPCREL(%rip), %reg
1728 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1732 elf_x86_64_convert_load_reloc (bfd
*abfd
, asection
*sec
,
1734 Elf_Internal_Rela
*irel
,
1735 struct elf_link_hash_entry
*h
,
1736 bfd_boolean
*converted
,
1737 struct bfd_link_info
*link_info
)
1739 struct elf_x86_64_link_hash_table
*htab
;
1741 bfd_boolean require_reloc_pc32
;
1743 bfd_boolean to_reloc_pc32
;
1746 bfd_signed_vma raddend
;
1747 unsigned int opcode
;
1749 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
1750 unsigned int r_symndx
;
1752 bfd_vma roff
= irel
->r_offset
;
1754 if (roff
< (r_type
== R_X86_64_REX_GOTPCRELX
? 3 : 2))
1757 raddend
= irel
->r_addend
;
1758 /* Addend for 32-bit PC-relative relocation must be -4. */
1762 htab
= elf_x86_64_hash_table (link_info
);
1763 is_pic
= bfd_link_pic (link_info
);
1765 relocx
= (r_type
== R_X86_64_GOTPCRELX
1766 || r_type
== R_X86_64_REX_GOTPCRELX
);
1768 /* TRUE if we can convert only to R_X86_64_PC32. Enable it for
1771 = link_info
->disable_target_specific_optimizations
> 1;
1773 r_symndx
= htab
->r_sym (irel
->r_info
);
1775 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
1777 /* Convert mov to lea since it has been done for a while. */
1780 /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
1781 for call, jmp or one of adc, add, and, cmp, or, sbb, sub,
1782 test, xor instructions. */
1787 /* We convert only to R_X86_64_PC32:
1789 2. R_X86_64_GOTPCREL since we can't modify REX byte.
1790 3. require_reloc_pc32 is true.
1793 to_reloc_pc32
= (opcode
== 0xff
1795 || require_reloc_pc32
1798 /* Get the symbol referred to by the reloc. */
1801 Elf_Internal_Sym
*isym
1802 = bfd_sym_from_r_symndx (&htab
->sym_cache
, abfd
, r_symndx
);
1804 /* Skip relocation against undefined symbols. */
1805 if (isym
->st_shndx
== SHN_UNDEF
)
1808 symtype
= ELF_ST_TYPE (isym
->st_info
);
1810 if (isym
->st_shndx
== SHN_ABS
)
1811 tsec
= bfd_abs_section_ptr
;
1812 else if (isym
->st_shndx
== SHN_COMMON
)
1813 tsec
= bfd_com_section_ptr
;
1814 else if (isym
->st_shndx
== SHN_X86_64_LCOMMON
)
1815 tsec
= &_bfd_elf_large_com_section
;
1817 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1819 toff
= isym
->st_value
;
1823 /* Undefined weak symbol is only bound locally in executable
1824 and its reference is resolved as 0 without relocation
1825 overflow. We can only perform this optimization for
1826 GOTPCRELX relocations since we need to modify REX byte.
1827 It is OK convert mov with R_X86_64_GOTPCREL to
1829 if ((relocx
|| opcode
== 0x8b)
1830 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
,
1832 elf_x86_64_hash_entry (h
)))
1836 /* Skip for branch instructions since R_X86_64_PC32
1838 if (require_reloc_pc32
)
1843 /* For non-branch instructions, we can convert to
1844 R_X86_64_32/R_X86_64_32S since we know if there
1846 to_reloc_pc32
= FALSE
;
1849 /* Since we don't know the current PC when PIC is true,
1850 we can't convert to R_X86_64_PC32. */
1851 if (to_reloc_pc32
&& is_pic
)
1856 /* Avoid optimizing GOTPCREL relocations againt _DYNAMIC since
1857 ld.so may use its link-time address. */
1858 else if ((h
->def_regular
1859 || h
->root
.type
== bfd_link_hash_defined
1860 || h
->root
.type
== bfd_link_hash_defweak
)
1861 && h
!= htab
->elf
.hdynamic
1862 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
1864 /* bfd_link_hash_new or bfd_link_hash_undefined is
1865 set by an assignment in a linker script in
1866 bfd_elf_record_link_assignment. */
1868 && (h
->root
.type
== bfd_link_hash_new
1869 || h
->root
.type
== bfd_link_hash_undefined
))
1871 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */
1872 if (require_reloc_pc32
)
1876 tsec
= h
->root
.u
.def
.section
;
1877 toff
= h
->root
.u
.def
.value
;
1884 /* Don't convert GOTPCREL relocation against large section. */
1885 if (elf_section_data (tsec
) != NULL
1886 && (elf_section_flags (tsec
) & SHF_X86_64_LARGE
) != 0)
1889 /* We can only estimate relocation overflow for R_X86_64_PC32. */
1893 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
1895 /* At this stage in linking, no SEC_MERGE symbol has been
1896 adjusted, so all references to such symbols need to be
1897 passed through _bfd_merged_section_offset. (Later, in
1898 relocate_section, all SEC_MERGE symbols *except* for
1899 section symbols have been adjusted.)
1901 gas may reduce relocations against symbols in SEC_MERGE
1902 sections to a relocation against the section symbol when
1903 the original addend was zero. When the reloc is against
1904 a section symbol we should include the addend in the
1905 offset passed to _bfd_merged_section_offset, since the
1906 location of interest is the original symbol. On the
1907 other hand, an access to "sym+addend" where "sym" is not
1908 a section symbol should not include the addend; Such an
1909 access is presumed to be an offset from "sym"; The
1910 location of interest is just "sym". */
1911 if (symtype
== STT_SECTION
)
1914 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
1915 elf_section_data (tsec
)->sec_info
,
1918 if (symtype
!= STT_SECTION
)
1924 /* Don't convert if R_X86_64_PC32 relocation overflows. */
1925 if (tsec
->output_section
== sec
->output_section
)
1927 if ((toff
- roff
+ 0x80000000) > 0xffffffff)
1932 bfd_signed_vma distance
;
1934 /* At this point, we don't know the load addresses of TSEC
1935 section nor SEC section. We estimate the distrance between
1936 SEC and TSEC. We store the estimated distances in the
1937 compressed_size field of the output section, which is only
1938 used to decompress the compressed input section. */
1939 if (sec
->output_section
->compressed_size
== 0)
1942 bfd_size_type size
= 0;
1943 for (asect
= link_info
->output_bfd
->sections
;
1945 asect
= asect
->next
)
1946 /* Skip debug sections since compressed_size is used to
1947 compress debug sections. */
1948 if ((asect
->flags
& SEC_DEBUGGING
) == 0)
1951 for (i
= asect
->map_head
.s
;
1955 size
= align_power (size
, i
->alignment_power
);
1958 asect
->compressed_size
= size
;
1962 /* Don't convert GOTPCREL relocations if TSEC isn't placed
1964 distance
= (tsec
->output_section
->compressed_size
1965 - sec
->output_section
->compressed_size
);
1969 /* Take PT_GNU_RELRO segment into account by adding
1971 if ((toff
+ distance
+ get_elf_backend_data (abfd
)->maxpagesize
1972 - roff
+ 0x80000000) > 0xffffffff)
1979 /* We have "call/jmp *foo@GOTPCREL(%rip)". */
1984 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
1986 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
1989 /* Convert to "jmp foo nop". */
1992 nop_offset
= irel
->r_offset
+ 3;
1993 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
1994 irel
->r_offset
-= 1;
1995 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
1999 struct elf_x86_64_link_hash_entry
*eh
2000 = (struct elf_x86_64_link_hash_entry
*) h
;
2002 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
2005 /* To support TLS optimization, always use addr32 prefix for
2006 "call *__tls_get_addr@GOTPCREL(%rip)". */
2007 if (eh
&& eh
->tls_get_addr
== 1)
2010 nop_offset
= irel
->r_offset
- 2;
2014 nop
= link_info
->call_nop_byte
;
2015 if (link_info
->call_nop_as_suffix
)
2017 nop_offset
= irel
->r_offset
+ 3;
2018 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
2019 irel
->r_offset
-= 1;
2020 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
2023 nop_offset
= irel
->r_offset
- 2;
2026 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
2027 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
2028 r_type
= R_X86_64_PC32
;
2033 unsigned int rex_mask
= REX_R
;
2035 if (r_type
== R_X86_64_REX_GOTPCRELX
)
2036 rex
= bfd_get_8 (abfd
, contents
+ roff
- 3);
2044 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
2045 "lea foo(%rip), %reg". */
2047 r_type
= R_X86_64_PC32
;
2051 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
2052 "mov $foo, %reg". */
2054 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2055 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
2056 if ((rex
& REX_W
) != 0
2057 && ABI_64_P (link_info
->output_bfd
))
2059 /* Keep the REX_W bit in REX byte for LP64. */
2060 r_type
= R_X86_64_32S
;
2061 goto rewrite_modrm_rex
;
2065 /* If the REX_W bit in REX byte isn't needed,
2066 use R_X86_64_32 and clear the W bit to avoid
2067 sign-extend imm32 to imm64. */
2068 r_type
= R_X86_64_32
;
2069 /* Clear the W bit in REX byte. */
2071 goto rewrite_modrm_rex
;
2077 /* R_X86_64_PC32 isn't supported. */
2081 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2084 /* Convert "test %reg, foo@GOTPCREL(%rip)" to
2085 "test $foo, %reg". */
2086 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
2091 /* Convert "binop foo@GOTPCREL(%rip), %reg" to
2092 "binop $foo, %reg". */
2093 modrm
= 0xc0 | (modrm
& 0x38) >> 3 | (opcode
& 0x3c);
2097 /* Use R_X86_64_32 with 32-bit operand to avoid relocation
2098 overflow when sign-extending imm32 to imm64. */
2099 r_type
= (rex
& REX_W
) != 0 ? R_X86_64_32S
: R_X86_64_32
;
2102 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
2106 /* Move the R bit to the B bit in REX byte. */
2107 rex
= (rex
& ~rex_mask
) | (rex
& REX_R
) >> 2;
2108 bfd_put_8 (abfd
, rex
, contents
+ roff
- 3);
2111 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */
2115 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
2118 irel
->r_info
= htab
->r_info (r_symndx
, r_type
);
2125 /* Look through the relocs for a section during the first phase, and
2126 calculate needed space in the global offset table, procedure
2127 linkage table, and dynamic reloc sections. */
2130 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
2132 const Elf_Internal_Rela
*relocs
)
2134 struct elf_x86_64_link_hash_table
*htab
;
2135 Elf_Internal_Shdr
*symtab_hdr
;
2136 struct elf_link_hash_entry
**sym_hashes
;
2137 const Elf_Internal_Rela
*rel
;
2138 const Elf_Internal_Rela
*rel_end
;
2141 bfd_boolean use_plt_got
;
2143 if (bfd_link_relocatable (info
))
2146 BFD_ASSERT (is_x86_64_elf (abfd
));
2148 htab
= elf_x86_64_hash_table (info
);
2151 sec
->check_relocs_failed
= 1;
2155 /* Get the section contents. */
2156 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2157 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2158 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2160 sec
->check_relocs_failed
= 1;
2164 use_plt_got
= get_elf_x86_64_backend_data (abfd
) == &elf_x86_64_arch_bed
;
2166 symtab_hdr
= &elf_symtab_hdr (abfd
);
2167 sym_hashes
= elf_sym_hashes (abfd
);
2171 rel_end
= relocs
+ sec
->reloc_count
;
2172 for (rel
= relocs
; rel
< rel_end
; rel
++)
2174 unsigned int r_type
;
2175 unsigned long r_symndx
;
2176 struct elf_link_hash_entry
*h
;
2177 struct elf_x86_64_link_hash_entry
*eh
;
2178 Elf_Internal_Sym
*isym
;
2180 bfd_boolean size_reloc
;
2182 r_symndx
= htab
->r_sym (rel
->r_info
);
2183 r_type
= ELF32_R_TYPE (rel
->r_info
);
2185 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
2187 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
2192 if (r_symndx
< symtab_hdr
->sh_info
)
2194 /* A local symbol. */
2195 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2200 /* Check relocation against local STT_GNU_IFUNC symbol. */
2201 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
2203 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
2208 /* Fake a STT_GNU_IFUNC symbol. */
2209 h
->type
= STT_GNU_IFUNC
;
2212 h
->forced_local
= 1;
2213 h
->root
.type
= bfd_link_hash_defined
;
2221 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2222 while (h
->root
.type
== bfd_link_hash_indirect
2223 || h
->root
.type
== bfd_link_hash_warning
)
2224 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2227 /* Check invalid x32 relocations. */
2228 if (!ABI_64_P (abfd
))
2234 case R_X86_64_DTPOFF64
:
2235 case R_X86_64_TPOFF64
:
2237 case R_X86_64_GOTOFF64
:
2238 case R_X86_64_GOT64
:
2239 case R_X86_64_GOTPCREL64
:
2240 case R_X86_64_GOTPC64
:
2241 case R_X86_64_GOTPLT64
:
2242 case R_X86_64_PLTOFF64
:
2245 name
= h
->root
.root
.string
;
2247 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
2249 (*_bfd_error_handler
)
2250 (_("%B: relocation %s against symbol `%s' isn't "
2251 "supported in x32 mode"), abfd
,
2252 x86_64_elf_howto_table
[r_type
].name
, name
);
2253 bfd_set_error (bfd_error_bad_value
);
2266 case R_X86_64_PC32_BND
:
2267 case R_X86_64_PLT32_BND
:
2269 case R_X86_64_PLT32
:
2272 /* MPX PLT is supported only if elf_x86_64_arch_bed
2273 is used in 64-bit mode. */
2276 && (get_elf_x86_64_backend_data (abfd
)
2277 == &elf_x86_64_arch_bed
))
2279 elf_x86_64_hash_entry (h
)->has_bnd_reloc
= 1;
2281 /* Create the second PLT for Intel MPX support. */
2282 if (htab
->plt_bnd
== NULL
)
2284 unsigned int plt_bnd_align
;
2285 const struct elf_backend_data
*bed
;
2287 bed
= get_elf_backend_data (info
->output_bfd
);
2288 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry
) == 8
2289 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2290 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2293 if (htab
->elf
.dynobj
== NULL
)
2294 htab
->elf
.dynobj
= abfd
;
2296 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2298 (bed
->dynamic_sec_flags
2303 if (htab
->plt_bnd
== NULL
2304 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2313 case R_X86_64_GOTPCREL
:
2314 case R_X86_64_GOTPCRELX
:
2315 case R_X86_64_REX_GOTPCRELX
:
2316 case R_X86_64_GOTPCREL64
:
2317 if (htab
->elf
.dynobj
== NULL
)
2318 htab
->elf
.dynobj
= abfd
;
2319 /* Create the ifunc sections for static executables. */
2320 if (h
->type
== STT_GNU_IFUNC
2321 && !_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
,
2327 /* It is referenced by a non-shared object. */
2329 h
->root
.non_ir_ref
= 1;
2331 if (h
->type
== STT_GNU_IFUNC
)
2332 elf_tdata (info
->output_bfd
)->has_gnu_symbols
2333 |= elf_gnu_symbol_ifunc
;
2336 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, contents
,
2337 symtab_hdr
, sym_hashes
,
2338 &r_type
, GOT_UNKNOWN
,
2339 rel
, rel_end
, h
, r_symndx
, FALSE
))
2342 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2345 case R_X86_64_TLSLD
:
2346 htab
->tls_ld_got
.refcount
+= 1;
2349 case R_X86_64_TPOFF32
:
2350 if (!bfd_link_executable (info
) && ABI_64_P (abfd
))
2351 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
2352 &x86_64_elf_howto_table
[r_type
]);
2354 eh
->has_got_reloc
= 1;
2357 case R_X86_64_GOTTPOFF
:
2358 if (!bfd_link_executable (info
))
2359 info
->flags
|= DF_STATIC_TLS
;
2362 case R_X86_64_GOT32
:
2363 case R_X86_64_GOTPCREL
:
2364 case R_X86_64_GOTPCRELX
:
2365 case R_X86_64_REX_GOTPCRELX
:
2366 case R_X86_64_TLSGD
:
2367 case R_X86_64_GOT64
:
2368 case R_X86_64_GOTPCREL64
:
2369 case R_X86_64_GOTPLT64
:
2370 case R_X86_64_GOTPC32_TLSDESC
:
2371 case R_X86_64_TLSDESC_CALL
:
2372 /* This symbol requires a global offset table entry. */
2374 int tls_type
, old_tls_type
;
2378 default: tls_type
= GOT_NORMAL
; break;
2379 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
2380 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
2381 case R_X86_64_GOTPC32_TLSDESC
:
2382 case R_X86_64_TLSDESC_CALL
:
2383 tls_type
= GOT_TLS_GDESC
; break;
2388 h
->got
.refcount
+= 1;
2389 old_tls_type
= eh
->tls_type
;
2393 bfd_signed_vma
*local_got_refcounts
;
2395 /* This is a global offset table entry for a local symbol. */
2396 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2397 if (local_got_refcounts
== NULL
)
2401 size
= symtab_hdr
->sh_info
;
2402 size
*= sizeof (bfd_signed_vma
)
2403 + sizeof (bfd_vma
) + sizeof (char);
2404 local_got_refcounts
= ((bfd_signed_vma
*)
2405 bfd_zalloc (abfd
, size
));
2406 if (local_got_refcounts
== NULL
)
2408 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2409 elf_x86_64_local_tlsdesc_gotent (abfd
)
2410 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
2411 elf_x86_64_local_got_tls_type (abfd
)
2412 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
2414 local_got_refcounts
[r_symndx
] += 1;
2416 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
2419 /* If a TLS symbol is accessed using IE at least once,
2420 there is no point to use dynamic model for it. */
2421 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
2422 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
2423 || tls_type
!= GOT_TLS_IE
))
2425 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
2426 tls_type
= old_tls_type
;
2427 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
2428 && GOT_TLS_GD_ANY_P (tls_type
))
2429 tls_type
|= old_tls_type
;
2433 name
= h
->root
.root
.string
;
2435 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
2437 (*_bfd_error_handler
)
2438 (_("%B: '%s' accessed both as normal and thread local symbol"),
2440 bfd_set_error (bfd_error_bad_value
);
2445 if (old_tls_type
!= tls_type
)
2448 eh
->tls_type
= tls_type
;
2450 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
2455 case R_X86_64_GOTOFF64
:
2456 case R_X86_64_GOTPC32
:
2457 case R_X86_64_GOTPC64
:
2460 eh
->has_got_reloc
= 1;
2461 if (htab
->elf
.sgot
== NULL
)
2463 if (htab
->elf
.dynobj
== NULL
)
2464 htab
->elf
.dynobj
= abfd
;
2465 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
2471 case R_X86_64_PLT32
:
2472 case R_X86_64_PLT32_BND
:
2473 /* This symbol requires a procedure linkage table entry. We
2474 actually build the entry in adjust_dynamic_symbol,
2475 because this might be a case of linking PIC code which is
2476 never referenced by a dynamic object, in which case we
2477 don't need to generate a procedure linkage table entry
2480 /* If this is a local symbol, we resolve it directly without
2481 creating a procedure linkage table entry. */
2485 eh
->has_got_reloc
= 1;
2487 h
->plt
.refcount
+= 1;
2490 case R_X86_64_PLTOFF64
:
2491 /* This tries to form the 'address' of a function relative
2492 to GOT. For global symbols we need a PLT entry. */
2496 h
->plt
.refcount
+= 1;
2500 case R_X86_64_SIZE32
:
2501 case R_X86_64_SIZE64
:
2506 if (!ABI_64_P (abfd
))
2511 /* Check relocation overflow as these relocs may lead to
2512 run-time relocation overflow. Don't error out for
2513 sections we don't care about, such as debug sections or
2514 when relocation overflow check is disabled. */
2515 if (!info
->no_reloc_overflow_check
2516 && (bfd_link_pic (info
)
2517 || (bfd_link_executable (info
)
2521 && (sec
->flags
& SEC_READONLY
) == 0))
2522 && (sec
->flags
& SEC_ALLOC
) != 0)
2523 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
2524 &x86_64_elf_howto_table
[r_type
]);
2530 case R_X86_64_PC32_BND
:
2534 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2535 eh
->has_non_got_reloc
= 1;
2536 /* STT_GNU_IFUNC symbol must go through PLT even if it is
2537 locally defined and undefined symbol may turn out to be
2538 a STT_GNU_IFUNC symbol later. */
2540 && (bfd_link_executable (info
)
2541 || ((h
->type
== STT_GNU_IFUNC
2542 || h
->root
.type
== bfd_link_hash_undefweak
2543 || h
->root
.type
== bfd_link_hash_undefined
)
2544 && SYMBOLIC_BIND (info
, h
))))
2546 /* If this reloc is in a read-only section, we might
2547 need a copy reloc. We can't check reliably at this
2548 stage whether the section is read-only, as input
2549 sections have not yet been mapped to output sections.
2550 Tentatively set the flag for now, and correct in
2551 adjust_dynamic_symbol. */
2554 /* We may need a .plt entry if the function this reloc
2555 refers to is in a shared lib. */
2556 h
->plt
.refcount
+= 1;
2557 if (r_type
== R_X86_64_PC32
)
2559 /* Since something like ".long foo - ." may be used
2560 as pointer, make sure that PLT is used if foo is
2561 a function defined in a shared library. */
2562 if ((sec
->flags
& SEC_CODE
) == 0)
2563 h
->pointer_equality_needed
= 1;
2565 else if (r_type
!= R_X86_64_PC32_BND
2566 && r_type
!= R_X86_64_PC64
)
2568 h
->pointer_equality_needed
= 1;
2569 /* At run-time, R_X86_64_64 can be resolved for both
2570 x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2571 can only be resolved for x32. */
2572 if ((sec
->flags
& SEC_READONLY
) == 0
2573 && (r_type
== R_X86_64_64
2574 || (!ABI_64_P (abfd
)
2575 && (r_type
== R_X86_64_32
2576 || r_type
== R_X86_64_32S
))))
2577 eh
->func_pointer_refcount
+= 1;
2583 /* If we are creating a shared library, and this is a reloc
2584 against a global symbol, or a non PC relative reloc
2585 against a local symbol, then we need to copy the reloc
2586 into the shared library. However, if we are linking with
2587 -Bsymbolic, we do not need to copy a reloc against a
2588 global symbol which is defined in an object we are
2589 including in the link (i.e., DEF_REGULAR is set). At
2590 this point we have not seen all the input files, so it is
2591 possible that DEF_REGULAR is not set now but will be set
2592 later (it is never cleared). In case of a weak definition,
2593 DEF_REGULAR may be cleared later by a strong definition in
2594 a shared library. We account for that possibility below by
2595 storing information in the relocs_copied field of the hash
2596 table entry. A similar situation occurs when creating
2597 shared libraries and symbol visibility changes render the
2600 If on the other hand, we are creating an executable, we
2601 may need to keep relocations for symbols satisfied by a
2602 dynamic library if we manage to avoid copy relocs for the
2604 if ((sec
->flags
& SEC_ALLOC
) != 0
2605 && ((bfd_link_pic (info
)
2606 && (! IS_X86_64_PCREL_TYPE (r_type
)
2608 && (! (bfd_link_pie (info
)
2609 || SYMBOLIC_BIND (info
, h
))
2610 || h
->root
.type
== bfd_link_hash_defweak
2611 || !h
->def_regular
))))
2612 || (ELIMINATE_COPY_RELOCS
2613 && !bfd_link_pic (info
)
2615 && (h
->root
.type
== bfd_link_hash_defweak
2616 || !h
->def_regular
))))
2618 struct elf_dyn_relocs
*p
;
2619 struct elf_dyn_relocs
**head
;
2621 /* We must copy these reloc types into the output file.
2622 Create a reloc section in dynobj and make room for
2626 if (htab
->elf
.dynobj
== NULL
)
2627 htab
->elf
.dynobj
= abfd
;
2629 sreloc
= _bfd_elf_make_dynamic_reloc_section
2630 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
2631 abfd
, /*rela?*/ TRUE
);
2637 /* If this is a global symbol, we count the number of
2638 relocations we need for this symbol. */
2640 head
= &eh
->dyn_relocs
;
2643 /* Track dynamic relocs needed for local syms too.
2644 We really need local syms available to do this
2649 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2654 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2658 /* Beware of type punned pointers vs strict aliasing
2660 vpp
= &(elf_section_data (s
)->local_dynrel
);
2661 head
= (struct elf_dyn_relocs
**)vpp
;
2665 if (p
== NULL
|| p
->sec
!= sec
)
2667 bfd_size_type amt
= sizeof *p
;
2669 p
= ((struct elf_dyn_relocs
*)
2670 bfd_alloc (htab
->elf
.dynobj
, amt
));
2681 /* Count size relocation as PC-relative relocation. */
2682 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
2687 /* This relocation describes the C++ object vtable hierarchy.
2688 Reconstruct it for later use during GC. */
2689 case R_X86_64_GNU_VTINHERIT
:
2690 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2694 /* This relocation describes which C++ vtable entries are actually
2695 used. Record for later use during GC. */
2696 case R_X86_64_GNU_VTENTRY
:
2697 BFD_ASSERT (h
!= NULL
);
2699 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2709 && h
->plt
.refcount
> 0
2710 && (((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2711 || h
->got
.refcount
> 0)
2712 && htab
->plt_got
== NULL
)
2714 /* Create the GOT procedure linkage table. */
2715 unsigned int plt_got_align
;
2716 const struct elf_backend_data
*bed
;
2718 bed
= get_elf_backend_data (info
->output_bfd
);
2719 BFD_ASSERT (sizeof (elf_x86_64_legacy_plt2_entry
) == 8
2720 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2721 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2724 if (htab
->elf
.dynobj
== NULL
)
2725 htab
->elf
.dynobj
= abfd
;
2727 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2729 (bed
->dynamic_sec_flags
2734 if (htab
->plt_got
== NULL
2735 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2741 if ((r_type
== R_X86_64_GOTPCREL
2742 || r_type
== R_X86_64_GOTPCRELX
2743 || r_type
== R_X86_64_REX_GOTPCRELX
)
2744 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2745 sec
->need_convert_load
= 1;
2748 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2750 if (!info
->keep_memory
)
2754 /* Cache the section contents for elf_link_input_bfd. */
2755 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2762 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2764 sec
->check_relocs_failed
= 1;
2768 /* Return the section that should be marked against GC for a given
2772 elf_x86_64_gc_mark_hook (asection
*sec
,
2773 struct bfd_link_info
*info
,
2774 Elf_Internal_Rela
*rel
,
2775 struct elf_link_hash_entry
*h
,
2776 Elf_Internal_Sym
*sym
)
2779 switch (ELF32_R_TYPE (rel
->r_info
))
2781 case R_X86_64_GNU_VTINHERIT
:
2782 case R_X86_64_GNU_VTENTRY
:
2786 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2789 /* Remove undefined weak symbol from the dynamic symbol table if it
2790 is resolved to 0. */
2793 elf_x86_64_fixup_symbol (struct bfd_link_info
*info
,
2794 struct elf_link_hash_entry
*h
)
2796 if (h
->dynindx
!= -1
2797 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2798 elf_x86_64_hash_entry (h
)->has_got_reloc
,
2799 elf_x86_64_hash_entry (h
)))
2802 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2808 /* Adjust a symbol defined by a dynamic object and referenced by a
2809 regular object. The current definition is in some section of the
2810 dynamic object, but we're not including those sections. We have to
2811 change the definition to something the rest of the link can
2815 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2816 struct elf_link_hash_entry
*h
)
2818 struct elf_x86_64_link_hash_table
*htab
;
2820 struct elf_x86_64_link_hash_entry
*eh
;
2821 struct elf_dyn_relocs
*p
;
2823 /* STT_GNU_IFUNC symbol must go through PLT. */
2824 if (h
->type
== STT_GNU_IFUNC
)
2826 /* All local STT_GNU_IFUNC references must be treate as local
2827 calls via local PLT. */
2829 && SYMBOL_CALLS_LOCAL (info
, h
))
2831 bfd_size_type pc_count
= 0, count
= 0;
2832 struct elf_dyn_relocs
**pp
;
2834 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2835 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2837 pc_count
+= p
->pc_count
;
2838 p
->count
-= p
->pc_count
;
2847 if (pc_count
|| count
)
2851 if (h
->plt
.refcount
<= 0)
2852 h
->plt
.refcount
= 1;
2854 h
->plt
.refcount
+= 1;
2858 if (h
->plt
.refcount
<= 0)
2860 h
->plt
.offset
= (bfd_vma
) -1;
2866 /* If this is a function, put it in the procedure linkage table. We
2867 will fill in the contents of the procedure linkage table later,
2868 when we know the address of the .got section. */
2869 if (h
->type
== STT_FUNC
2872 if (h
->plt
.refcount
<= 0
2873 || SYMBOL_CALLS_LOCAL (info
, h
)
2874 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2875 && h
->root
.type
== bfd_link_hash_undefweak
))
2877 /* This case can occur if we saw a PLT32 reloc in an input
2878 file, but the symbol was never referred to by a dynamic
2879 object, or if all references were garbage collected. In
2880 such a case, we don't actually need to build a procedure
2881 linkage table, and we can just do a PC32 reloc instead. */
2882 h
->plt
.offset
= (bfd_vma
) -1;
2889 /* It's possible that we incorrectly decided a .plt reloc was
2890 needed for an R_X86_64_PC32 reloc to a non-function sym in
2891 check_relocs. We can't decide accurately between function and
2892 non-function syms in check-relocs; Objects loaded later in
2893 the link may change h->type. So fix it now. */
2894 h
->plt
.offset
= (bfd_vma
) -1;
2896 /* If this is a weak symbol, and there is a real definition, the
2897 processor independent code will have arranged for us to see the
2898 real definition first, and we can just use the same value. */
2899 if (h
->u
.weakdef
!= NULL
)
2901 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2902 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2903 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2904 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2905 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2907 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2908 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2909 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
2914 /* This is a reference to a symbol defined by a dynamic object which
2915 is not a function. */
2917 /* If we are creating a shared library, we must presume that the
2918 only references to the symbol are via the global offset table.
2919 For such cases we need not do anything here; the relocations will
2920 be handled correctly by relocate_section. */
2921 if (!bfd_link_executable (info
))
2924 /* If there are no references to this symbol that do not use the
2925 GOT, we don't need to generate a copy reloc. */
2926 if (!h
->non_got_ref
)
2929 /* If -z nocopyreloc was given, we won't generate them either. */
2930 if (info
->nocopyreloc
)
2936 if (ELIMINATE_COPY_RELOCS
)
2938 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2939 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2941 s
= p
->sec
->output_section
;
2942 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2946 /* If we didn't find any dynamic relocs in read-only sections, then
2947 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2955 /* We must allocate the symbol in our .dynbss section, which will
2956 become part of the .bss section of the executable. There will be
2957 an entry for this symbol in the .dynsym section. The dynamic
2958 object will contain position independent code, so all references
2959 from the dynamic object to this symbol will go through the global
2960 offset table. The dynamic linker will use the .dynsym entry to
2961 determine the address it must put in the global offset table, so
2962 both the dynamic object and the regular object will refer to the
2963 same memory location for the variable. */
2965 htab
= elf_x86_64_hash_table (info
);
2969 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2970 to copy the initial value out of the dynamic object and into the
2971 runtime process image. */
2972 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2974 const struct elf_backend_data
*bed
;
2975 bed
= get_elf_backend_data (info
->output_bfd
);
2976 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
2982 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2985 /* Allocate space in .plt, .got and associated reloc sections for
2989 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2991 struct bfd_link_info
*info
;
2992 struct elf_x86_64_link_hash_table
*htab
;
2993 struct elf_x86_64_link_hash_entry
*eh
;
2994 struct elf_dyn_relocs
*p
;
2995 const struct elf_backend_data
*bed
;
2996 unsigned int plt_entry_size
;
2997 bfd_boolean resolved_to_zero
;
2999 if (h
->root
.type
== bfd_link_hash_indirect
)
3002 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3004 info
= (struct bfd_link_info
*) inf
;
3005 htab
= elf_x86_64_hash_table (info
);
3008 bed
= get_elf_backend_data (info
->output_bfd
);
3009 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
3011 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
3015 /* We can't use the GOT PLT if pointer equality is needed since
3016 finish_dynamic_symbol won't clear symbol value and the dynamic
3017 linker won't update the GOT slot. We will get into an infinite
3018 loop at run-time. */
3019 if (htab
->plt_got
!= NULL
3020 && h
->type
!= STT_GNU_IFUNC
3021 && !h
->pointer_equality_needed
3022 && h
->plt
.refcount
> 0
3023 && h
->got
.refcount
> 0)
3025 /* Don't use the regular PLT if there are both GOT and GOTPLT
3027 h
->plt
.offset
= (bfd_vma
) -1;
3029 /* Use the GOT PLT. */
3030 eh
->plt_got
.refcount
= 1;
3033 /* Clear the reference count of function pointer relocations if
3034 symbol isn't a normal function. */
3035 if (h
->type
!= STT_FUNC
)
3036 eh
->func_pointer_refcount
= 0;
3038 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
3039 here if it is defined and referenced in a non-shared object. */
3040 if (h
->type
== STT_GNU_IFUNC
3043 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
3045 &htab
->readonly_dynrelocs_against_ifunc
,
3050 asection
*s
= htab
->plt_bnd
;
3051 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
3053 /* Use the .plt.bnd section if it is created. */
3054 eh
->plt_bnd
.offset
= s
->size
;
3056 /* Make room for this entry in the .plt.bnd section. */
3057 s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
3065 /* Don't create the PLT entry if there are only function pointer
3066 relocations which can be resolved at run-time. */
3067 else if (htab
->elf
.dynamic_sections_created
3068 && (h
->plt
.refcount
> eh
->func_pointer_refcount
3069 || eh
->plt_got
.refcount
> 0))
3071 bfd_boolean use_plt_got
;
3073 /* Clear the reference count of function pointer relocations
3075 eh
->func_pointer_refcount
= 0;
3077 if ((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
3079 /* Don't use the regular PLT for DF_BIND_NOW. */
3080 h
->plt
.offset
= (bfd_vma
) -1;
3082 /* Use the GOT PLT. */
3083 h
->got
.refcount
= 1;
3084 eh
->plt_got
.refcount
= 1;
3087 use_plt_got
= eh
->plt_got
.refcount
> 0;
3089 /* Make sure this symbol is output as a dynamic symbol.
3090 Undefined weak syms won't yet be marked as dynamic. */
3091 if (h
->dynindx
== -1
3093 && !resolved_to_zero
)
3095 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3099 if (bfd_link_pic (info
)
3100 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
3102 asection
*s
= htab
->elf
.splt
;
3103 asection
*bnd_s
= htab
->plt_bnd
;
3104 asection
*got_s
= htab
->plt_got
;
3106 /* If this is the first .plt entry, make room for the special
3107 first entry. The .plt section is used by prelink to undo
3108 prelinking for dynamic relocations. */
3110 s
->size
= plt_entry_size
;
3113 eh
->plt_got
.offset
= got_s
->size
;
3116 h
->plt
.offset
= s
->size
;
3118 eh
->plt_bnd
.offset
= bnd_s
->size
;
3121 /* If this symbol is not defined in a regular file, and we are
3122 not generating a shared library, then set the symbol to this
3123 location in the .plt. This is required to make function
3124 pointers compare as equal between the normal executable and
3125 the shared library. */
3126 if (! bfd_link_pic (info
)
3131 /* We need to make a call to the entry of the GOT PLT
3132 instead of regular PLT entry. */
3133 h
->root
.u
.def
.section
= got_s
;
3134 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
3140 /* We need to make a call to the entry of the second
3141 PLT instead of regular PLT entry. */
3142 h
->root
.u
.def
.section
= bnd_s
;
3143 h
->root
.u
.def
.value
= eh
->plt_bnd
.offset
;
3147 h
->root
.u
.def
.section
= s
;
3148 h
->root
.u
.def
.value
= h
->plt
.offset
;
3153 /* Make room for this entry. */
3155 got_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
3158 s
->size
+= plt_entry_size
;
3160 bnd_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
3162 /* We also need to make an entry in the .got.plt section,
3163 which will be placed in the .got section by the linker
3165 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
3167 /* There should be no PLT relocation against resolved
3168 undefined weak symbol in executable. */
3169 if (!resolved_to_zero
)
3171 /* We also need to make an entry in the .rela.plt
3173 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
3174 htab
->elf
.srelplt
->reloc_count
++;
3180 eh
->plt_got
.offset
= (bfd_vma
) -1;
3181 h
->plt
.offset
= (bfd_vma
) -1;
3187 eh
->plt_got
.offset
= (bfd_vma
) -1;
3188 h
->plt
.offset
= (bfd_vma
) -1;
3192 eh
->tlsdesc_got
= (bfd_vma
) -1;
3194 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
3195 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
3196 if (h
->got
.refcount
> 0
3197 && bfd_link_executable (info
)
3199 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
3201 h
->got
.offset
= (bfd_vma
) -1;
3203 else if (h
->got
.refcount
> 0)
3207 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
3209 /* Make sure this symbol is output as a dynamic symbol.
3210 Undefined weak syms won't yet be marked as dynamic. */
3211 if (h
->dynindx
== -1
3213 && !resolved_to_zero
)
3215 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3219 if (GOT_TLS_GDESC_P (tls_type
))
3221 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
3222 - elf_x86_64_compute_jump_table_size (htab
);
3223 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3224 h
->got
.offset
= (bfd_vma
) -2;
3226 if (! GOT_TLS_GDESC_P (tls_type
)
3227 || GOT_TLS_GD_P (tls_type
))
3230 h
->got
.offset
= s
->size
;
3231 s
->size
+= GOT_ENTRY_SIZE
;
3232 if (GOT_TLS_GD_P (tls_type
))
3233 s
->size
+= GOT_ENTRY_SIZE
;
3235 dyn
= htab
->elf
.dynamic_sections_created
;
3236 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
3237 and two if global. R_X86_64_GOTTPOFF needs one dynamic
3238 relocation. No dynamic relocation against resolved undefined
3239 weak symbol in executable. */
3240 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
3241 || tls_type
== GOT_TLS_IE
)
3242 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3243 else if (GOT_TLS_GD_P (tls_type
))
3244 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
3245 else if (! GOT_TLS_GDESC_P (tls_type
)
3246 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3247 && !resolved_to_zero
)
3248 || h
->root
.type
!= bfd_link_hash_undefweak
)
3249 && (bfd_link_pic (info
)
3250 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
3251 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3252 if (GOT_TLS_GDESC_P (tls_type
))
3254 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
3255 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3259 h
->got
.offset
= (bfd_vma
) -1;
3261 if (eh
->dyn_relocs
== NULL
)
3264 /* In the shared -Bsymbolic case, discard space allocated for
3265 dynamic pc-relative relocs against symbols which turn out to be
3266 defined in regular objects. For the normal shared case, discard
3267 space for pc-relative relocs that have become local due to symbol
3268 visibility changes. */
3270 if (bfd_link_pic (info
))
3272 /* Relocs that use pc_count are those that appear on a call
3273 insn, or certain REL relocs that can generated via assembly.
3274 We want calls to protected symbols to resolve directly to the
3275 function rather than going via the plt. If people want
3276 function pointer comparisons to work as expected then they
3277 should avoid writing weird assembly. */
3278 if (SYMBOL_CALLS_LOCAL (info
, h
))
3280 struct elf_dyn_relocs
**pp
;
3282 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3284 p
->count
-= p
->pc_count
;
3293 /* Also discard relocs on undefined weak syms with non-default
3294 visibility or in PIE. */
3295 if (eh
->dyn_relocs
!= NULL
)
3297 if (h
->root
.type
== bfd_link_hash_undefweak
)
3299 /* Undefined weak symbol is never bound locally in shared
3301 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3302 || resolved_to_zero
)
3303 eh
->dyn_relocs
= NULL
;
3304 else if (h
->dynindx
== -1
3305 && ! h
->forced_local
3306 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3309 /* For PIE, discard space for pc-relative relocs against
3310 symbols which turn out to need copy relocs. */
3311 else if (bfd_link_executable (info
)
3312 && (h
->needs_copy
|| eh
->needs_copy
)
3316 struct elf_dyn_relocs
**pp
;
3318 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3320 if (p
->pc_count
!= 0)
3328 else if (ELIMINATE_COPY_RELOCS
)
3330 /* For the non-shared case, discard space for relocs against
3331 symbols which turn out to need copy relocs or are not
3332 dynamic. Keep dynamic relocations for run-time function
3333 pointer initialization. */
3335 if ((!h
->non_got_ref
3336 || eh
->func_pointer_refcount
> 0
3337 || (h
->root
.type
== bfd_link_hash_undefweak
3338 && !resolved_to_zero
))
3341 || (htab
->elf
.dynamic_sections_created
3342 && (h
->root
.type
== bfd_link_hash_undefweak
3343 || h
->root
.type
== bfd_link_hash_undefined
))))
3345 /* Make sure this symbol is output as a dynamic symbol.
3346 Undefined weak syms won't yet be marked as dynamic. */
3347 if (h
->dynindx
== -1
3348 && ! h
->forced_local
3349 && ! resolved_to_zero
3350 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3353 /* If that succeeded, we know we'll be keeping all the
3355 if (h
->dynindx
!= -1)
3359 eh
->dyn_relocs
= NULL
;
3360 eh
->func_pointer_refcount
= 0;
3365 /* Finally, allocate space. */
3366 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3370 sreloc
= elf_section_data (p
->sec
)->sreloc
;
3372 BFD_ASSERT (sreloc
!= NULL
);
3374 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3380 /* Allocate space in .plt, .got and associated reloc sections for
3381 local dynamic relocs. */
3384 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
3386 struct elf_link_hash_entry
*h
3387 = (struct elf_link_hash_entry
*) *slot
;
3389 if (h
->type
!= STT_GNU_IFUNC
3393 || h
->root
.type
!= bfd_link_hash_defined
)
3396 return elf_x86_64_allocate_dynrelocs (h
, inf
);
3399 /* Find any dynamic relocs that apply to read-only sections. */
3402 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
3405 struct elf_x86_64_link_hash_entry
*eh
;
3406 struct elf_dyn_relocs
*p
;
3408 /* Skip local IFUNC symbols. */
3409 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
3412 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3413 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3415 asection
*s
= p
->sec
->output_section
;
3417 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
3419 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3421 info
->flags
|= DF_TEXTREL
;
3423 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3424 || info
->error_textrel
)
3425 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
3426 p
->sec
->owner
, h
->root
.root
.string
,
3429 /* Not an error, just cut short the traversal. */
3436 /* Convert load via the GOT slot to load immediate. */
3439 elf_x86_64_convert_load (bfd
*abfd
, asection
*sec
,
3440 struct bfd_link_info
*link_info
)
3442 Elf_Internal_Shdr
*symtab_hdr
;
3443 Elf_Internal_Rela
*internal_relocs
;
3444 Elf_Internal_Rela
*irel
, *irelend
;
3446 struct elf_x86_64_link_hash_table
*htab
;
3447 bfd_boolean changed
;
3448 bfd_signed_vma
*local_got_refcounts
;
3450 /* Don't even try to convert non-ELF outputs. */
3451 if (!is_elf_hash_table (link_info
->hash
))
3454 /* Nothing to do if there is no need or no output. */
3455 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
3456 || sec
->need_convert_load
== 0
3457 || bfd_is_abs_section (sec
->output_section
))
3460 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3462 /* Load the relocations for this section. */
3463 internal_relocs
= (_bfd_elf_link_read_relocs
3464 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
3465 link_info
->keep_memory
));
3466 if (internal_relocs
== NULL
)
3470 htab
= elf_x86_64_hash_table (link_info
);
3471 local_got_refcounts
= elf_local_got_refcounts (abfd
);
3473 /* Get the section contents. */
3474 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
3475 contents
= elf_section_data (sec
)->this_hdr
.contents
;
3478 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
3482 irelend
= internal_relocs
+ sec
->reloc_count
;
3483 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3485 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
3486 unsigned int r_symndx
;
3487 struct elf_link_hash_entry
*h
;
3488 bfd_boolean converted
;
3490 if (r_type
!= R_X86_64_GOTPCRELX
3491 && r_type
!= R_X86_64_REX_GOTPCRELX
3492 && r_type
!= R_X86_64_GOTPCREL
)
3495 r_symndx
= htab
->r_sym (irel
->r_info
);
3496 if (r_symndx
< symtab_hdr
->sh_info
)
3497 h
= elf_x86_64_get_local_sym_hash (htab
, sec
->owner
,
3498 (const Elf_Internal_Rela
*) irel
,
3502 h
= elf_sym_hashes (abfd
)[r_symndx
- symtab_hdr
->sh_info
];
3503 while (h
->root
.type
== bfd_link_hash_indirect
3504 || h
->root
.type
== bfd_link_hash_warning
)
3505 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3508 /* STT_GNU_IFUNC must keep GOTPCREL relocations. */
3509 if (h
!= NULL
&& h
->type
== STT_GNU_IFUNC
)
3513 if (!elf_x86_64_convert_load_reloc (abfd
, sec
, contents
, irel
, h
,
3514 &converted
, link_info
))
3519 changed
= converted
;
3522 if (h
->got
.refcount
> 0)
3523 h
->got
.refcount
-= 1;
3527 if (local_got_refcounts
!= NULL
3528 && local_got_refcounts
[r_symndx
] > 0)
3529 local_got_refcounts
[r_symndx
] -= 1;
3534 if (contents
!= NULL
3535 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3537 if (!changed
&& !link_info
->keep_memory
)
3541 /* Cache the section contents for elf_link_input_bfd. */
3542 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3546 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3549 free (internal_relocs
);
3551 elf_section_data (sec
)->relocs
= internal_relocs
;
3557 if (contents
!= NULL
3558 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3560 if (internal_relocs
!= NULL
3561 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3562 free (internal_relocs
);
3566 /* Set the sizes of the dynamic sections. */
3569 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
3570 struct bfd_link_info
*info
)
3572 struct elf_x86_64_link_hash_table
*htab
;
3577 const struct elf_backend_data
*bed
;
3579 htab
= elf_x86_64_hash_table (info
);
3582 bed
= get_elf_backend_data (output_bfd
);
3584 dynobj
= htab
->elf
.dynobj
;
3588 /* Set up .got offsets for local syms, and space for local dynamic
3590 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3592 bfd_signed_vma
*local_got
;
3593 bfd_signed_vma
*end_local_got
;
3594 char *local_tls_type
;
3595 bfd_vma
*local_tlsdesc_gotent
;
3596 bfd_size_type locsymcount
;
3597 Elf_Internal_Shdr
*symtab_hdr
;
3600 if (! is_x86_64_elf (ibfd
))
3603 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3605 struct elf_dyn_relocs
*p
;
3607 if (!elf_x86_64_convert_load (ibfd
, s
, info
))
3610 for (p
= (struct elf_dyn_relocs
*)
3611 (elf_section_data (s
)->local_dynrel
);
3615 if (!bfd_is_abs_section (p
->sec
)
3616 && bfd_is_abs_section (p
->sec
->output_section
))
3618 /* Input section has been discarded, either because
3619 it is a copy of a linkonce section or due to
3620 linker script /DISCARD/, so we'll be discarding
3623 else if (p
->count
!= 0)
3625 srel
= elf_section_data (p
->sec
)->sreloc
;
3626 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3627 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3628 && (info
->flags
& DF_TEXTREL
) == 0)
3630 info
->flags
|= DF_TEXTREL
;
3631 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3632 || info
->error_textrel
)
3633 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3634 p
->sec
->owner
, p
->sec
);
3640 local_got
= elf_local_got_refcounts (ibfd
);
3644 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3645 locsymcount
= symtab_hdr
->sh_info
;
3646 end_local_got
= local_got
+ locsymcount
;
3647 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
3648 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
3650 srel
= htab
->elf
.srelgot
;
3651 for (; local_got
< end_local_got
;
3652 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3654 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3657 if (GOT_TLS_GDESC_P (*local_tls_type
))
3659 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3660 - elf_x86_64_compute_jump_table_size (htab
);
3661 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3662 *local_got
= (bfd_vma
) -2;
3664 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3665 || GOT_TLS_GD_P (*local_tls_type
))
3667 *local_got
= s
->size
;
3668 s
->size
+= GOT_ENTRY_SIZE
;
3669 if (GOT_TLS_GD_P (*local_tls_type
))
3670 s
->size
+= GOT_ENTRY_SIZE
;
3672 if (bfd_link_pic (info
)
3673 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3674 || *local_tls_type
== GOT_TLS_IE
)
3676 if (GOT_TLS_GDESC_P (*local_tls_type
))
3678 htab
->elf
.srelplt
->size
3679 += bed
->s
->sizeof_rela
;
3680 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3682 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3683 || GOT_TLS_GD_P (*local_tls_type
))
3684 srel
->size
+= bed
->s
->sizeof_rela
;
3688 *local_got
= (bfd_vma
) -1;
3692 if (htab
->tls_ld_got
.refcount
> 0)
3694 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3696 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
3697 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
3698 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3701 htab
->tls_ld_got
.offset
= -1;
3703 /* Allocate global sym .plt and .got entries, and space for global
3704 sym dynamic relocs. */
3705 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
3708 /* Allocate .plt and .got entries, and space for local symbols. */
3709 htab_traverse (htab
->loc_hash_table
,
3710 elf_x86_64_allocate_local_dynrelocs
,
3713 /* For every jump slot reserved in the sgotplt, reloc_count is
3714 incremented. However, when we reserve space for TLS descriptors,
3715 it's not incremented, so in order to compute the space reserved
3716 for them, it suffices to multiply the reloc count by the jump
3719 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3720 so that R_X86_64_IRELATIVE entries come last. */
3721 if (htab
->elf
.srelplt
)
3723 htab
->sgotplt_jump_table_size
3724 = elf_x86_64_compute_jump_table_size (htab
);
3725 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3727 else if (htab
->elf
.irelplt
)
3728 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3730 if (htab
->tlsdesc_plt
)
3732 /* If we're not using lazy TLS relocations, don't generate the
3733 PLT and GOT entries they require. */
3734 if ((info
->flags
& DF_BIND_NOW
))
3735 htab
->tlsdesc_plt
= 0;
3738 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
3739 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
3740 /* Reserve room for the initial entry.
3741 FIXME: we could probably do away with it in this case. */
3742 if (htab
->elf
.splt
->size
== 0)
3743 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3744 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
3745 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3749 if (htab
->elf
.sgotplt
)
3751 /* Don't allocate .got.plt section if there are no GOT nor PLT
3752 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3753 if ((htab
->elf
.hgot
== NULL
3754 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3755 && (htab
->elf
.sgotplt
->size
3756 == get_elf_backend_data (output_bfd
)->got_header_size
)
3757 && (htab
->elf
.splt
== NULL
3758 || htab
->elf
.splt
->size
== 0)
3759 && (htab
->elf
.sgot
== NULL
3760 || htab
->elf
.sgot
->size
== 0)
3761 && (htab
->elf
.iplt
== NULL
3762 || htab
->elf
.iplt
->size
== 0)
3763 && (htab
->elf
.igotplt
== NULL
3764 || htab
->elf
.igotplt
->size
== 0))
3765 htab
->elf
.sgotplt
->size
= 0;
3768 if (htab
->plt_eh_frame
!= NULL
3769 && htab
->elf
.splt
!= NULL
3770 && htab
->elf
.splt
->size
!= 0
3771 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3772 && _bfd_elf_eh_frame_present (info
))
3774 const struct elf_x86_64_backend_data
*arch_data
3775 = get_elf_x86_64_arch_data (bed
);
3776 htab
->plt_eh_frame
->size
= arch_data
->eh_frame_plt_size
;
3779 /* We now have determined the sizes of the various dynamic sections.
3780 Allocate memory for them. */
3782 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3784 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3787 if (s
== htab
->elf
.splt
3788 || s
== htab
->elf
.sgot
3789 || s
== htab
->elf
.sgotplt
3790 || s
== htab
->elf
.iplt
3791 || s
== htab
->elf
.igotplt
3792 || s
== htab
->plt_bnd
3793 || s
== htab
->plt_got
3794 || s
== htab
->plt_eh_frame
3795 || s
== htab
->sdynbss
)
3797 /* Strip this section if we don't need it; see the
3800 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3802 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
3805 /* We use the reloc_count field as a counter if we need
3806 to copy relocs into the output file. */
3807 if (s
!= htab
->elf
.srelplt
)
3812 /* It's not one of our sections, so don't allocate space. */
3818 /* If we don't need this section, strip it from the
3819 output file. This is mostly to handle .rela.bss and
3820 .rela.plt. We must create both sections in
3821 create_dynamic_sections, because they must be created
3822 before the linker maps input sections to output
3823 sections. The linker does that before
3824 adjust_dynamic_symbol is called, and it is that
3825 function which decides whether anything needs to go
3826 into these sections. */
3828 s
->flags
|= SEC_EXCLUDE
;
3832 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3835 /* Allocate memory for the section contents. We use bfd_zalloc
3836 here in case unused entries are not reclaimed before the
3837 section's contents are written out. This should not happen,
3838 but this way if it does, we get a R_X86_64_NONE reloc instead
3840 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3841 if (s
->contents
== NULL
)
3845 if (htab
->plt_eh_frame
!= NULL
3846 && htab
->plt_eh_frame
->contents
!= NULL
)
3848 const struct elf_x86_64_backend_data
*arch_data
3849 = get_elf_x86_64_arch_data (bed
);
3851 memcpy (htab
->plt_eh_frame
->contents
,
3852 arch_data
->eh_frame_plt
, htab
->plt_eh_frame
->size
);
3853 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3854 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3857 if (htab
->elf
.dynamic_sections_created
)
3859 /* Add some entries to the .dynamic section. We fill in the
3860 values later, in elf_x86_64_finish_dynamic_sections, but we
3861 must add the entries now so that we get the correct size for
3862 the .dynamic section. The DT_DEBUG entry is filled in by the
3863 dynamic linker and used by the debugger. */
3864 #define add_dynamic_entry(TAG, VAL) \
3865 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3867 if (bfd_link_executable (info
))
3869 if (!add_dynamic_entry (DT_DEBUG
, 0))
3873 if (htab
->elf
.splt
->size
!= 0)
3875 /* DT_PLTGOT is used by prelink even if there is no PLT
3877 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3880 if (htab
->elf
.srelplt
->size
!= 0)
3882 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3883 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3884 || !add_dynamic_entry (DT_JMPREL
, 0))
3888 if (htab
->tlsdesc_plt
3889 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3890 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3896 if (!add_dynamic_entry (DT_RELA
, 0)
3897 || !add_dynamic_entry (DT_RELASZ
, 0)
3898 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3901 /* If any dynamic relocs apply to a read-only section,
3902 then we need a DT_TEXTREL entry. */
3903 if ((info
->flags
& DF_TEXTREL
) == 0)
3904 elf_link_hash_traverse (&htab
->elf
,
3905 elf_x86_64_readonly_dynrelocs
,
3908 if ((info
->flags
& DF_TEXTREL
) != 0)
3910 if (htab
->readonly_dynrelocs_against_ifunc
)
3912 info
->callbacks
->einfo
3913 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3914 bfd_set_error (bfd_error_bad_value
);
3918 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3923 #undef add_dynamic_entry
3929 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3930 struct bfd_link_info
*info
)
3932 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3936 struct elf_link_hash_entry
*tlsbase
;
3938 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3939 "_TLS_MODULE_BASE_",
3940 FALSE
, FALSE
, FALSE
);
3942 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3944 struct elf_x86_64_link_hash_table
*htab
;
3945 struct bfd_link_hash_entry
*bh
= NULL
;
3946 const struct elf_backend_data
*bed
3947 = get_elf_backend_data (output_bfd
);
3949 htab
= elf_x86_64_hash_table (info
);
3953 if (!(_bfd_generic_link_add_one_symbol
3954 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3955 tls_sec
, 0, NULL
, FALSE
,
3956 bed
->collect
, &bh
)))
3959 htab
->tls_module_base
= bh
;
3961 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3962 tlsbase
->def_regular
= 1;
3963 tlsbase
->other
= STV_HIDDEN
;
3964 tlsbase
->root
.linker_def
= 1;
3965 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
3972 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
3973 executables. Rather than setting it to the beginning of the TLS
3974 section, we have to set it to the end. This function may be called
3975 multiple times, it is idempotent. */
3978 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
3980 struct elf_x86_64_link_hash_table
*htab
;
3981 struct bfd_link_hash_entry
*base
;
3983 if (!bfd_link_executable (info
))
3986 htab
= elf_x86_64_hash_table (info
);
3990 base
= htab
->tls_module_base
;
3994 base
->u
.def
.value
= htab
->elf
.tls_size
;
3997 /* Return the base VMA address which should be subtracted from real addresses
3998 when resolving @dtpoff relocation.
3999 This is PT_TLS segment p_vaddr. */
4002 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
4004 /* If tls_sec is NULL, we should have signalled an error already. */
4005 if (elf_hash_table (info
)->tls_sec
== NULL
)
4007 return elf_hash_table (info
)->tls_sec
->vma
;
4010 /* Return the relocation value for @tpoff relocation
4011 if STT_TLS virtual address is ADDRESS. */
4014 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
4016 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
4017 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
4018 bfd_vma static_tls_size
;
4020 /* If tls_segment is NULL, we should have signalled an error already. */
4021 if (htab
->tls_sec
== NULL
)
4024 /* Consider special static TLS alignment requirements. */
4025 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
4026 return address
- static_tls_size
- htab
->tls_sec
->vma
;
4029 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
4033 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
4035 /* Opcode Instruction
4038 0x0f 0x8x conditional jump */
4040 && (contents
[offset
- 1] == 0xe8
4041 || contents
[offset
- 1] == 0xe9))
4043 && contents
[offset
- 2] == 0x0f
4044 && (contents
[offset
- 1] & 0xf0) == 0x80));
4047 /* Relocate an x86_64 ELF section. */
4050 elf_x86_64_relocate_section (bfd
*output_bfd
,
4051 struct bfd_link_info
*info
,
4053 asection
*input_section
,
4055 Elf_Internal_Rela
*relocs
,
4056 Elf_Internal_Sym
*local_syms
,
4057 asection
**local_sections
)
4059 struct elf_x86_64_link_hash_table
*htab
;
4060 Elf_Internal_Shdr
*symtab_hdr
;
4061 struct elf_link_hash_entry
**sym_hashes
;
4062 bfd_vma
*local_got_offsets
;
4063 bfd_vma
*local_tlsdesc_gotents
;
4064 Elf_Internal_Rela
*rel
;
4065 Elf_Internal_Rela
*wrel
;
4066 Elf_Internal_Rela
*relend
;
4067 const unsigned int plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
4069 BFD_ASSERT (is_x86_64_elf (input_bfd
));
4071 /* Skip if check_relocs failed. */
4072 if (input_section
->check_relocs_failed
)
4075 htab
= elf_x86_64_hash_table (info
);
4078 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
4079 sym_hashes
= elf_sym_hashes (input_bfd
);
4080 local_got_offsets
= elf_local_got_offsets (input_bfd
);
4081 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
4083 elf_x86_64_set_tls_module_base (info
);
4085 rel
= wrel
= relocs
;
4086 relend
= relocs
+ input_section
->reloc_count
;
4087 for (; rel
< relend
; wrel
++, rel
++)
4089 unsigned int r_type
;
4090 reloc_howto_type
*howto
;
4091 unsigned long r_symndx
;
4092 struct elf_link_hash_entry
*h
;
4093 struct elf_x86_64_link_hash_entry
*eh
;
4094 Elf_Internal_Sym
*sym
;
4096 bfd_vma off
, offplt
, plt_offset
;
4098 bfd_boolean unresolved_reloc
;
4099 bfd_reloc_status_type r
;
4101 asection
*base_got
, *resolved_plt
;
4103 bfd_boolean resolved_to_zero
;
4105 r_type
= ELF32_R_TYPE (rel
->r_info
);
4106 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
4107 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
4114 if (r_type
>= (int) R_X86_64_standard
)
4116 (*_bfd_error_handler
)
4117 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
4118 input_bfd
, input_section
, r_type
);
4119 bfd_set_error (bfd_error_bad_value
);
4123 if (r_type
!= (int) R_X86_64_32
4124 || ABI_64_P (output_bfd
))
4125 howto
= x86_64_elf_howto_table
+ r_type
;
4127 howto
= (x86_64_elf_howto_table
4128 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
4129 r_symndx
= htab
->r_sym (rel
->r_info
);
4133 unresolved_reloc
= FALSE
;
4134 if (r_symndx
< symtab_hdr
->sh_info
)
4136 sym
= local_syms
+ r_symndx
;
4137 sec
= local_sections
[r_symndx
];
4139 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
4141 st_size
= sym
->st_size
;
4143 /* Relocate against local STT_GNU_IFUNC symbol. */
4144 if (!bfd_link_relocatable (info
)
4145 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
4147 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
4152 /* Set STT_GNU_IFUNC symbol value. */
4153 h
->root
.u
.def
.value
= sym
->st_value
;
4154 h
->root
.u
.def
.section
= sec
;
4159 bfd_boolean warned ATTRIBUTE_UNUSED
;
4160 bfd_boolean ignored ATTRIBUTE_UNUSED
;
4162 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
4163 r_symndx
, symtab_hdr
, sym_hashes
,
4165 unresolved_reloc
, warned
, ignored
);
4169 if (sec
!= NULL
&& discarded_section (sec
))
4171 _bfd_clear_contents (howto
, input_bfd
, input_section
,
4172 contents
+ rel
->r_offset
);
4173 wrel
->r_offset
= rel
->r_offset
;
4177 /* For ld -r, remove relocations in debug sections against
4178 sections defined in discarded sections. Not done for
4179 eh_frame editing code expects to be present. */
4180 if (bfd_link_relocatable (info
)
4181 && (input_section
->flags
& SEC_DEBUGGING
))
4187 if (bfd_link_relocatable (info
))
4194 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
4196 if (r_type
== R_X86_64_64
)
4198 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
4199 zero-extend it to 64bit if addend is zero. */
4200 r_type
= R_X86_64_32
;
4201 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4203 else if (r_type
== R_X86_64_SIZE64
)
4205 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
4206 zero-extend it to 64bit if addend is zero. */
4207 r_type
= R_X86_64_SIZE32
;
4208 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4212 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
4214 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
4215 it here if it is defined in a non-shared object. */
4217 && h
->type
== STT_GNU_IFUNC
4223 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4225 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4226 sections because such sections are not SEC_ALLOC and
4227 thus ld.so will not process them. */
4228 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
4232 else if (h
->plt
.offset
== (bfd_vma
) -1)
4235 /* STT_GNU_IFUNC symbol must go through PLT. */
4236 if (htab
->elf
.splt
!= NULL
)
4238 if (htab
->plt_bnd
!= NULL
)
4240 resolved_plt
= htab
->plt_bnd
;
4241 plt_offset
= eh
->plt_bnd
.offset
;
4245 resolved_plt
= htab
->elf
.splt
;
4246 plt_offset
= h
->plt
.offset
;
4251 resolved_plt
= htab
->elf
.iplt
;
4252 plt_offset
= h
->plt
.offset
;
4255 relocation
= (resolved_plt
->output_section
->vma
4256 + resolved_plt
->output_offset
+ plt_offset
);
4261 if (h
->root
.root
.string
)
4262 name
= h
->root
.root
.string
;
4264 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4266 (*_bfd_error_handler
)
4267 (_("%B: relocation %s against STT_GNU_IFUNC "
4268 "symbol `%s' isn't handled by %s"), input_bfd
,
4269 howto
->name
, name
, __FUNCTION__
);
4270 bfd_set_error (bfd_error_bad_value
);
4274 if (bfd_link_pic (info
))
4279 if (ABI_64_P (output_bfd
))
4283 if (rel
->r_addend
!= 0)
4285 if (h
->root
.root
.string
)
4286 name
= h
->root
.root
.string
;
4288 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4290 (*_bfd_error_handler
)
4291 (_("%B: relocation %s against STT_GNU_IFUNC "
4292 "symbol `%s' has non-zero addend: %d"),
4293 input_bfd
, howto
->name
, name
, rel
->r_addend
);
4294 bfd_set_error (bfd_error_bad_value
);
4298 /* Generate dynamic relcoation only when there is a
4299 non-GOT reference in a shared object. */
4300 if (bfd_link_pic (info
) && h
->non_got_ref
)
4302 Elf_Internal_Rela outrel
;
4305 /* Need a dynamic relocation to get the real function
4307 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
4311 if (outrel
.r_offset
== (bfd_vma
) -1
4312 || outrel
.r_offset
== (bfd_vma
) -2)
4315 outrel
.r_offset
+= (input_section
->output_section
->vma
4316 + input_section
->output_offset
);
4318 if (h
->dynindx
== -1
4320 || bfd_link_executable (info
))
4322 /* This symbol is resolved locally. */
4323 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4324 outrel
.r_addend
= (h
->root
.u
.def
.value
4325 + h
->root
.u
.def
.section
->output_section
->vma
4326 + h
->root
.u
.def
.section
->output_offset
);
4330 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4331 outrel
.r_addend
= 0;
4334 sreloc
= htab
->elf
.irelifunc
;
4335 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4337 /* If this reloc is against an external symbol, we
4338 do not want to fiddle with the addend. Otherwise,
4339 we need to include the symbol value so that it
4340 becomes an addend for the dynamic reloc. For an
4341 internal symbol, we have updated addend. */
4346 case R_X86_64_PC32_BND
:
4348 case R_X86_64_PLT32
:
4349 case R_X86_64_PLT32_BND
:
4352 case R_X86_64_GOTPCREL
:
4353 case R_X86_64_GOTPCRELX
:
4354 case R_X86_64_REX_GOTPCRELX
:
4355 case R_X86_64_GOTPCREL64
:
4356 base_got
= htab
->elf
.sgot
;
4357 off
= h
->got
.offset
;
4359 if (base_got
== NULL
)
4362 if (off
== (bfd_vma
) -1)
4364 /* We can't use h->got.offset here to save state, or
4365 even just remember the offset, as finish_dynamic_symbol
4366 would use that as offset into .got. */
4368 if (htab
->elf
.splt
!= NULL
)
4370 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4371 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4372 base_got
= htab
->elf
.sgotplt
;
4376 plt_index
= h
->plt
.offset
/ plt_entry_size
;
4377 off
= plt_index
* GOT_ENTRY_SIZE
;
4378 base_got
= htab
->elf
.igotplt
;
4381 if (h
->dynindx
== -1
4385 /* This references the local defitionion. We must
4386 initialize this entry in the global offset table.
4387 Since the offset must always be a multiple of 8,
4388 we use the least significant bit to record
4389 whether we have initialized it already.
4391 When doing a dynamic link, we create a .rela.got
4392 relocation entry to initialize the value. This
4393 is done in the finish_dynamic_symbol routine. */
4398 bfd_put_64 (output_bfd
, relocation
,
4399 base_got
->contents
+ off
);
4400 /* Note that this is harmless for the GOTPLT64
4401 case, as -1 | 1 still is -1. */
4407 relocation
= (base_got
->output_section
->vma
4408 + base_got
->output_offset
+ off
);
4414 resolved_to_zero
= (eh
!= NULL
4415 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
4419 /* When generating a shared object, the relocations handled here are
4420 copied into the output file to be resolved at run time. */
4423 case R_X86_64_GOT32
:
4424 case R_X86_64_GOT64
:
4425 /* Relocation is to the entry for this symbol in the global
4427 case R_X86_64_GOTPCREL
:
4428 case R_X86_64_GOTPCRELX
:
4429 case R_X86_64_REX_GOTPCRELX
:
4430 case R_X86_64_GOTPCREL64
:
4431 /* Use global offset table entry as symbol value. */
4432 case R_X86_64_GOTPLT64
:
4433 /* This is obsolete and treated the the same as GOT64. */
4434 base_got
= htab
->elf
.sgot
;
4436 if (htab
->elf
.sgot
== NULL
)
4443 off
= h
->got
.offset
;
4445 && h
->plt
.offset
!= (bfd_vma
)-1
4446 && off
== (bfd_vma
)-1)
4448 /* We can't use h->got.offset here to save
4449 state, or even just remember the offset, as
4450 finish_dynamic_symbol would use that as offset into
4452 bfd_vma plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4453 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4454 base_got
= htab
->elf
.sgotplt
;
4457 dyn
= htab
->elf
.dynamic_sections_created
;
4459 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
4460 || (bfd_link_pic (info
)
4461 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4462 || (ELF_ST_VISIBILITY (h
->other
)
4463 && h
->root
.type
== bfd_link_hash_undefweak
))
4465 /* This is actually a static link, or it is a -Bsymbolic
4466 link and the symbol is defined locally, or the symbol
4467 was forced to be local because of a version file. We
4468 must initialize this entry in the global offset table.
4469 Since the offset must always be a multiple of 8, we
4470 use the least significant bit to record whether we
4471 have initialized it already.
4473 When doing a dynamic link, we create a .rela.got
4474 relocation entry to initialize the value. This is
4475 done in the finish_dynamic_symbol routine. */
4480 bfd_put_64 (output_bfd
, relocation
,
4481 base_got
->contents
+ off
);
4482 /* Note that this is harmless for the GOTPLT64 case,
4483 as -1 | 1 still is -1. */
4488 unresolved_reloc
= FALSE
;
4492 if (local_got_offsets
== NULL
)
4495 off
= local_got_offsets
[r_symndx
];
4497 /* The offset must always be a multiple of 8. We use
4498 the least significant bit to record whether we have
4499 already generated the necessary reloc. */
4504 bfd_put_64 (output_bfd
, relocation
,
4505 base_got
->contents
+ off
);
4507 if (bfd_link_pic (info
))
4510 Elf_Internal_Rela outrel
;
4512 /* We need to generate a R_X86_64_RELATIVE reloc
4513 for the dynamic linker. */
4514 s
= htab
->elf
.srelgot
;
4518 outrel
.r_offset
= (base_got
->output_section
->vma
4519 + base_got
->output_offset
4521 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4522 outrel
.r_addend
= relocation
;
4523 elf_append_rela (output_bfd
, s
, &outrel
);
4526 local_got_offsets
[r_symndx
] |= 1;
4530 if (off
>= (bfd_vma
) -2)
4533 relocation
= base_got
->output_section
->vma
4534 + base_got
->output_offset
+ off
;
4535 if (r_type
!= R_X86_64_GOTPCREL
4536 && r_type
!= R_X86_64_GOTPCRELX
4537 && r_type
!= R_X86_64_REX_GOTPCRELX
4538 && r_type
!= R_X86_64_GOTPCREL64
)
4539 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4540 - htab
->elf
.sgotplt
->output_offset
;
4544 case R_X86_64_GOTOFF64
:
4545 /* Relocation is relative to the start of the global offset
4548 /* Check to make sure it isn't a protected function or data
4549 symbol for shared library since it may not be local when
4550 used as function address or with copy relocation. We also
4551 need to make sure that a symbol is referenced locally. */
4552 if (bfd_link_pic (info
) && h
)
4554 if (!h
->def_regular
)
4558 switch (ELF_ST_VISIBILITY (h
->other
))
4561 v
= _("hidden symbol");
4564 v
= _("internal symbol");
4567 v
= _("protected symbol");
4574 (*_bfd_error_handler
)
4575 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s `%s' can not be used when making a shared object"),
4576 input_bfd
, v
, h
->root
.root
.string
);
4577 bfd_set_error (bfd_error_bad_value
);
4580 else if (!bfd_link_executable (info
)
4581 && !SYMBOL_REFERENCES_LOCAL (info
, h
)
4582 && (h
->type
== STT_FUNC
4583 || h
->type
== STT_OBJECT
)
4584 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4586 (*_bfd_error_handler
)
4587 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s `%s' can not be used when making a shared object"),
4589 h
->type
== STT_FUNC
? "function" : "data",
4590 h
->root
.root
.string
);
4591 bfd_set_error (bfd_error_bad_value
);
4596 /* Note that sgot is not involved in this
4597 calculation. We always want the start of .got.plt. If we
4598 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4599 permitted by the ABI, we might have to change this
4601 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4602 + htab
->elf
.sgotplt
->output_offset
;
4605 case R_X86_64_GOTPC32
:
4606 case R_X86_64_GOTPC64
:
4607 /* Use global offset table as symbol value. */
4608 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4609 + htab
->elf
.sgotplt
->output_offset
;
4610 unresolved_reloc
= FALSE
;
4613 case R_X86_64_PLTOFF64
:
4614 /* Relocation is PLT entry relative to GOT. For local
4615 symbols it's the symbol itself relative to GOT. */
4617 /* See PLT32 handling. */
4618 && h
->plt
.offset
!= (bfd_vma
) -1
4619 && htab
->elf
.splt
!= NULL
)
4621 if (htab
->plt_bnd
!= NULL
)
4623 resolved_plt
= htab
->plt_bnd
;
4624 plt_offset
= eh
->plt_bnd
.offset
;
4628 resolved_plt
= htab
->elf
.splt
;
4629 plt_offset
= h
->plt
.offset
;
4632 relocation
= (resolved_plt
->output_section
->vma
4633 + resolved_plt
->output_offset
4635 unresolved_reloc
= FALSE
;
4638 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4639 + htab
->elf
.sgotplt
->output_offset
;
4642 case R_X86_64_PLT32
:
4643 case R_X86_64_PLT32_BND
:
4644 /* Relocation is to the entry for this symbol in the
4645 procedure linkage table. */
4647 /* Resolve a PLT32 reloc against a local symbol directly,
4648 without using the procedure linkage table. */
4652 if ((h
->plt
.offset
== (bfd_vma
) -1
4653 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4654 || htab
->elf
.splt
== NULL
)
4656 /* We didn't make a PLT entry for this symbol. This
4657 happens when statically linking PIC code, or when
4658 using -Bsymbolic. */
4662 if (h
->plt
.offset
!= (bfd_vma
) -1)
4664 if (htab
->plt_bnd
!= NULL
)
4666 resolved_plt
= htab
->plt_bnd
;
4667 plt_offset
= eh
->plt_bnd
.offset
;
4671 resolved_plt
= htab
->elf
.splt
;
4672 plt_offset
= h
->plt
.offset
;
4677 /* Use the GOT PLT. */
4678 resolved_plt
= htab
->plt_got
;
4679 plt_offset
= eh
->plt_got
.offset
;
4682 relocation
= (resolved_plt
->output_section
->vma
4683 + resolved_plt
->output_offset
4685 unresolved_reloc
= FALSE
;
4688 case R_X86_64_SIZE32
:
4689 case R_X86_64_SIZE64
:
4690 /* Set to symbol size. */
4691 relocation
= st_size
;
4697 case R_X86_64_PC32_BND
:
4698 /* Don't complain about -fPIC if the symbol is undefined when
4699 building executable unless it is unresolved weak symbol. */
4700 if ((input_section
->flags
& SEC_ALLOC
) != 0
4701 && (input_section
->flags
& SEC_READONLY
) != 0
4703 && ((bfd_link_executable (info
)
4704 && h
->root
.type
== bfd_link_hash_undefweak
4705 && !resolved_to_zero
)
4706 || (bfd_link_pic (info
)
4707 && !(bfd_link_pie (info
)
4708 && h
->root
.type
== bfd_link_hash_undefined
))))
4710 bfd_boolean fail
= FALSE
;
4712 = ((r_type
== R_X86_64_PC32
4713 || r_type
== R_X86_64_PC32_BND
)
4714 && is_32bit_relative_branch (contents
, rel
->r_offset
));
4716 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
4718 /* Symbol is referenced locally. Make sure it is
4719 defined locally or for a branch. */
4720 fail
= !h
->def_regular
&& !branch
;
4722 else if (!(bfd_link_pie (info
)
4723 && (h
->needs_copy
|| eh
->needs_copy
)))
4725 /* Symbol doesn't need copy reloc and isn't referenced
4726 locally. We only allow branch to symbol with
4727 non-default visibility. */
4729 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
4733 return elf_x86_64_need_pic (input_bfd
, input_section
,
4734 h
, NULL
, NULL
, howto
);
4743 /* FIXME: The ABI says the linker should make sure the value is
4744 the same when it's zeroextended to 64 bit. */
4747 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4750 /* Don't copy a pc-relative relocation into the output file
4751 if the symbol needs copy reloc or the symbol is undefined
4752 when building executable. Copy dynamic function pointer
4753 relocations. Don't generate dynamic relocations against
4754 resolved undefined weak symbols in PIE. */
4755 if ((bfd_link_pic (info
)
4756 && !(bfd_link_pie (info
)
4760 || h
->root
.type
== bfd_link_hash_undefined
)
4761 && IS_X86_64_PCREL_TYPE (r_type
))
4763 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4764 && !resolved_to_zero
)
4765 || h
->root
.type
!= bfd_link_hash_undefweak
))
4766 && ((! IS_X86_64_PCREL_TYPE (r_type
)
4767 && r_type
!= R_X86_64_SIZE32
4768 && r_type
!= R_X86_64_SIZE64
)
4769 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
4770 || (ELIMINATE_COPY_RELOCS
4771 && !bfd_link_pic (info
)
4775 || eh
->func_pointer_refcount
> 0
4776 || (h
->root
.type
== bfd_link_hash_undefweak
4777 && !resolved_to_zero
))
4778 && ((h
->def_dynamic
&& !h
->def_regular
)
4779 /* Undefined weak symbol is bound locally when
4781 || h
->root
.type
== bfd_link_hash_undefined
)))
4783 Elf_Internal_Rela outrel
;
4784 bfd_boolean skip
, relocate
;
4787 /* When generating a shared object, these relocations
4788 are copied into the output file to be resolved at run
4794 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4796 if (outrel
.r_offset
== (bfd_vma
) -1)
4798 else if (outrel
.r_offset
== (bfd_vma
) -2)
4799 skip
= TRUE
, relocate
= TRUE
;
4801 outrel
.r_offset
+= (input_section
->output_section
->vma
4802 + input_section
->output_offset
);
4805 memset (&outrel
, 0, sizeof outrel
);
4807 /* h->dynindx may be -1 if this symbol was marked to
4811 && (IS_X86_64_PCREL_TYPE (r_type
)
4812 || !(bfd_link_executable (info
)
4813 || SYMBOLIC_BIND (info
, h
))
4814 || ! h
->def_regular
))
4816 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4817 outrel
.r_addend
= rel
->r_addend
;
4821 /* This symbol is local, or marked to become local.
4822 When relocation overflow check is disabled, we
4823 convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */
4824 if (r_type
== htab
->pointer_r_type
4825 || (r_type
== R_X86_64_32
4826 && info
->no_reloc_overflow_check
))
4829 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4830 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4832 else if (r_type
== R_X86_64_64
4833 && !ABI_64_P (output_bfd
))
4836 outrel
.r_info
= htab
->r_info (0,
4837 R_X86_64_RELATIVE64
);
4838 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4839 /* Check addend overflow. */
4840 if ((outrel
.r_addend
& 0x80000000)
4841 != (rel
->r_addend
& 0x80000000))
4844 int addend
= rel
->r_addend
;
4845 if (h
&& h
->root
.root
.string
)
4846 name
= h
->root
.root
.string
;
4848 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4851 (*_bfd_error_handler
)
4852 (_("%B: addend -0x%x in relocation %s against "
4853 "symbol `%s' at 0x%lx in section `%A' is "
4855 input_bfd
, input_section
, addend
,
4857 (unsigned long) rel
->r_offset
);
4859 (*_bfd_error_handler
)
4860 (_("%B: addend 0x%x in relocation %s against "
4861 "symbol `%s' at 0x%lx in section `%A' is "
4863 input_bfd
, input_section
, addend
,
4865 (unsigned long) rel
->r_offset
);
4866 bfd_set_error (bfd_error_bad_value
);
4874 if (bfd_is_abs_section (sec
))
4876 else if (sec
== NULL
|| sec
->owner
== NULL
)
4878 bfd_set_error (bfd_error_bad_value
);
4885 /* We are turning this relocation into one
4886 against a section symbol. It would be
4887 proper to subtract the symbol's value,
4888 osec->vma, from the emitted reloc addend,
4889 but ld.so expects buggy relocs. */
4890 osec
= sec
->output_section
;
4891 sindx
= elf_section_data (osec
)->dynindx
;
4894 asection
*oi
= htab
->elf
.text_index_section
;
4895 sindx
= elf_section_data (oi
)->dynindx
;
4897 BFD_ASSERT (sindx
!= 0);
4900 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
4901 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4905 sreloc
= elf_section_data (input_section
)->sreloc
;
4907 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4909 r
= bfd_reloc_notsupported
;
4910 goto check_relocation_error
;
4913 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4915 /* If this reloc is against an external symbol, we do
4916 not want to fiddle with the addend. Otherwise, we
4917 need to include the symbol value so that it becomes
4918 an addend for the dynamic reloc. */
4925 case R_X86_64_TLSGD
:
4926 case R_X86_64_GOTPC32_TLSDESC
:
4927 case R_X86_64_TLSDESC_CALL
:
4928 case R_X86_64_GOTTPOFF
:
4929 tls_type
= GOT_UNKNOWN
;
4930 if (h
== NULL
&& local_got_offsets
)
4931 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
4933 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
4935 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4936 input_section
, contents
,
4937 symtab_hdr
, sym_hashes
,
4938 &r_type
, tls_type
, rel
,
4939 relend
, h
, r_symndx
, TRUE
))
4942 if (r_type
== R_X86_64_TPOFF32
)
4944 bfd_vma roff
= rel
->r_offset
;
4946 BFD_ASSERT (! unresolved_reloc
);
4948 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4950 /* GD->LE transition. For 64bit, change
4951 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4952 .word 0x6666; rex64; call __tls_get_addr@PLT
4954 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4956 call *__tls_get_addr@GOTPCREL(%rip)
4957 which may be converted to
4958 addr32 call __tls_get_addr
4961 leaq foo@tpoff(%rax), %rax
4963 leaq foo@tlsgd(%rip), %rdi
4964 .word 0x6666; rex64; call __tls_get_addr@PLT
4966 leaq foo@tlsgd(%rip), %rdi
4968 call *__tls_get_addr@GOTPCREL(%rip)
4969 which may be converted to
4970 addr32 call __tls_get_addr
4973 leaq foo@tpoff(%rax), %rax
4974 For largepic, change:
4975 leaq foo@tlsgd(%rip), %rdi
4976 movabsq $__tls_get_addr@pltoff, %rax
4981 leaq foo@tpoff(%rax), %rax
4982 nopw 0x0(%rax,%rax,1) */
4984 if (ABI_64_P (output_bfd
))
4986 if (contents
[roff
+ 5] == 0xb8)
4988 memcpy (contents
+ roff
- 3,
4989 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
4990 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4994 memcpy (contents
+ roff
- 4,
4995 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
4999 memcpy (contents
+ roff
- 3,
5000 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5002 bfd_put_32 (output_bfd
,
5003 elf_x86_64_tpoff (info
, relocation
),
5004 contents
+ roff
+ 8 + largepic
);
5005 /* Skip R_X86_64_PC32, R_X86_64_PLT32,
5006 R_X86_64_GOTPCRELX and R_X86_64_PLTOFF64. */
5011 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5013 /* GDesc -> LE transition.
5014 It's originally something like:
5015 leaq x@tlsdesc(%rip), %rax
5018 movl $x@tpoff, %rax. */
5020 unsigned int val
, type
;
5022 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5023 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5024 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
5025 contents
+ roff
- 3);
5026 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
5027 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
5028 contents
+ roff
- 1);
5029 bfd_put_32 (output_bfd
,
5030 elf_x86_64_tpoff (info
, relocation
),
5034 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5036 /* GDesc -> LE transition.
5041 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5042 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5045 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
5047 /* IE->LE transition:
5048 For 64bit, originally it can be one of:
5049 movq foo@gottpoff(%rip), %reg
5050 addq foo@gottpoff(%rip), %reg
5053 leaq foo(%reg), %reg
5055 For 32bit, originally it can be one of:
5056 movq foo@gottpoff(%rip), %reg
5057 addl foo@gottpoff(%rip), %reg
5060 leal foo(%reg), %reg
5063 unsigned int val
, type
, reg
;
5066 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5069 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
5070 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5076 bfd_put_8 (output_bfd
, 0x49,
5077 contents
+ roff
- 3);
5078 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5079 bfd_put_8 (output_bfd
, 0x41,
5080 contents
+ roff
- 3);
5081 bfd_put_8 (output_bfd
, 0xc7,
5082 contents
+ roff
- 2);
5083 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5084 contents
+ roff
- 1);
5088 /* addq/addl -> addq/addl - addressing with %rsp/%r12
5091 bfd_put_8 (output_bfd
, 0x49,
5092 contents
+ roff
- 3);
5093 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5094 bfd_put_8 (output_bfd
, 0x41,
5095 contents
+ roff
- 3);
5096 bfd_put_8 (output_bfd
, 0x81,
5097 contents
+ roff
- 2);
5098 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5099 contents
+ roff
- 1);
5103 /* addq/addl -> leaq/leal */
5105 bfd_put_8 (output_bfd
, 0x4d,
5106 contents
+ roff
- 3);
5107 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5108 bfd_put_8 (output_bfd
, 0x45,
5109 contents
+ roff
- 3);
5110 bfd_put_8 (output_bfd
, 0x8d,
5111 contents
+ roff
- 2);
5112 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
5113 contents
+ roff
- 1);
5115 bfd_put_32 (output_bfd
,
5116 elf_x86_64_tpoff (info
, relocation
),
5124 if (htab
->elf
.sgot
== NULL
)
5129 off
= h
->got
.offset
;
5130 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
5134 if (local_got_offsets
== NULL
)
5137 off
= local_got_offsets
[r_symndx
];
5138 offplt
= local_tlsdesc_gotents
[r_symndx
];
5145 Elf_Internal_Rela outrel
;
5149 if (htab
->elf
.srelgot
== NULL
)
5152 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
5154 if (GOT_TLS_GDESC_P (tls_type
))
5156 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
5157 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
5158 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
5159 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5160 + htab
->elf
.sgotplt
->output_offset
5162 + htab
->sgotplt_jump_table_size
);
5163 sreloc
= htab
->elf
.srelplt
;
5165 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5167 outrel
.r_addend
= 0;
5168 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5171 sreloc
= htab
->elf
.srelgot
;
5173 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5174 + htab
->elf
.sgot
->output_offset
+ off
);
5176 if (GOT_TLS_GD_P (tls_type
))
5177 dr_type
= R_X86_64_DTPMOD64
;
5178 else if (GOT_TLS_GDESC_P (tls_type
))
5181 dr_type
= R_X86_64_TPOFF64
;
5183 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
5184 outrel
.r_addend
= 0;
5185 if ((dr_type
== R_X86_64_TPOFF64
5186 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
5187 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5188 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
5190 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5192 if (GOT_TLS_GD_P (tls_type
))
5196 BFD_ASSERT (! unresolved_reloc
);
5197 bfd_put_64 (output_bfd
,
5198 relocation
- elf_x86_64_dtpoff_base (info
),
5199 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5203 bfd_put_64 (output_bfd
, 0,
5204 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5205 outrel
.r_info
= htab
->r_info (indx
,
5207 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
5208 elf_append_rela (output_bfd
, sreloc
,
5217 local_got_offsets
[r_symndx
] |= 1;
5220 if (off
>= (bfd_vma
) -2
5221 && ! GOT_TLS_GDESC_P (tls_type
))
5223 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
5225 if (r_type
== R_X86_64_GOTPC32_TLSDESC
5226 || r_type
== R_X86_64_TLSDESC_CALL
)
5227 relocation
= htab
->elf
.sgotplt
->output_section
->vma
5228 + htab
->elf
.sgotplt
->output_offset
5229 + offplt
+ htab
->sgotplt_jump_table_size
;
5231 relocation
= htab
->elf
.sgot
->output_section
->vma
5232 + htab
->elf
.sgot
->output_offset
+ off
;
5233 unresolved_reloc
= FALSE
;
5237 bfd_vma roff
= rel
->r_offset
;
5239 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5241 /* GD->IE transition. For 64bit, change
5242 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5243 .word 0x6666; rex64; call __tls_get_addr@PLT
5245 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5247 call *__tls_get_addr@GOTPCREL(%rip
5248 which may be converted to
5249 addr32 call __tls_get_addr
5252 addq foo@gottpoff(%rip), %rax
5254 leaq foo@tlsgd(%rip), %rdi
5255 .word 0x6666; rex64; call __tls_get_addr@PLT
5257 leaq foo@tlsgd(%rip), %rdi
5259 call *__tls_get_addr@GOTPCREL(%rip)
5260 which may be converted to
5261 addr32 call __tls_get_addr
5264 addq foo@gottpoff(%rip), %rax
5265 For largepic, change:
5266 leaq foo@tlsgd(%rip), %rdi
5267 movabsq $__tls_get_addr@pltoff, %rax
5272 addq foo@gottpoff(%rax), %rax
5273 nopw 0x0(%rax,%rax,1) */
5275 if (ABI_64_P (output_bfd
))
5277 if (contents
[roff
+ 5] == 0xb8)
5279 memcpy (contents
+ roff
- 3,
5280 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
5281 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5285 memcpy (contents
+ roff
- 4,
5286 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5290 memcpy (contents
+ roff
- 3,
5291 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5294 relocation
= (htab
->elf
.sgot
->output_section
->vma
5295 + htab
->elf
.sgot
->output_offset
+ off
5298 - input_section
->output_section
->vma
5299 - input_section
->output_offset
5301 bfd_put_32 (output_bfd
, relocation
,
5302 contents
+ roff
+ 8 + largepic
);
5303 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5308 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5310 /* GDesc -> IE transition.
5311 It's originally something like:
5312 leaq x@tlsdesc(%rip), %rax
5315 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
5317 /* Now modify the instruction as appropriate. To
5318 turn a leaq into a movq in the form we use it, it
5319 suffices to change the second byte from 0x8d to
5321 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
5323 bfd_put_32 (output_bfd
,
5324 htab
->elf
.sgot
->output_section
->vma
5325 + htab
->elf
.sgot
->output_offset
+ off
5327 - input_section
->output_section
->vma
5328 - input_section
->output_offset
5333 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5335 /* GDesc -> IE transition.
5342 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5343 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5351 case R_X86_64_TLSLD
:
5352 if (! elf_x86_64_tls_transition (info
, input_bfd
,
5353 input_section
, contents
,
5354 symtab_hdr
, sym_hashes
,
5355 &r_type
, GOT_UNKNOWN
, rel
,
5356 relend
, h
, r_symndx
, TRUE
))
5359 if (r_type
!= R_X86_64_TLSLD
)
5361 /* LD->LE transition:
5362 leaq foo@tlsld(%rip), %rdi
5363 call __tls_get_addr@PLT
5364 For 64bit, we change it into:
5365 .word 0x6666; .byte 0x66; movq %fs:0, %rax
5366 For 32bit, we change it into:
5367 nopl 0x0(%rax); movl %fs:0, %eax
5369 leaq foo@tlsld(%rip), %rdi;
5370 call *__tls_get_addr@GOTPCREL(%rip)
5371 which may be converted to
5372 addr32 call __tls_get_addr
5373 For 64bit, we change it into:
5374 .word 0x6666; .word 0x6666; movq %fs:0, %rax
5375 For 32bit, we change it into:
5376 nopw 0x0(%rax); movl %fs:0, %eax
5377 For largepic, change:
5378 leaq foo@tlsgd(%rip), %rdi
5379 movabsq $__tls_get_addr@pltoff, %rax
5383 data16 data16 data16 nopw %cs:0x0(%rax,%rax,1)
5386 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
5387 if (ABI_64_P (output_bfd
))
5389 if (contents
[rel
->r_offset
+ 5] == 0xb8)
5390 memcpy (contents
+ rel
->r_offset
- 3,
5391 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
5392 "\x64\x48\x8b\x04\x25\0\0\0", 22);
5393 else if (contents
[rel
->r_offset
+ 4] == 0xff
5394 || contents
[rel
->r_offset
+ 4] == 0x67)
5395 memcpy (contents
+ rel
->r_offset
- 3,
5396 "\x66\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0",
5399 memcpy (contents
+ rel
->r_offset
- 3,
5400 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
5404 if (contents
[rel
->r_offset
+ 4] == 0xff)
5405 memcpy (contents
+ rel
->r_offset
- 3,
5406 "\x66\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0",
5409 memcpy (contents
+ rel
->r_offset
- 3,
5410 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
5412 /* Skip R_X86_64_PC32, R_X86_64_PLT32, R_X86_64_GOTPCRELX
5413 and R_X86_64_PLTOFF64. */
5419 if (htab
->elf
.sgot
== NULL
)
5422 off
= htab
->tls_ld_got
.offset
;
5427 Elf_Internal_Rela outrel
;
5429 if (htab
->elf
.srelgot
== NULL
)
5432 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5433 + htab
->elf
.sgot
->output_offset
+ off
);
5435 bfd_put_64 (output_bfd
, 0,
5436 htab
->elf
.sgot
->contents
+ off
);
5437 bfd_put_64 (output_bfd
, 0,
5438 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5439 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
5440 outrel
.r_addend
= 0;
5441 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
5443 htab
->tls_ld_got
.offset
|= 1;
5445 relocation
= htab
->elf
.sgot
->output_section
->vma
5446 + htab
->elf
.sgot
->output_offset
+ off
;
5447 unresolved_reloc
= FALSE
;
5450 case R_X86_64_DTPOFF32
:
5451 if (!bfd_link_executable (info
)
5452 || (input_section
->flags
& SEC_CODE
) == 0)
5453 relocation
-= elf_x86_64_dtpoff_base (info
);
5455 relocation
= elf_x86_64_tpoff (info
, relocation
);
5458 case R_X86_64_TPOFF32
:
5459 case R_X86_64_TPOFF64
:
5460 BFD_ASSERT (bfd_link_executable (info
));
5461 relocation
= elf_x86_64_tpoff (info
, relocation
);
5464 case R_X86_64_DTPOFF64
:
5465 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
5466 relocation
-= elf_x86_64_dtpoff_base (info
);
5473 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5474 because such sections are not SEC_ALLOC and thus ld.so will
5475 not process them. */
5476 if (unresolved_reloc
5477 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
5479 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5480 rel
->r_offset
) != (bfd_vma
) -1)
5482 (*_bfd_error_handler
)
5483 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5486 (long) rel
->r_offset
,
5488 h
->root
.root
.string
);
5493 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5494 contents
, rel
->r_offset
,
5495 relocation
, rel
->r_addend
);
5497 check_relocation_error
:
5498 if (r
!= bfd_reloc_ok
)
5503 name
= h
->root
.root
.string
;
5506 name
= bfd_elf_string_from_elf_section (input_bfd
,
5507 symtab_hdr
->sh_link
,
5512 name
= bfd_section_name (input_bfd
, sec
);
5515 if (r
== bfd_reloc_overflow
)
5516 (*info
->callbacks
->reloc_overflow
)
5517 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5518 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
5521 (*_bfd_error_handler
)
5522 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5523 input_bfd
, input_section
,
5524 (long) rel
->r_offset
, name
, (int) r
);
5535 Elf_Internal_Shdr
*rel_hdr
;
5536 size_t deleted
= rel
- wrel
;
5538 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
5539 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5540 if (rel_hdr
->sh_size
== 0)
5542 /* It is too late to remove an empty reloc section. Leave
5544 ??? What is wrong with an empty section??? */
5545 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
5548 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5549 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5550 input_section
->reloc_count
-= deleted
;
5556 /* Finish up dynamic symbol handling. We set the contents of various
5557 dynamic sections here. */
5560 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
5561 struct bfd_link_info
*info
,
5562 struct elf_link_hash_entry
*h
,
5563 Elf_Internal_Sym
*sym
)
5565 struct elf_x86_64_link_hash_table
*htab
;
5566 const struct elf_x86_64_backend_data
*abed
;
5567 bfd_boolean use_plt_bnd
;
5568 struct elf_x86_64_link_hash_entry
*eh
;
5569 bfd_boolean local_undefweak
;
5571 htab
= elf_x86_64_hash_table (info
);
5575 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5576 section only if there is .plt section. */
5577 use_plt_bnd
= htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
;
5579 ? &elf_x86_64_bnd_arch_bed
5580 : get_elf_x86_64_backend_data (output_bfd
));
5582 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
5584 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5585 resolved undefined weak symbols in executable so that their
5586 references have value 0 at run-time. */
5587 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
5591 if (h
->plt
.offset
!= (bfd_vma
) -1)
5594 bfd_vma got_offset
, plt_offset
, plt_plt_offset
, plt_got_offset
;
5595 bfd_vma plt_plt_insn_end
, plt_got_insn_size
;
5596 Elf_Internal_Rela rela
;
5598 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
5599 const struct elf_backend_data
*bed
;
5600 bfd_vma plt_got_pcrel_offset
;
5602 /* When building a static executable, use .iplt, .igot.plt and
5603 .rela.iplt sections for STT_GNU_IFUNC symbols. */
5604 if (htab
->elf
.splt
!= NULL
)
5606 plt
= htab
->elf
.splt
;
5607 gotplt
= htab
->elf
.sgotplt
;
5608 relplt
= htab
->elf
.srelplt
;
5612 plt
= htab
->elf
.iplt
;
5613 gotplt
= htab
->elf
.igotplt
;
5614 relplt
= htab
->elf
.irelplt
;
5617 /* This symbol has an entry in the procedure linkage table. Set
5619 if ((h
->dynindx
== -1
5621 && !((h
->forced_local
|| bfd_link_executable (info
))
5623 && h
->type
== STT_GNU_IFUNC
))
5629 /* Get the index in the procedure linkage table which
5630 corresponds to this symbol. This is the index of this symbol
5631 in all the symbols for which we are making plt entries. The
5632 first entry in the procedure linkage table is reserved.
5634 Get the offset into the .got table of the entry that
5635 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
5636 bytes. The first three are reserved for the dynamic linker.
5638 For static executables, we don't reserve anything. */
5640 if (plt
== htab
->elf
.splt
)
5642 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
5643 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
5647 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
5648 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
5651 plt_plt_insn_end
= abed
->plt_plt_insn_end
;
5652 plt_plt_offset
= abed
->plt_plt_offset
;
5653 plt_got_insn_size
= abed
->plt_got_insn_size
;
5654 plt_got_offset
= abed
->plt_got_offset
;
5657 /* Use the second PLT with BND relocations. */
5658 const bfd_byte
*plt_entry
, *plt2_entry
;
5660 if (eh
->has_bnd_reloc
)
5662 plt_entry
= elf_x86_64_bnd_plt_entry
;
5663 plt2_entry
= elf_x86_64_bnd_plt2_entry
;
5667 plt_entry
= elf_x86_64_legacy_plt_entry
;
5668 plt2_entry
= elf_x86_64_legacy_plt2_entry
;
5670 /* Subtract 1 since there is no BND prefix. */
5671 plt_plt_insn_end
-= 1;
5672 plt_plt_offset
-= 1;
5673 plt_got_insn_size
-= 1;
5674 plt_got_offset
-= 1;
5677 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry
)
5678 == sizeof (elf_x86_64_legacy_plt_entry
));
5680 /* Fill in the entry in the procedure linkage table. */
5681 memcpy (plt
->contents
+ h
->plt
.offset
,
5682 plt_entry
, sizeof (elf_x86_64_legacy_plt_entry
));
5683 /* Fill in the entry in the second PLT. */
5684 memcpy (htab
->plt_bnd
->contents
+ eh
->plt_bnd
.offset
,
5685 plt2_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5687 resolved_plt
= htab
->plt_bnd
;
5688 plt_offset
= eh
->plt_bnd
.offset
;
5692 /* Fill in the entry in the procedure linkage table. */
5693 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
5694 abed
->plt_entry_size
);
5697 plt_offset
= h
->plt
.offset
;
5700 /* Insert the relocation positions of the plt section. */
5702 /* Put offset the PC-relative instruction referring to the GOT entry,
5703 subtracting the size of that instruction. */
5704 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
5705 + gotplt
->output_offset
5707 - resolved_plt
->output_section
->vma
5708 - resolved_plt
->output_offset
5710 - plt_got_insn_size
);
5712 /* Check PC-relative offset overflow in PLT entry. */
5713 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
5714 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5715 output_bfd
, h
->root
.root
.string
);
5717 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
5718 resolved_plt
->contents
+ plt_offset
+ plt_got_offset
);
5720 /* Fill in the entry in the global offset table, initially this
5721 points to the second part of the PLT entry. Leave the entry
5722 as zero for undefined weak symbol in PIE. No PLT relocation
5723 against undefined weak symbol in PIE. */
5724 if (!local_undefweak
)
5726 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5727 + plt
->output_offset
5729 + abed
->plt_lazy_offset
),
5730 gotplt
->contents
+ got_offset
);
5732 /* Fill in the entry in the .rela.plt section. */
5733 rela
.r_offset
= (gotplt
->output_section
->vma
5734 + gotplt
->output_offset
5736 if (h
->dynindx
== -1
5737 || ((bfd_link_executable (info
)
5738 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5740 && h
->type
== STT_GNU_IFUNC
))
5742 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5743 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
5744 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
5745 rela
.r_addend
= (h
->root
.u
.def
.value
5746 + h
->root
.u
.def
.section
->output_section
->vma
5747 + h
->root
.u
.def
.section
->output_offset
);
5748 /* R_X86_64_IRELATIVE comes last. */
5749 plt_index
= htab
->next_irelative_index
--;
5753 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
5755 plt_index
= htab
->next_jump_slot_index
++;
5758 /* Don't fill PLT entry for static executables. */
5759 if (plt
== htab
->elf
.splt
)
5761 bfd_vma plt0_offset
= h
->plt
.offset
+ plt_plt_insn_end
;
5763 /* Put relocation index. */
5764 bfd_put_32 (output_bfd
, plt_index
,
5765 (plt
->contents
+ h
->plt
.offset
5766 + abed
->plt_reloc_offset
));
5768 /* Put offset for jmp .PLT0 and check for overflow. We don't
5769 check relocation index for overflow since branch displacement
5770 will overflow first. */
5771 if (plt0_offset
> 0x80000000)
5772 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5773 output_bfd
, h
->root
.root
.string
);
5774 bfd_put_32 (output_bfd
, - plt0_offset
,
5775 plt
->contents
+ h
->plt
.offset
+ plt_plt_offset
);
5778 bed
= get_elf_backend_data (output_bfd
);
5779 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
5780 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
5783 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5785 bfd_vma got_offset
, plt_offset
, plt_got_offset
, plt_got_insn_size
;
5786 asection
*plt
, *got
;
5787 bfd_boolean got_after_plt
;
5788 int32_t got_pcrel_offset
;
5789 const bfd_byte
*got_plt_entry
;
5791 /* Set the entry in the GOT procedure linkage table. */
5792 plt
= htab
->plt_got
;
5793 got
= htab
->elf
.sgot
;
5794 got_offset
= h
->got
.offset
;
5796 if (got_offset
== (bfd_vma
) -1
5797 || h
->type
== STT_GNU_IFUNC
5802 /* Use the second PLT entry template for the GOT PLT since they
5803 are the identical. */
5804 plt_got_insn_size
= elf_x86_64_bnd_arch_bed
.plt_got_insn_size
;
5805 plt_got_offset
= elf_x86_64_bnd_arch_bed
.plt_got_offset
;
5806 if (eh
->has_bnd_reloc
)
5807 got_plt_entry
= elf_x86_64_bnd_plt2_entry
;
5810 got_plt_entry
= elf_x86_64_legacy_plt2_entry
;
5812 /* Subtract 1 since there is no BND prefix. */
5813 plt_got_insn_size
-= 1;
5814 plt_got_offset
-= 1;
5817 /* Fill in the entry in the GOT procedure linkage table. */
5818 plt_offset
= eh
->plt_got
.offset
;
5819 memcpy (plt
->contents
+ plt_offset
,
5820 got_plt_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5822 /* Put offset the PC-relative instruction referring to the GOT
5823 entry, subtracting the size of that instruction. */
5824 got_pcrel_offset
= (got
->output_section
->vma
5825 + got
->output_offset
5827 - plt
->output_section
->vma
5828 - plt
->output_offset
5830 - plt_got_insn_size
);
5832 /* Check PC-relative offset overflow in GOT PLT entry. */
5833 got_after_plt
= got
->output_section
->vma
> plt
->output_section
->vma
;
5834 if ((got_after_plt
&& got_pcrel_offset
< 0)
5835 || (!got_after_plt
&& got_pcrel_offset
> 0))
5836 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
5837 output_bfd
, h
->root
.root
.string
);
5839 bfd_put_32 (output_bfd
, got_pcrel_offset
,
5840 plt
->contents
+ plt_offset
+ plt_got_offset
);
5843 if (!local_undefweak
5845 && (h
->plt
.offset
!= (bfd_vma
) -1
5846 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5848 /* Mark the symbol as undefined, rather than as defined in
5849 the .plt section. Leave the value if there were any
5850 relocations where pointer equality matters (this is a clue
5851 for the dynamic linker, to make function pointer
5852 comparisons work between an application and shared
5853 library), otherwise set it to zero. If a function is only
5854 called from a binary, there is no need to slow down
5855 shared libraries because of that. */
5856 sym
->st_shndx
= SHN_UNDEF
;
5857 if (!h
->pointer_equality_needed
)
5861 /* Don't generate dynamic GOT relocation against undefined weak
5862 symbol in executable. */
5863 if (h
->got
.offset
!= (bfd_vma
) -1
5864 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
5865 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
5866 && !local_undefweak
)
5868 Elf_Internal_Rela rela
;
5870 /* This symbol has an entry in the global offset table. Set it
5872 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5875 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5876 + htab
->elf
.sgot
->output_offset
5877 + (h
->got
.offset
&~ (bfd_vma
) 1));
5879 /* If this is a static link, or it is a -Bsymbolic link and the
5880 symbol is defined locally or was forced to be local because
5881 of a version file, we just want to emit a RELATIVE reloc.
5882 The entry in the global offset table will already have been
5883 initialized in the relocate_section function. */
5885 && h
->type
== STT_GNU_IFUNC
)
5887 if (bfd_link_pic (info
))
5889 /* Generate R_X86_64_GLOB_DAT. */
5896 if (!h
->pointer_equality_needed
)
5899 /* For non-shared object, we can't use .got.plt, which
5900 contains the real function addres if we need pointer
5901 equality. We load the GOT entry with the PLT entry. */
5902 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5903 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5904 + plt
->output_offset
5906 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5910 else if (bfd_link_pic (info
)
5911 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5913 if (!h
->def_regular
)
5915 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5916 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
5917 rela
.r_addend
= (h
->root
.u
.def
.value
5918 + h
->root
.u
.def
.section
->output_section
->vma
5919 + h
->root
.u
.def
.section
->output_offset
);
5923 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5925 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5926 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5927 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
5931 elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &rela
);
5936 Elf_Internal_Rela rela
;
5938 /* This symbol needs a copy reloc. Set it up. */
5940 if (h
->dynindx
== -1
5941 || (h
->root
.type
!= bfd_link_hash_defined
5942 && h
->root
.type
!= bfd_link_hash_defweak
)
5943 || htab
->srelbss
== NULL
)
5946 rela
.r_offset
= (h
->root
.u
.def
.value
5947 + h
->root
.u
.def
.section
->output_section
->vma
5948 + h
->root
.u
.def
.section
->output_offset
);
5949 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
5951 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
5957 /* Finish up local dynamic symbol handling. We set the contents of
5958 various dynamic sections here. */
5961 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
5963 struct elf_link_hash_entry
*h
5964 = (struct elf_link_hash_entry
*) *slot
;
5965 struct bfd_link_info
*info
5966 = (struct bfd_link_info
*) inf
;
5968 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5972 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5973 here since undefined weak symbol may not be dynamic and may not be
5974 called for elf_x86_64_finish_dynamic_symbol. */
5977 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
5980 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
5981 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5983 if (h
->root
.type
!= bfd_link_hash_undefweak
5984 || h
->dynindx
!= -1)
5987 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5991 /* Used to decide how to sort relocs in an optimal manner for the
5992 dynamic linker, before writing them out. */
5994 static enum elf_reloc_type_class
5995 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info
,
5996 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5997 const Elf_Internal_Rela
*rela
)
5999 bfd
*abfd
= info
->output_bfd
;
6000 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6001 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
6003 if (htab
->elf
.dynsym
!= NULL
6004 && htab
->elf
.dynsym
->contents
!= NULL
)
6006 /* Check relocation against STT_GNU_IFUNC symbol if there are
6008 unsigned long r_symndx
= htab
->r_sym (rela
->r_info
);
6009 if (r_symndx
!= STN_UNDEF
)
6011 Elf_Internal_Sym sym
;
6012 if (!bed
->s
->swap_symbol_in (abfd
,
6013 (htab
->elf
.dynsym
->contents
6014 + r_symndx
* bed
->s
->sizeof_sym
),
6018 if (ELF_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
6019 return reloc_class_ifunc
;
6023 switch ((int) ELF32_R_TYPE (rela
->r_info
))
6025 case R_X86_64_IRELATIVE
:
6026 return reloc_class_ifunc
;
6027 case R_X86_64_RELATIVE
:
6028 case R_X86_64_RELATIVE64
:
6029 return reloc_class_relative
;
6030 case R_X86_64_JUMP_SLOT
:
6031 return reloc_class_plt
;
6033 return reloc_class_copy
;
6035 return reloc_class_normal
;
6039 /* Finish up the dynamic sections. */
6042 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
6043 struct bfd_link_info
*info
)
6045 struct elf_x86_64_link_hash_table
*htab
;
6048 const struct elf_x86_64_backend_data
*abed
;
6050 htab
= elf_x86_64_hash_table (info
);
6054 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
6055 section only if there is .plt section. */
6056 abed
= (htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
6057 ? &elf_x86_64_bnd_arch_bed
6058 : get_elf_x86_64_backend_data (output_bfd
));
6060 dynobj
= htab
->elf
.dynobj
;
6061 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
6063 if (htab
->elf
.dynamic_sections_created
)
6065 bfd_byte
*dyncon
, *dynconend
;
6066 const struct elf_backend_data
*bed
;
6067 bfd_size_type sizeof_dyn
;
6069 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
6072 bed
= get_elf_backend_data (dynobj
);
6073 sizeof_dyn
= bed
->s
->sizeof_dyn
;
6074 dyncon
= sdyn
->contents
;
6075 dynconend
= sdyn
->contents
+ sdyn
->size
;
6076 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
6078 Elf_Internal_Dyn dyn
;
6081 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
6089 s
= htab
->elf
.sgotplt
;
6090 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
6094 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
6098 s
= htab
->elf
.srelplt
->output_section
;
6099 dyn
.d_un
.d_val
= s
->size
;
6103 /* The procedure linkage table relocs (DT_JMPREL) should
6104 not be included in the overall relocs (DT_RELA).
6105 Therefore, we override the DT_RELASZ entry here to
6106 make it not include the JMPREL relocs. Since the
6107 linker script arranges for .rela.plt to follow all
6108 other relocation sections, we don't have to worry
6109 about changing the DT_RELA entry. */
6110 if (htab
->elf
.srelplt
!= NULL
)
6112 s
= htab
->elf
.srelplt
->output_section
;
6113 dyn
.d_un
.d_val
-= s
->size
;
6117 case DT_TLSDESC_PLT
:
6119 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6120 + htab
->tlsdesc_plt
;
6123 case DT_TLSDESC_GOT
:
6125 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6126 + htab
->tlsdesc_got
;
6130 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
6133 /* Fill in the special first entry in the procedure linkage table. */
6134 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
6136 /* Fill in the first entry in the procedure linkage table. */
6137 memcpy (htab
->elf
.splt
->contents
,
6138 abed
->plt0_entry
, abed
->plt_entry_size
);
6139 /* Add offset for pushq GOT+8(%rip), since the instruction
6140 uses 6 bytes subtract this value. */
6141 bfd_put_32 (output_bfd
,
6142 (htab
->elf
.sgotplt
->output_section
->vma
6143 + htab
->elf
.sgotplt
->output_offset
6145 - htab
->elf
.splt
->output_section
->vma
6146 - htab
->elf
.splt
->output_offset
6148 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
6149 /* Add offset for the PC-relative instruction accessing GOT+16,
6150 subtracting the offset to the end of that instruction. */
6151 bfd_put_32 (output_bfd
,
6152 (htab
->elf
.sgotplt
->output_section
->vma
6153 + htab
->elf
.sgotplt
->output_offset
6155 - htab
->elf
.splt
->output_section
->vma
6156 - htab
->elf
.splt
->output_offset
6157 - abed
->plt0_got2_insn_end
),
6158 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
6160 elf_section_data (htab
->elf
.splt
->output_section
)
6161 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
6163 if (htab
->tlsdesc_plt
)
6165 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6166 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
6168 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
6169 abed
->plt0_entry
, abed
->plt_entry_size
);
6171 /* Add offset for pushq GOT+8(%rip), since the
6172 instruction uses 6 bytes subtract this value. */
6173 bfd_put_32 (output_bfd
,
6174 (htab
->elf
.sgotplt
->output_section
->vma
6175 + htab
->elf
.sgotplt
->output_offset
6177 - htab
->elf
.splt
->output_section
->vma
6178 - htab
->elf
.splt
->output_offset
6181 htab
->elf
.splt
->contents
6182 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
6183 /* Add offset for the PC-relative instruction accessing GOT+TDG,
6184 where TGD stands for htab->tlsdesc_got, subtracting the offset
6185 to the end of that instruction. */
6186 bfd_put_32 (output_bfd
,
6187 (htab
->elf
.sgot
->output_section
->vma
6188 + htab
->elf
.sgot
->output_offset
6190 - htab
->elf
.splt
->output_section
->vma
6191 - htab
->elf
.splt
->output_offset
6193 - abed
->plt0_got2_insn_end
),
6194 htab
->elf
.splt
->contents
6195 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
6200 if (htab
->plt_bnd
!= NULL
)
6201 elf_section_data (htab
->plt_bnd
->output_section
)
6202 ->this_hdr
.sh_entsize
= sizeof (elf_x86_64_bnd_plt2_entry
);
6204 if (htab
->elf
.sgotplt
)
6206 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
6208 (*_bfd_error_handler
)
6209 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
6213 /* Fill in the first three entries in the global offset table. */
6214 if (htab
->elf
.sgotplt
->size
> 0)
6216 /* Set the first entry in the global offset table to the address of
6217 the dynamic section. */
6219 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
6221 bfd_put_64 (output_bfd
,
6222 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
6223 htab
->elf
.sgotplt
->contents
);
6224 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
6225 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
6226 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
6229 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
6233 /* Adjust .eh_frame for .plt section. */
6234 if (htab
->plt_eh_frame
!= NULL
6235 && htab
->plt_eh_frame
->contents
!= NULL
)
6237 if (htab
->elf
.splt
!= NULL
6238 && htab
->elf
.splt
->size
!= 0
6239 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
6240 && htab
->elf
.splt
->output_section
!= NULL
6241 && htab
->plt_eh_frame
->output_section
!= NULL
)
6243 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
6244 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
6245 + htab
->plt_eh_frame
->output_offset
6246 + PLT_FDE_START_OFFSET
;
6247 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6248 htab
->plt_eh_frame
->contents
6249 + PLT_FDE_START_OFFSET
);
6251 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
6253 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6255 htab
->plt_eh_frame
->contents
))
6260 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
6261 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
6264 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
6265 htab_traverse (htab
->loc_hash_table
,
6266 elf_x86_64_finish_local_dynamic_symbol
,
6269 /* Fill PLT entries for undefined weak symbols in PIE. */
6270 if (bfd_link_pie (info
))
6271 bfd_hash_traverse (&info
->hash
->table
,
6272 elf_x86_64_pie_finish_undefweak_symbol
,
6278 /* Return an array of PLT entry symbol values. */
6281 elf_x86_64_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
6284 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
6287 bfd_vma
*plt_sym_val
;
6289 bfd_byte
*plt_contents
;
6290 const struct elf_x86_64_backend_data
*bed
;
6291 Elf_Internal_Shdr
*hdr
;
6294 /* Get the .plt section contents. PLT passed down may point to the
6295 .plt.bnd section. Make sure that PLT always points to the .plt
6297 plt_bnd
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6302 plt
= bfd_get_section_by_name (abfd
, ".plt");
6305 bed
= &elf_x86_64_bnd_arch_bed
;
6308 bed
= get_elf_x86_64_backend_data (abfd
);
6310 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
6311 if (plt_contents
== NULL
)
6313 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
6314 plt_contents
, 0, plt
->size
))
6317 free (plt_contents
);
6321 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
6322 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
6325 hdr
= &elf_section_data (relplt
)->this_hdr
;
6326 count
= relplt
->size
/ hdr
->sh_entsize
;
6328 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
6329 if (plt_sym_val
== NULL
)
6332 for (i
= 0; i
< count
; i
++)
6333 plt_sym_val
[i
] = -1;
6335 plt_offset
= bed
->plt_entry_size
;
6336 p
= relplt
->relocation
;
6337 for (i
= 0; i
< count
; i
++, p
++)
6341 /* Skip unknown relocation. */
6342 if (p
->howto
== NULL
)
6345 if (p
->howto
->type
!= R_X86_64_JUMP_SLOT
6346 && p
->howto
->type
!= R_X86_64_IRELATIVE
)
6349 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
6350 + bed
->plt_reloc_offset
));
6351 if (reloc_index
< count
)
6355 /* This is the index in .plt section. */
6356 long plt_index
= plt_offset
/ bed
->plt_entry_size
;
6357 /* Store VMA + the offset in .plt.bnd section. */
6358 plt_sym_val
[reloc_index
] =
6360 + (plt_index
- 1) * sizeof (elf_x86_64_legacy_plt2_entry
));
6363 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
6365 plt_offset
+= bed
->plt_entry_size
;
6367 /* PR binutils/18437: Skip extra relocations in the .rela.plt
6369 if (plt_offset
>= plt
->size
)
6373 free (plt_contents
);
6378 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
6382 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
6389 /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
6390 as PLT if it exists. */
6391 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6393 plt
= bfd_get_section_by_name (abfd
, ".plt");
6394 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
6395 dynsymcount
, dynsyms
, ret
,
6397 elf_x86_64_get_plt_sym_val
);
6400 /* Handle an x86-64 specific section when reading an object file. This
6401 is called when elfcode.h finds a section with an unknown type. */
6404 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
6405 const char *name
, int shindex
)
6407 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
6410 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
6416 /* Hook called by the linker routine which adds symbols from an object
6417 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
6421 elf_x86_64_add_symbol_hook (bfd
*abfd
,
6422 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6423 Elf_Internal_Sym
*sym
,
6424 const char **namep ATTRIBUTE_UNUSED
,
6425 flagword
*flagsp ATTRIBUTE_UNUSED
,
6431 switch (sym
->st_shndx
)
6433 case SHN_X86_64_LCOMMON
:
6434 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
6437 lcomm
= bfd_make_section_with_flags (abfd
,
6441 | SEC_LINKER_CREATED
));
6444 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
6447 *valp
= sym
->st_size
;
6455 /* Given a BFD section, try to locate the corresponding ELF section
6459 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
6460 asection
*sec
, int *index_return
)
6462 if (sec
== &_bfd_elf_large_com_section
)
6464 *index_return
= SHN_X86_64_LCOMMON
;
6470 /* Process a symbol. */
6473 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
6476 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
6478 switch (elfsym
->internal_elf_sym
.st_shndx
)
6480 case SHN_X86_64_LCOMMON
:
6481 asym
->section
= &_bfd_elf_large_com_section
;
6482 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
6483 /* Common symbol doesn't set BSF_GLOBAL. */
6484 asym
->flags
&= ~BSF_GLOBAL
;
6490 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
6492 return (sym
->st_shndx
== SHN_COMMON
6493 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
6497 elf_x86_64_common_section_index (asection
*sec
)
6499 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6502 return SHN_X86_64_LCOMMON
;
6506 elf_x86_64_common_section (asection
*sec
)
6508 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6509 return bfd_com_section_ptr
;
6511 return &_bfd_elf_large_com_section
;
6515 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
6516 const Elf_Internal_Sym
*sym
,
6521 const asection
*oldsec
)
6523 /* A normal common symbol and a large common symbol result in a
6524 normal common symbol. We turn the large common symbol into a
6527 && h
->root
.type
== bfd_link_hash_common
6529 && bfd_is_com_section (*psec
)
6532 if (sym
->st_shndx
== SHN_COMMON
6533 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
6535 h
->root
.u
.c
.p
->section
6536 = bfd_make_section_old_way (oldbfd
, "COMMON");
6537 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
6539 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
6540 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
6541 *psec
= bfd_com_section_ptr
;
6548 elf_x86_64_additional_program_headers (bfd
*abfd
,
6549 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6554 /* Check to see if we need a large readonly segment. */
6555 s
= bfd_get_section_by_name (abfd
, ".lrodata");
6556 if (s
&& (s
->flags
& SEC_LOAD
))
6559 /* Check to see if we need a large data segment. Since .lbss sections
6560 is placed right after the .bss section, there should be no need for
6561 a large data segment just because of .lbss. */
6562 s
= bfd_get_section_by_name (abfd
, ".ldata");
6563 if (s
&& (s
->flags
& SEC_LOAD
))
6569 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6572 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
6574 if (h
->plt
.offset
!= (bfd_vma
) -1
6576 && !h
->pointer_equality_needed
)
6579 return _bfd_elf_hash_symbol (h
);
6582 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
6585 elf_x86_64_relocs_compatible (const bfd_target
*input
,
6586 const bfd_target
*output
)
6588 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
6589 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
6590 && _bfd_elf_relocs_compatible (input
, output
));
6593 static const struct bfd_elf_special_section
6594 elf_x86_64_special_sections
[]=
6596 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6597 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6598 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
6599 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6600 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6601 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6602 { NULL
, 0, 0, 0, 0 }
6605 #define TARGET_LITTLE_SYM x86_64_elf64_vec
6606 #define TARGET_LITTLE_NAME "elf64-x86-64"
6607 #define ELF_ARCH bfd_arch_i386
6608 #define ELF_TARGET_ID X86_64_ELF_DATA
6609 #define ELF_MACHINE_CODE EM_X86_64
6610 #define ELF_MAXPAGESIZE 0x200000
6611 #define ELF_MINPAGESIZE 0x1000
6612 #define ELF_COMMONPAGESIZE 0x1000
6614 #define elf_backend_can_gc_sections 1
6615 #define elf_backend_can_refcount 1
6616 #define elf_backend_want_got_plt 1
6617 #define elf_backend_plt_readonly 1
6618 #define elf_backend_want_plt_sym 0
6619 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
6620 #define elf_backend_rela_normal 1
6621 #define elf_backend_plt_alignment 4
6622 #define elf_backend_extern_protected_data 1
6623 #define elf_backend_caches_rawsize 1
6625 #define elf_info_to_howto elf_x86_64_info_to_howto
6627 #define bfd_elf64_bfd_link_hash_table_create \
6628 elf_x86_64_link_hash_table_create
6629 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
6630 #define bfd_elf64_bfd_reloc_name_lookup \
6631 elf_x86_64_reloc_name_lookup
6633 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
6634 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
6635 #define elf_backend_check_relocs elf_x86_64_check_relocs
6636 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
6637 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
6638 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
6639 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
6640 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
6641 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
6642 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
6644 #define elf_backend_write_core_note elf_x86_64_write_core_note
6646 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
6647 #define elf_backend_relocate_section elf_x86_64_relocate_section
6648 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
6649 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
6650 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
6651 #define elf_backend_object_p elf64_x86_64_elf_object_p
6652 #define bfd_elf64_mkobject elf_x86_64_mkobject
6653 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
6655 #define elf_backend_section_from_shdr \
6656 elf_x86_64_section_from_shdr
6658 #define elf_backend_section_from_bfd_section \
6659 elf_x86_64_elf_section_from_bfd_section
6660 #define elf_backend_add_symbol_hook \
6661 elf_x86_64_add_symbol_hook
6662 #define elf_backend_symbol_processing \
6663 elf_x86_64_symbol_processing
6664 #define elf_backend_common_section_index \
6665 elf_x86_64_common_section_index
6666 #define elf_backend_common_section \
6667 elf_x86_64_common_section
6668 #define elf_backend_common_definition \
6669 elf_x86_64_common_definition
6670 #define elf_backend_merge_symbol \
6671 elf_x86_64_merge_symbol
6672 #define elf_backend_special_sections \
6673 elf_x86_64_special_sections
6674 #define elf_backend_additional_program_headers \
6675 elf_x86_64_additional_program_headers
6676 #define elf_backend_hash_symbol \
6677 elf_x86_64_hash_symbol
6678 #define elf_backend_omit_section_dynsym \
6679 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6680 #define elf_backend_fixup_symbol \
6681 elf_x86_64_fixup_symbol
6683 #include "elf64-target.h"
6685 /* CloudABI support. */
6687 #undef TARGET_LITTLE_SYM
6688 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
6689 #undef TARGET_LITTLE_NAME
6690 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
6693 #define ELF_OSABI ELFOSABI_CLOUDABI
6696 #define elf64_bed elf64_x86_64_cloudabi_bed
6698 #include "elf64-target.h"
6700 /* FreeBSD support. */
6702 #undef TARGET_LITTLE_SYM
6703 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
6704 #undef TARGET_LITTLE_NAME
6705 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
6708 #define ELF_OSABI ELFOSABI_FREEBSD
6711 #define elf64_bed elf64_x86_64_fbsd_bed
6713 #include "elf64-target.h"
6715 /* Solaris 2 support. */
6717 #undef TARGET_LITTLE_SYM
6718 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
6719 #undef TARGET_LITTLE_NAME
6720 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
6722 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6723 objects won't be recognized. */
6727 #define elf64_bed elf64_x86_64_sol2_bed
6729 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
6731 #undef elf_backend_static_tls_alignment
6732 #define elf_backend_static_tls_alignment 16
6734 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6736 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6738 #undef elf_backend_want_plt_sym
6739 #define elf_backend_want_plt_sym 1
6741 #undef elf_backend_strtab_flags
6742 #define elf_backend_strtab_flags SHF_STRINGS
6745 elf64_x86_64_copy_solaris_special_section_fields (const bfd
*ibfd ATTRIBUTE_UNUSED
,
6746 bfd
*obfd ATTRIBUTE_UNUSED
,
6747 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
6748 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
6750 /* PR 19938: FIXME: Need to add code for setting the sh_info
6751 and sh_link fields of Solaris specific section types. */
6755 #undef elf_backend_copy_special_section_fields
6756 #define elf_backend_copy_special_section_fields elf64_x86_64_copy_solaris_special_section_fields
6758 #include "elf64-target.h"
6760 /* Native Client support. */
6763 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
6765 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
6766 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
6770 #undef TARGET_LITTLE_SYM
6771 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
6772 #undef TARGET_LITTLE_NAME
6773 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
6775 #define elf64_bed elf64_x86_64_nacl_bed
6777 #undef ELF_MAXPAGESIZE
6778 #undef ELF_MINPAGESIZE
6779 #undef ELF_COMMONPAGESIZE
6780 #define ELF_MAXPAGESIZE 0x10000
6781 #define ELF_MINPAGESIZE 0x10000
6782 #define ELF_COMMONPAGESIZE 0x10000
6784 /* Restore defaults. */
6786 #undef elf_backend_static_tls_alignment
6787 #undef elf_backend_want_plt_sym
6788 #define elf_backend_want_plt_sym 0
6789 #undef elf_backend_strtab_flags
6790 #undef elf_backend_copy_special_section_fields
6792 /* NaCl uses substantially different PLT entries for the same effects. */
6794 #undef elf_backend_plt_alignment
6795 #define elf_backend_plt_alignment 5
6796 #define NACL_PLT_ENTRY_SIZE 64
6797 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6799 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
6801 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
6802 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
6803 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6804 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6805 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6807 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
6808 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
6810 /* 32 bytes of nop to pad out to the standard size. */
6811 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6812 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6813 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6814 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6815 0x66, /* excess data16 prefix */
6819 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6821 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
6822 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6823 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6824 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6826 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
6827 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6828 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6830 /* Lazy GOT entries point here (32-byte aligned). */
6831 0x68, /* pushq immediate */
6832 0, 0, 0, 0, /* replaced with index into relocation table. */
6833 0xe9, /* jmp relative */
6834 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
6836 /* 22 bytes of nop to pad out to the standard size. */
6837 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6838 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6839 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
6842 /* .eh_frame covering the .plt section. */
6844 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
6846 #if (PLT_CIE_LENGTH != 20 \
6847 || PLT_FDE_LENGTH != 36 \
6848 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6849 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6850 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
6852 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6853 0, 0, 0, 0, /* CIE ID */
6854 1, /* CIE version */
6855 'z', 'R', 0, /* Augmentation string */
6856 1, /* Code alignment factor */
6857 0x78, /* Data alignment factor */
6858 16, /* Return address column */
6859 1, /* Augmentation size */
6860 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6861 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
6862 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
6863 DW_CFA_nop
, DW_CFA_nop
,
6865 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6866 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
6867 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
6868 0, 0, 0, 0, /* .plt size goes here */
6869 0, /* Augmentation size */
6870 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
6871 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6872 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
6873 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6874 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6875 13, /* Block length */
6876 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
6877 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
6878 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6879 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
6880 DW_CFA_nop
, DW_CFA_nop
6883 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
6885 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
6886 elf_x86_64_nacl_plt_entry
, /* plt_entry */
6887 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6888 2, /* plt0_got1_offset */
6889 9, /* plt0_got2_offset */
6890 13, /* plt0_got2_insn_end */
6891 3, /* plt_got_offset */
6892 33, /* plt_reloc_offset */
6893 38, /* plt_plt_offset */
6894 7, /* plt_got_insn_size */
6895 42, /* plt_plt_insn_end */
6896 32, /* plt_lazy_offset */
6897 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
6898 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
6901 #undef elf_backend_arch_data
6902 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
6904 #undef elf_backend_object_p
6905 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
6906 #undef elf_backend_modify_segment_map
6907 #define elf_backend_modify_segment_map nacl_modify_segment_map
6908 #undef elf_backend_modify_program_headers
6909 #define elf_backend_modify_program_headers nacl_modify_program_headers
6910 #undef elf_backend_final_write_processing
6911 #define elf_backend_final_write_processing nacl_final_write_processing
6913 #include "elf64-target.h"
6915 /* Native Client x32 support. */
6918 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
6920 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
6921 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
6925 #undef TARGET_LITTLE_SYM
6926 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
6927 #undef TARGET_LITTLE_NAME
6928 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
6930 #define elf32_bed elf32_x86_64_nacl_bed
6932 #define bfd_elf32_bfd_link_hash_table_create \
6933 elf_x86_64_link_hash_table_create
6934 #define bfd_elf32_bfd_reloc_type_lookup \
6935 elf_x86_64_reloc_type_lookup
6936 #define bfd_elf32_bfd_reloc_name_lookup \
6937 elf_x86_64_reloc_name_lookup
6938 #define bfd_elf32_mkobject \
6940 #define bfd_elf32_get_synthetic_symtab \
6941 elf_x86_64_get_synthetic_symtab
6943 #undef elf_backend_object_p
6944 #define elf_backend_object_p \
6945 elf32_x86_64_nacl_elf_object_p
6947 #undef elf_backend_bfd_from_remote_memory
6948 #define elf_backend_bfd_from_remote_memory \
6949 _bfd_elf32_bfd_from_remote_memory
6951 #undef elf_backend_size_info
6952 #define elf_backend_size_info \
6953 _bfd_elf32_size_info
6955 #include "elf32-target.h"
6957 /* Restore defaults. */
6958 #undef elf_backend_object_p
6959 #define elf_backend_object_p elf64_x86_64_elf_object_p
6960 #undef elf_backend_bfd_from_remote_memory
6961 #undef elf_backend_size_info
6962 #undef elf_backend_modify_segment_map
6963 #undef elf_backend_modify_program_headers
6964 #undef elf_backend_final_write_processing
6966 /* Intel L1OM support. */
6969 elf64_l1om_elf_object_p (bfd
*abfd
)
6971 /* Set the right machine number for an L1OM elf64 file. */
6972 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
6976 #undef TARGET_LITTLE_SYM
6977 #define TARGET_LITTLE_SYM l1om_elf64_vec
6978 #undef TARGET_LITTLE_NAME
6979 #define TARGET_LITTLE_NAME "elf64-l1om"
6981 #define ELF_ARCH bfd_arch_l1om
6983 #undef ELF_MACHINE_CODE
6984 #define ELF_MACHINE_CODE EM_L1OM
6989 #define elf64_bed elf64_l1om_bed
6991 #undef elf_backend_object_p
6992 #define elf_backend_object_p elf64_l1om_elf_object_p
6994 /* Restore defaults. */
6995 #undef ELF_MAXPAGESIZE
6996 #undef ELF_MINPAGESIZE
6997 #undef ELF_COMMONPAGESIZE
6998 #define ELF_MAXPAGESIZE 0x200000
6999 #define ELF_MINPAGESIZE 0x1000
7000 #define ELF_COMMONPAGESIZE 0x1000
7001 #undef elf_backend_plt_alignment
7002 #define elf_backend_plt_alignment 4
7003 #undef elf_backend_arch_data
7004 #define elf_backend_arch_data &elf_x86_64_arch_bed
7006 #include "elf64-target.h"
7008 /* FreeBSD L1OM support. */
7010 #undef TARGET_LITTLE_SYM
7011 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
7012 #undef TARGET_LITTLE_NAME
7013 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
7016 #define ELF_OSABI ELFOSABI_FREEBSD
7019 #define elf64_bed elf64_l1om_fbsd_bed
7021 #include "elf64-target.h"
7023 /* Intel K1OM support. */
7026 elf64_k1om_elf_object_p (bfd
*abfd
)
7028 /* Set the right machine number for an K1OM elf64 file. */
7029 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
7033 #undef TARGET_LITTLE_SYM
7034 #define TARGET_LITTLE_SYM k1om_elf64_vec
7035 #undef TARGET_LITTLE_NAME
7036 #define TARGET_LITTLE_NAME "elf64-k1om"
7038 #define ELF_ARCH bfd_arch_k1om
7040 #undef ELF_MACHINE_CODE
7041 #define ELF_MACHINE_CODE EM_K1OM
7046 #define elf64_bed elf64_k1om_bed
7048 #undef elf_backend_object_p
7049 #define elf_backend_object_p elf64_k1om_elf_object_p
7051 #undef elf_backend_static_tls_alignment
7053 #undef elf_backend_want_plt_sym
7054 #define elf_backend_want_plt_sym 0
7056 #include "elf64-target.h"
7058 /* FreeBSD K1OM support. */
7060 #undef TARGET_LITTLE_SYM
7061 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
7062 #undef TARGET_LITTLE_NAME
7063 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
7066 #define ELF_OSABI ELFOSABI_FREEBSD
7069 #define elf64_bed elf64_k1om_fbsd_bed
7071 #include "elf64-target.h"
7073 /* 32bit x86-64 support. */
7075 #undef TARGET_LITTLE_SYM
7076 #define TARGET_LITTLE_SYM x86_64_elf32_vec
7077 #undef TARGET_LITTLE_NAME
7078 #define TARGET_LITTLE_NAME "elf32-x86-64"
7082 #define ELF_ARCH bfd_arch_i386
7084 #undef ELF_MACHINE_CODE
7085 #define ELF_MACHINE_CODE EM_X86_64
7089 #undef elf_backend_object_p
7090 #define elf_backend_object_p \
7091 elf32_x86_64_elf_object_p
7093 #undef elf_backend_bfd_from_remote_memory
7094 #define elf_backend_bfd_from_remote_memory \
7095 _bfd_elf32_bfd_from_remote_memory
7097 #undef elf_backend_size_info
7098 #define elf_backend_size_info \
7099 _bfd_elf32_size_info
7101 #include "elf32-target.h"