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, EH) \
752 ((EH)->elf.root.type == bfd_link_hash_undefweak \
753 && bfd_link_executable (INFO) \
754 && (elf_x86_64_hash_table (INFO)->interp == NULL \
755 || !(EH)->has_got_reloc \
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 /* Reference count of C/C++ function pointer relocations in read-write
800 section which can be resolved at run-time. */
801 bfd_signed_vma func_pointer_refcount
;
803 /* Information about the GOT PLT entry. Filled when there are both
804 GOT and PLT relocations against the same function. */
805 union gotplt_union plt_got
;
807 /* Information about the second PLT entry. Filled when has_bnd_reloc is
809 union gotplt_union plt_bnd
;
811 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
812 starting at the end of the jump table. */
816 #define elf_x86_64_hash_entry(ent) \
817 ((struct elf_x86_64_link_hash_entry *)(ent))
819 struct elf_x86_64_obj_tdata
821 struct elf_obj_tdata root
;
823 /* tls_type for each local got entry. */
824 char *local_got_tls_type
;
826 /* GOTPLT entries for TLS descriptors. */
827 bfd_vma
*local_tlsdesc_gotent
;
830 #define elf_x86_64_tdata(abfd) \
831 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
833 #define elf_x86_64_local_got_tls_type(abfd) \
834 (elf_x86_64_tdata (abfd)->local_got_tls_type)
836 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
837 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
839 #define is_x86_64_elf(bfd) \
840 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
841 && elf_tdata (bfd) != NULL \
842 && elf_object_id (bfd) == X86_64_ELF_DATA)
845 elf_x86_64_mkobject (bfd
*abfd
)
847 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_x86_64_obj_tdata
),
851 /* x86-64 ELF linker hash table. */
853 struct elf_x86_64_link_hash_table
855 struct elf_link_hash_table elf
;
857 /* Short-cuts to get to dynamic linker sections. */
861 asection
*plt_eh_frame
;
867 bfd_signed_vma refcount
;
871 /* The amount of space used by the jump slots in the GOT. */
872 bfd_vma sgotplt_jump_table_size
;
874 /* Small local sym cache. */
875 struct sym_cache sym_cache
;
877 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
878 bfd_vma (*r_sym
) (bfd_vma
);
879 unsigned int pointer_r_type
;
880 const char *dynamic_interpreter
;
881 int dynamic_interpreter_size
;
883 /* _TLS_MODULE_BASE_ symbol. */
884 struct bfd_link_hash_entry
*tls_module_base
;
886 /* Used by local STT_GNU_IFUNC symbols. */
887 htab_t loc_hash_table
;
888 void * loc_hash_memory
;
890 /* The offset into splt of the PLT entry for the TLS descriptor
891 resolver. Special values are 0, if not necessary (or not found
892 to be necessary yet), and -1 if needed but not determined
895 /* The offset into sgot of the GOT entry used by the PLT entry
899 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
900 bfd_vma next_jump_slot_index
;
901 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
902 bfd_vma next_irelative_index
;
904 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
905 to read-only sections. */
906 bfd_boolean readonly_dynrelocs_against_ifunc
;
909 /* Get the x86-64 ELF linker hash table from a link_info structure. */
911 #define elf_x86_64_hash_table(p) \
912 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
913 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
915 #define elf_x86_64_compute_jump_table_size(htab) \
916 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
918 /* Create an entry in an x86-64 ELF linker hash table. */
920 static struct bfd_hash_entry
*
921 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
922 struct bfd_hash_table
*table
,
925 /* Allocate the structure if it has not already been allocated by a
929 entry
= (struct bfd_hash_entry
*)
930 bfd_hash_allocate (table
,
931 sizeof (struct elf_x86_64_link_hash_entry
));
936 /* Call the allocation method of the superclass. */
937 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
940 struct elf_x86_64_link_hash_entry
*eh
;
942 eh
= (struct elf_x86_64_link_hash_entry
*) entry
;
943 eh
->dyn_relocs
= NULL
;
944 eh
->tls_type
= GOT_UNKNOWN
;
946 eh
->has_bnd_reloc
= 0;
947 eh
->has_got_reloc
= 0;
948 eh
->has_non_got_reloc
= 0;
949 eh
->func_pointer_refcount
= 0;
950 eh
->plt_bnd
.offset
= (bfd_vma
) -1;
951 eh
->plt_got
.offset
= (bfd_vma
) -1;
952 eh
->tlsdesc_got
= (bfd_vma
) -1;
958 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
959 for local symbol so that we can handle local STT_GNU_IFUNC symbols
960 as global symbol. We reuse indx and dynstr_index for local symbol
961 hash since they aren't used by global symbols in this backend. */
964 elf_x86_64_local_htab_hash (const void *ptr
)
966 struct elf_link_hash_entry
*h
967 = (struct elf_link_hash_entry
*) ptr
;
968 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
971 /* Compare local hash entries. */
974 elf_x86_64_local_htab_eq (const void *ptr1
, const void *ptr2
)
976 struct elf_link_hash_entry
*h1
977 = (struct elf_link_hash_entry
*) ptr1
;
978 struct elf_link_hash_entry
*h2
979 = (struct elf_link_hash_entry
*) ptr2
;
981 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
984 /* Find and/or create a hash entry for local symbol. */
986 static struct elf_link_hash_entry
*
987 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table
*htab
,
988 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
991 struct elf_x86_64_link_hash_entry e
, *ret
;
992 asection
*sec
= abfd
->sections
;
993 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
994 htab
->r_sym (rel
->r_info
));
997 e
.elf
.indx
= sec
->id
;
998 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
999 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
1000 create
? INSERT
: NO_INSERT
);
1007 ret
= (struct elf_x86_64_link_hash_entry
*) *slot
;
1011 ret
= (struct elf_x86_64_link_hash_entry
*)
1012 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
1013 sizeof (struct elf_x86_64_link_hash_entry
));
1016 memset (ret
, 0, sizeof (*ret
));
1017 ret
->elf
.indx
= sec
->id
;
1018 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
1019 ret
->elf
.dynindx
= -1;
1020 ret
->func_pointer_refcount
= 0;
1021 ret
->plt_got
.offset
= (bfd_vma
) -1;
1027 /* Destroy an X86-64 ELF linker hash table. */
1030 elf_x86_64_link_hash_table_free (bfd
*obfd
)
1032 struct elf_x86_64_link_hash_table
*htab
1033 = (struct elf_x86_64_link_hash_table
*) obfd
->link
.hash
;
1035 if (htab
->loc_hash_table
)
1036 htab_delete (htab
->loc_hash_table
);
1037 if (htab
->loc_hash_memory
)
1038 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
1039 _bfd_elf_link_hash_table_free (obfd
);
1042 /* Create an X86-64 ELF linker hash table. */
1044 static struct bfd_link_hash_table
*
1045 elf_x86_64_link_hash_table_create (bfd
*abfd
)
1047 struct elf_x86_64_link_hash_table
*ret
;
1048 bfd_size_type amt
= sizeof (struct elf_x86_64_link_hash_table
);
1050 ret
= (struct elf_x86_64_link_hash_table
*) bfd_zmalloc (amt
);
1054 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1055 elf_x86_64_link_hash_newfunc
,
1056 sizeof (struct elf_x86_64_link_hash_entry
),
1063 if (ABI_64_P (abfd
))
1065 ret
->r_info
= elf64_r_info
;
1066 ret
->r_sym
= elf64_r_sym
;
1067 ret
->pointer_r_type
= R_X86_64_64
;
1068 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
1069 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
1073 ret
->r_info
= elf32_r_info
;
1074 ret
->r_sym
= elf32_r_sym
;
1075 ret
->pointer_r_type
= R_X86_64_32
;
1076 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
1077 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
1080 ret
->loc_hash_table
= htab_try_create (1024,
1081 elf_x86_64_local_htab_hash
,
1082 elf_x86_64_local_htab_eq
,
1084 ret
->loc_hash_memory
= objalloc_create ();
1085 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1087 elf_x86_64_link_hash_table_free (abfd
);
1090 ret
->elf
.root
.hash_table_free
= elf_x86_64_link_hash_table_free
;
1092 return &ret
->elf
.root
;
1095 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1096 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1100 elf_x86_64_create_dynamic_sections (bfd
*dynobj
,
1101 struct bfd_link_info
*info
)
1103 struct elf_x86_64_link_hash_table
*htab
;
1105 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1108 htab
= elf_x86_64_hash_table (info
);
1112 htab
->sdynbss
= bfd_get_linker_section (dynobj
, ".dynbss");
1116 if (bfd_link_executable (info
))
1118 /* Always allow copy relocs for building executables. */
1119 asection
*s
= bfd_get_linker_section (dynobj
, ".rela.bss");
1122 const struct elf_backend_data
*bed
= get_elf_backend_data (dynobj
);
1123 s
= bfd_make_section_anyway_with_flags (dynobj
,
1125 (bed
->dynamic_sec_flags
1128 || ! bfd_set_section_alignment (dynobj
, s
,
1129 bed
->s
->log_file_align
))
1135 if (!info
->no_ld_generated_unwind_info
1136 && htab
->plt_eh_frame
== NULL
1137 && htab
->elf
.splt
!= NULL
)
1139 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1140 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1141 | SEC_LINKER_CREATED
);
1143 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
1144 if (htab
->plt_eh_frame
== NULL
1145 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 3))
1151 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1154 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
1155 struct elf_link_hash_entry
*dir
,
1156 struct elf_link_hash_entry
*ind
)
1158 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
1160 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
1161 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
1163 if (!edir
->has_bnd_reloc
)
1164 edir
->has_bnd_reloc
= eind
->has_bnd_reloc
;
1166 if (!edir
->has_got_reloc
)
1167 edir
->has_got_reloc
= eind
->has_got_reloc
;
1169 if (!edir
->has_non_got_reloc
)
1170 edir
->has_non_got_reloc
= eind
->has_non_got_reloc
;
1172 if (eind
->dyn_relocs
!= NULL
)
1174 if (edir
->dyn_relocs
!= NULL
)
1176 struct elf_dyn_relocs
**pp
;
1177 struct elf_dyn_relocs
*p
;
1179 /* Add reloc counts against the indirect sym to the direct sym
1180 list. Merge any entries against the same section. */
1181 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1183 struct elf_dyn_relocs
*q
;
1185 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1186 if (q
->sec
== p
->sec
)
1188 q
->pc_count
+= p
->pc_count
;
1189 q
->count
+= p
->count
;
1196 *pp
= edir
->dyn_relocs
;
1199 edir
->dyn_relocs
= eind
->dyn_relocs
;
1200 eind
->dyn_relocs
= NULL
;
1203 if (ind
->root
.type
== bfd_link_hash_indirect
1204 && dir
->got
.refcount
<= 0)
1206 edir
->tls_type
= eind
->tls_type
;
1207 eind
->tls_type
= GOT_UNKNOWN
;
1210 if (ELIMINATE_COPY_RELOCS
1211 && ind
->root
.type
!= bfd_link_hash_indirect
1212 && dir
->dynamic_adjusted
)
1214 /* If called to transfer flags for a weakdef during processing
1215 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1216 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1217 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1218 dir
->ref_regular
|= ind
->ref_regular
;
1219 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1220 dir
->needs_plt
|= ind
->needs_plt
;
1221 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1225 if (eind
->func_pointer_refcount
> 0)
1227 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1228 eind
->func_pointer_refcount
= 0;
1231 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1236 elf64_x86_64_elf_object_p (bfd
*abfd
)
1238 /* Set the right machine number for an x86-64 elf64 file. */
1239 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
1244 elf32_x86_64_elf_object_p (bfd
*abfd
)
1246 /* Set the right machine number for an x86-64 elf32 file. */
1247 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
1251 /* Return TRUE if the TLS access code sequence support transition
1255 elf_x86_64_check_tls_transition (bfd
*abfd
,
1256 struct bfd_link_info
*info
,
1259 Elf_Internal_Shdr
*symtab_hdr
,
1260 struct elf_link_hash_entry
**sym_hashes
,
1261 unsigned int r_type
,
1262 const Elf_Internal_Rela
*rel
,
1263 const Elf_Internal_Rela
*relend
)
1266 unsigned long r_symndx
;
1267 bfd_boolean largepic
= FALSE
;
1268 struct elf_link_hash_entry
*h
;
1270 struct elf_x86_64_link_hash_table
*htab
;
1272 /* Get the section contents. */
1273 if (contents
== NULL
)
1275 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1276 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1279 /* FIXME: How to better handle error condition? */
1280 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1283 /* Cache the section contents for elf_link_input_bfd. */
1284 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1288 htab
= elf_x86_64_hash_table (info
);
1289 offset
= rel
->r_offset
;
1292 case R_X86_64_TLSGD
:
1293 case R_X86_64_TLSLD
:
1294 if ((rel
+ 1) >= relend
)
1297 if (r_type
== R_X86_64_TLSGD
)
1299 /* Check transition from GD access model. For 64bit, only
1300 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1301 .word 0x6666; rex64; call __tls_get_addr
1302 can transit to different access model. For 32bit, only
1303 leaq foo@tlsgd(%rip), %rdi
1304 .word 0x6666; rex64; call __tls_get_addr
1305 can transit to different access model. For largepic
1307 leaq foo@tlsgd(%rip), %rdi
1308 movabsq $__tls_get_addr@pltoff, %rax
1312 static const unsigned char call
[] = { 0x66, 0x66, 0x48, 0xe8 };
1313 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1315 if ((offset
+ 12) > sec
->size
)
1318 if (memcmp (contents
+ offset
+ 4, call
, 4) != 0)
1320 if (!ABI_64_P (abfd
)
1321 || (offset
+ 19) > sec
->size
1323 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0
1324 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1325 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1330 else if (ABI_64_P (abfd
))
1333 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1339 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1345 /* Check transition from LD access model. Only
1346 leaq foo@tlsld(%rip), %rdi;
1348 can transit to different access model. For largepic
1350 leaq foo@tlsld(%rip), %rdi
1351 movabsq $__tls_get_addr@pltoff, %rax
1355 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1357 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1360 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0)
1363 if (0xe8 != *(contents
+ offset
+ 4))
1365 if (!ABI_64_P (abfd
)
1366 || (offset
+ 19) > sec
->size
1367 || memcmp (contents
+ offset
+ 4, "\x48\xb8", 2) != 0
1368 || memcmp (contents
+ offset
+ 14, "\x48\x01\xd8\xff\xd0", 5)
1375 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1376 if (r_symndx
< symtab_hdr
->sh_info
)
1379 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1380 /* Use strncmp to check __tls_get_addr since __tls_get_addr
1381 may be versioned. */
1383 && h
->root
.root
.string
!= NULL
1385 ? ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLTOFF64
1386 : (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1387 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
))
1388 && (strncmp (h
->root
.root
.string
,
1389 "__tls_get_addr", 14) == 0));
1391 case R_X86_64_GOTTPOFF
:
1392 /* Check transition from IE access model:
1393 mov foo@gottpoff(%rip), %reg
1394 add foo@gottpoff(%rip), %reg
1397 /* Check REX prefix first. */
1398 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1400 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1401 if (val
!= 0x48 && val
!= 0x4c)
1403 /* X32 may have 0x44 REX prefix or no REX prefix. */
1404 if (ABI_64_P (abfd
))
1410 /* X32 may not have any REX prefix. */
1411 if (ABI_64_P (abfd
))
1413 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1417 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1418 if (val
!= 0x8b && val
!= 0x03)
1421 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1422 return (val
& 0xc7) == 5;
1424 case R_X86_64_GOTPC32_TLSDESC
:
1425 /* Check transition from GDesc access model:
1426 leaq x@tlsdesc(%rip), %rax
1428 Make sure it's a leaq adding rip to a 32-bit offset
1429 into any register, although it's probably almost always
1432 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1435 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1436 if ((val
& 0xfb) != 0x48)
1439 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1442 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1443 return (val
& 0xc7) == 0x05;
1445 case R_X86_64_TLSDESC_CALL
:
1446 /* Check transition from GDesc access model:
1447 call *x@tlsdesc(%rax)
1449 if (offset
+ 2 <= sec
->size
)
1451 /* Make sure that it's a call *x@tlsdesc(%rax). */
1452 static const unsigned char call
[] = { 0xff, 0x10 };
1453 return memcmp (contents
+ offset
, call
, 2) == 0;
1463 /* Return TRUE if the TLS access transition is OK or no transition
1464 will be performed. Update R_TYPE if there is a transition. */
1467 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1468 asection
*sec
, bfd_byte
*contents
,
1469 Elf_Internal_Shdr
*symtab_hdr
,
1470 struct elf_link_hash_entry
**sym_hashes
,
1471 unsigned int *r_type
, int tls_type
,
1472 const Elf_Internal_Rela
*rel
,
1473 const Elf_Internal_Rela
*relend
,
1474 struct elf_link_hash_entry
*h
,
1475 unsigned long r_symndx
)
1477 unsigned int from_type
= *r_type
;
1478 unsigned int to_type
= from_type
;
1479 bfd_boolean check
= TRUE
;
1481 /* Skip TLS transition for functions. */
1483 && (h
->type
== STT_FUNC
1484 || h
->type
== STT_GNU_IFUNC
))
1489 case R_X86_64_TLSGD
:
1490 case R_X86_64_GOTPC32_TLSDESC
:
1491 case R_X86_64_TLSDESC_CALL
:
1492 case R_X86_64_GOTTPOFF
:
1493 if (bfd_link_executable (info
))
1496 to_type
= R_X86_64_TPOFF32
;
1498 to_type
= R_X86_64_GOTTPOFF
;
1501 /* When we are called from elf_x86_64_relocate_section,
1502 CONTENTS isn't NULL and there may be additional transitions
1503 based on TLS_TYPE. */
1504 if (contents
!= NULL
)
1506 unsigned int new_to_type
= to_type
;
1508 if (bfd_link_executable (info
)
1511 && tls_type
== GOT_TLS_IE
)
1512 new_to_type
= R_X86_64_TPOFF32
;
1514 if (to_type
== R_X86_64_TLSGD
1515 || to_type
== R_X86_64_GOTPC32_TLSDESC
1516 || to_type
== R_X86_64_TLSDESC_CALL
)
1518 if (tls_type
== GOT_TLS_IE
)
1519 new_to_type
= R_X86_64_GOTTPOFF
;
1522 /* We checked the transition before when we were called from
1523 elf_x86_64_check_relocs. We only want to check the new
1524 transition which hasn't been checked before. */
1525 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1526 to_type
= new_to_type
;
1531 case R_X86_64_TLSLD
:
1532 if (bfd_link_executable (info
))
1533 to_type
= R_X86_64_TPOFF32
;
1540 /* Return TRUE if there is no transition. */
1541 if (from_type
== to_type
)
1544 /* Check if the transition can be performed. */
1546 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1547 symtab_hdr
, sym_hashes
,
1548 from_type
, rel
, relend
))
1550 reloc_howto_type
*from
, *to
;
1553 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1554 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1557 name
= h
->root
.root
.string
;
1560 struct elf_x86_64_link_hash_table
*htab
;
1562 htab
= elf_x86_64_hash_table (info
);
1567 Elf_Internal_Sym
*isym
;
1569 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1571 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1575 (*_bfd_error_handler
)
1576 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1577 "in section `%A' failed"),
1578 abfd
, sec
, from
->name
, to
->name
, name
,
1579 (unsigned long) rel
->r_offset
);
1580 bfd_set_error (bfd_error_bad_value
);
1588 /* Rename some of the generic section flags to better document how they
1590 #define need_convert_load sec_flg0
1591 #define check_relocs_failed sec_flg1
1594 elf_x86_64_need_pic (bfd
*input_bfd
, asection
*sec
,
1595 struct elf_link_hash_entry
*h
,
1596 Elf_Internal_Shdr
*symtab_hdr
,
1597 Elf_Internal_Sym
*isym
,
1598 reloc_howto_type
*howto
)
1601 const char *und
= "";
1602 const char *pic
= "";
1607 name
= h
->root
.root
.string
;
1608 switch (ELF_ST_VISIBILITY (h
->other
))
1611 v
= _("hidden symbol ");
1614 v
= _("internal symbol ");
1617 v
= _("protected symbol ");
1621 pic
= _("; recompile with -fPIC");
1625 if (!h
->def_regular
&& !h
->def_dynamic
)
1626 und
= _("undefined ");
1630 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, isym
, NULL
);
1631 pic
= _("; recompile with -fPIC");
1634 (*_bfd_error_handler
) (_("%B: relocation %s against %s%s`%s' can "
1635 "not be used when making a shared object%s"),
1636 input_bfd
, howto
->name
, und
, v
, name
, pic
);
1637 bfd_set_error (bfd_error_bad_value
);
1638 sec
->check_relocs_failed
= 1;
1642 /* Look through the relocs for a section during the first phase, and
1643 calculate needed space in the global offset table, procedure
1644 linkage table, and dynamic reloc sections. */
1647 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1649 const Elf_Internal_Rela
*relocs
)
1651 struct elf_x86_64_link_hash_table
*htab
;
1652 Elf_Internal_Shdr
*symtab_hdr
;
1653 struct elf_link_hash_entry
**sym_hashes
;
1654 const Elf_Internal_Rela
*rel
;
1655 const Elf_Internal_Rela
*rel_end
;
1657 bfd_boolean use_plt_got
;
1659 if (bfd_link_relocatable (info
))
1662 BFD_ASSERT (is_x86_64_elf (abfd
));
1664 htab
= elf_x86_64_hash_table (info
);
1668 use_plt_got
= get_elf_x86_64_backend_data (abfd
) == &elf_x86_64_arch_bed
;
1670 symtab_hdr
= &elf_symtab_hdr (abfd
);
1671 sym_hashes
= elf_sym_hashes (abfd
);
1675 rel_end
= relocs
+ sec
->reloc_count
;
1676 for (rel
= relocs
; rel
< rel_end
; rel
++)
1678 unsigned int r_type
;
1679 unsigned long r_symndx
;
1680 struct elf_link_hash_entry
*h
;
1681 struct elf_x86_64_link_hash_entry
*eh
;
1682 Elf_Internal_Sym
*isym
;
1684 bfd_boolean size_reloc
;
1686 r_symndx
= htab
->r_sym (rel
->r_info
);
1687 r_type
= ELF32_R_TYPE (rel
->r_info
);
1689 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1691 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
1696 if (r_symndx
< symtab_hdr
->sh_info
)
1698 /* A local symbol. */
1699 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1704 /* Check relocation against local STT_GNU_IFUNC symbol. */
1705 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1707 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
1712 /* Fake a STT_GNU_IFUNC symbol. */
1713 h
->type
= STT_GNU_IFUNC
;
1716 h
->forced_local
= 1;
1717 h
->root
.type
= bfd_link_hash_defined
;
1725 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1726 while (h
->root
.type
== bfd_link_hash_indirect
1727 || h
->root
.type
== bfd_link_hash_warning
)
1728 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1731 /* Check invalid x32 relocations. */
1732 if (!ABI_64_P (abfd
))
1738 case R_X86_64_DTPOFF64
:
1739 case R_X86_64_TPOFF64
:
1741 case R_X86_64_GOTOFF64
:
1742 case R_X86_64_GOT64
:
1743 case R_X86_64_GOTPCREL64
:
1744 case R_X86_64_GOTPC64
:
1745 case R_X86_64_GOTPLT64
:
1746 case R_X86_64_PLTOFF64
:
1749 name
= h
->root
.root
.string
;
1751 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1753 (*_bfd_error_handler
)
1754 (_("%B: relocation %s against symbol `%s' isn't "
1755 "supported in x32 mode"), abfd
,
1756 x86_64_elf_howto_table
[r_type
].name
, name
);
1757 bfd_set_error (bfd_error_bad_value
);
1770 case R_X86_64_PC32_BND
:
1771 case R_X86_64_PLT32_BND
:
1773 case R_X86_64_PLT32
:
1776 /* MPX PLT is supported only if elf_x86_64_arch_bed
1777 is used in 64-bit mode. */
1780 && (get_elf_x86_64_backend_data (abfd
)
1781 == &elf_x86_64_arch_bed
))
1783 elf_x86_64_hash_entry (h
)->has_bnd_reloc
= 1;
1785 /* Create the second PLT for Intel MPX support. */
1786 if (htab
->plt_bnd
== NULL
)
1788 unsigned int plt_bnd_align
;
1789 const struct elf_backend_data
*bed
;
1791 bed
= get_elf_backend_data (info
->output_bfd
);
1792 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry
) == 8
1793 && (sizeof (elf_x86_64_bnd_plt2_entry
)
1794 == sizeof (elf_x86_64_legacy_plt2_entry
)));
1797 if (htab
->elf
.dynobj
== NULL
)
1798 htab
->elf
.dynobj
= abfd
;
1800 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
1802 (bed
->dynamic_sec_flags
1807 if (htab
->plt_bnd
== NULL
1808 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
1817 case R_X86_64_GOTPCREL
:
1818 case R_X86_64_GOTPCRELX
:
1819 case R_X86_64_REX_GOTPCRELX
:
1820 case R_X86_64_GOTPCREL64
:
1821 if (htab
->elf
.dynobj
== NULL
)
1822 htab
->elf
.dynobj
= abfd
;
1823 /* Create the ifunc sections for static executables. */
1824 if (h
->type
== STT_GNU_IFUNC
1825 && !_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
,
1831 /* It is referenced by a non-shared object. */
1833 h
->root
.non_ir_ref
= 1;
1835 if (h
->type
== STT_GNU_IFUNC
)
1836 elf_tdata (info
->output_bfd
)->has_gnu_symbols
1837 |= elf_gnu_symbol_ifunc
;
1840 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
1841 symtab_hdr
, sym_hashes
,
1842 &r_type
, GOT_UNKNOWN
,
1843 rel
, rel_end
, h
, r_symndx
))
1846 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
1849 case R_X86_64_TLSLD
:
1850 htab
->tls_ld_got
.refcount
+= 1;
1853 case R_X86_64_TPOFF32
:
1854 if (!bfd_link_executable (info
) && ABI_64_P (abfd
))
1855 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
1856 &x86_64_elf_howto_table
[r_type
]);
1858 eh
->has_got_reloc
= 1;
1861 case R_X86_64_GOTTPOFF
:
1862 if (!bfd_link_executable (info
))
1863 info
->flags
|= DF_STATIC_TLS
;
1866 case R_X86_64_GOT32
:
1867 case R_X86_64_GOTPCREL
:
1868 case R_X86_64_GOTPCRELX
:
1869 case R_X86_64_REX_GOTPCRELX
:
1870 case R_X86_64_TLSGD
:
1871 case R_X86_64_GOT64
:
1872 case R_X86_64_GOTPCREL64
:
1873 case R_X86_64_GOTPLT64
:
1874 case R_X86_64_GOTPC32_TLSDESC
:
1875 case R_X86_64_TLSDESC_CALL
:
1876 /* This symbol requires a global offset table entry. */
1878 int tls_type
, old_tls_type
;
1882 default: tls_type
= GOT_NORMAL
; break;
1883 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
1884 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
1885 case R_X86_64_GOTPC32_TLSDESC
:
1886 case R_X86_64_TLSDESC_CALL
:
1887 tls_type
= GOT_TLS_GDESC
; break;
1892 h
->got
.refcount
+= 1;
1893 old_tls_type
= eh
->tls_type
;
1897 bfd_signed_vma
*local_got_refcounts
;
1899 /* This is a global offset table entry for a local symbol. */
1900 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1901 if (local_got_refcounts
== NULL
)
1905 size
= symtab_hdr
->sh_info
;
1906 size
*= sizeof (bfd_signed_vma
)
1907 + sizeof (bfd_vma
) + sizeof (char);
1908 local_got_refcounts
= ((bfd_signed_vma
*)
1909 bfd_zalloc (abfd
, size
));
1910 if (local_got_refcounts
== NULL
)
1912 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1913 elf_x86_64_local_tlsdesc_gotent (abfd
)
1914 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
1915 elf_x86_64_local_got_tls_type (abfd
)
1916 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
1918 local_got_refcounts
[r_symndx
] += 1;
1920 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
1923 /* If a TLS symbol is accessed using IE at least once,
1924 there is no point to use dynamic model for it. */
1925 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1926 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
1927 || tls_type
!= GOT_TLS_IE
))
1929 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
1930 tls_type
= old_tls_type
;
1931 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
1932 && GOT_TLS_GD_ANY_P (tls_type
))
1933 tls_type
|= old_tls_type
;
1937 name
= h
->root
.root
.string
;
1939 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
1941 (*_bfd_error_handler
)
1942 (_("%B: '%s' accessed both as normal and thread local symbol"),
1944 bfd_set_error (bfd_error_bad_value
);
1949 if (old_tls_type
!= tls_type
)
1952 eh
->tls_type
= tls_type
;
1954 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1959 case R_X86_64_GOTOFF64
:
1960 case R_X86_64_GOTPC32
:
1961 case R_X86_64_GOTPC64
:
1964 eh
->has_got_reloc
= 1;
1965 if (htab
->elf
.sgot
== NULL
)
1967 if (htab
->elf
.dynobj
== NULL
)
1968 htab
->elf
.dynobj
= abfd
;
1969 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
1975 case R_X86_64_PLT32
:
1976 case R_X86_64_PLT32_BND
:
1977 /* This symbol requires a procedure linkage table entry. We
1978 actually build the entry in adjust_dynamic_symbol,
1979 because this might be a case of linking PIC code which is
1980 never referenced by a dynamic object, in which case we
1981 don't need to generate a procedure linkage table entry
1984 /* If this is a local symbol, we resolve it directly without
1985 creating a procedure linkage table entry. */
1989 eh
->has_got_reloc
= 1;
1991 h
->plt
.refcount
+= 1;
1994 case R_X86_64_PLTOFF64
:
1995 /* This tries to form the 'address' of a function relative
1996 to GOT. For global symbols we need a PLT entry. */
2000 h
->plt
.refcount
+= 1;
2004 case R_X86_64_SIZE32
:
2005 case R_X86_64_SIZE64
:
2010 if (!ABI_64_P (abfd
))
2015 /* Check relocation overflow as these relocs may lead to
2016 run-time relocation overflow. Don't error out for
2017 sections we don't care about, such as debug sections or
2018 when relocation overflow check is disabled. */
2019 if (!info
->no_reloc_overflow_check
2020 && (bfd_link_pic (info
)
2021 || (bfd_link_executable (info
)
2025 && (sec
->flags
& SEC_READONLY
) == 0))
2026 && (sec
->flags
& SEC_ALLOC
) != 0)
2027 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
2028 &x86_64_elf_howto_table
[r_type
]);
2034 case R_X86_64_PC32_BND
:
2038 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2039 eh
->has_non_got_reloc
= 1;
2040 /* STT_GNU_IFUNC symbol must go through PLT even if it is
2041 locally defined and undefined symbol may turn out to be
2042 a STT_GNU_IFUNC symbol later. */
2044 && (bfd_link_executable (info
)
2045 || ((h
->type
== STT_GNU_IFUNC
2046 || h
->root
.type
== bfd_link_hash_undefweak
2047 || h
->root
.type
== bfd_link_hash_undefined
)
2048 && SYMBOLIC_BIND (info
, h
))))
2050 /* If this reloc is in a read-only section, we might
2051 need a copy reloc. We can't check reliably at this
2052 stage whether the section is read-only, as input
2053 sections have not yet been mapped to output sections.
2054 Tentatively set the flag for now, and correct in
2055 adjust_dynamic_symbol. */
2058 /* We may need a .plt entry if the function this reloc
2059 refers to is in a shared lib. */
2060 h
->plt
.refcount
+= 1;
2061 if (r_type
== R_X86_64_PC32
)
2063 /* Since something like ".long foo - ." may be used
2064 as pointer, make sure that PLT is used if foo is
2065 a function defined in a shared library. */
2066 if ((sec
->flags
& SEC_CODE
) == 0)
2067 h
->pointer_equality_needed
= 1;
2069 else if (r_type
!= R_X86_64_PC32_BND
2070 && r_type
!= R_X86_64_PC64
)
2072 h
->pointer_equality_needed
= 1;
2073 /* At run-time, R_X86_64_64 can be resolved for both
2074 x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2075 can only be resolved for x32. */
2076 if ((sec
->flags
& SEC_READONLY
) == 0
2077 && (r_type
== R_X86_64_64
2078 || (!ABI_64_P (abfd
)
2079 && (r_type
== R_X86_64_32
2080 || r_type
== R_X86_64_32S
))))
2081 eh
->func_pointer_refcount
+= 1;
2087 /* If we are creating a shared library, and this is a reloc
2088 against a global symbol, or a non PC relative reloc
2089 against a local symbol, then we need to copy the reloc
2090 into the shared library. However, if we are linking with
2091 -Bsymbolic, we do not need to copy a reloc against a
2092 global symbol which is defined in an object we are
2093 including in the link (i.e., DEF_REGULAR is set). At
2094 this point we have not seen all the input files, so it is
2095 possible that DEF_REGULAR is not set now but will be set
2096 later (it is never cleared). In case of a weak definition,
2097 DEF_REGULAR may be cleared later by a strong definition in
2098 a shared library. We account for that possibility below by
2099 storing information in the relocs_copied field of the hash
2100 table entry. A similar situation occurs when creating
2101 shared libraries and symbol visibility changes render the
2104 If on the other hand, we are creating an executable, we
2105 may need to keep relocations for symbols satisfied by a
2106 dynamic library if we manage to avoid copy relocs for the
2108 if ((bfd_link_pic (info
)
2109 && (sec
->flags
& SEC_ALLOC
) != 0
2110 && (! IS_X86_64_PCREL_TYPE (r_type
)
2112 && (! (bfd_link_pie (info
)
2113 || SYMBOLIC_BIND (info
, h
))
2114 || h
->root
.type
== bfd_link_hash_defweak
2115 || !h
->def_regular
))))
2116 || (ELIMINATE_COPY_RELOCS
2117 && !bfd_link_pic (info
)
2118 && (sec
->flags
& SEC_ALLOC
) != 0
2120 && (h
->root
.type
== bfd_link_hash_defweak
2121 || !h
->def_regular
)))
2123 struct elf_dyn_relocs
*p
;
2124 struct elf_dyn_relocs
**head
;
2126 /* We must copy these reloc types into the output file.
2127 Create a reloc section in dynobj and make room for
2131 if (htab
->elf
.dynobj
== NULL
)
2132 htab
->elf
.dynobj
= abfd
;
2134 sreloc
= _bfd_elf_make_dynamic_reloc_section
2135 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
2136 abfd
, /*rela?*/ TRUE
);
2142 /* If this is a global symbol, we count the number of
2143 relocations we need for this symbol. */
2145 head
= &eh
->dyn_relocs
;
2148 /* Track dynamic relocs needed for local syms too.
2149 We really need local syms available to do this
2154 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2159 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2163 /* Beware of type punned pointers vs strict aliasing
2165 vpp
= &(elf_section_data (s
)->local_dynrel
);
2166 head
= (struct elf_dyn_relocs
**)vpp
;
2170 if (p
== NULL
|| p
->sec
!= sec
)
2172 bfd_size_type amt
= sizeof *p
;
2174 p
= ((struct elf_dyn_relocs
*)
2175 bfd_alloc (htab
->elf
.dynobj
, amt
));
2186 /* Count size relocation as PC-relative relocation. */
2187 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
2192 /* This relocation describes the C++ object vtable hierarchy.
2193 Reconstruct it for later use during GC. */
2194 case R_X86_64_GNU_VTINHERIT
:
2195 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2199 /* This relocation describes which C++ vtable entries are actually
2200 used. Record for later use during GC. */
2201 case R_X86_64_GNU_VTENTRY
:
2202 BFD_ASSERT (h
!= NULL
);
2204 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2214 && h
->plt
.refcount
> 0
2215 && (((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2216 || h
->got
.refcount
> 0)
2217 && htab
->plt_got
== NULL
)
2219 /* Create the GOT procedure linkage table. */
2220 unsigned int plt_got_align
;
2221 const struct elf_backend_data
*bed
;
2223 bed
= get_elf_backend_data (info
->output_bfd
);
2224 BFD_ASSERT (sizeof (elf_x86_64_legacy_plt2_entry
) == 8
2225 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2226 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2229 if (htab
->elf
.dynobj
== NULL
)
2230 htab
->elf
.dynobj
= abfd
;
2232 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2234 (bed
->dynamic_sec_flags
2239 if (htab
->plt_got
== NULL
2240 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2246 if ((r_type
== R_X86_64_GOTPCREL
2247 || r_type
== R_X86_64_GOTPCRELX
2248 || r_type
== R_X86_64_REX_GOTPCRELX
)
2249 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2250 sec
->need_convert_load
= 1;
2256 /* Return the section that should be marked against GC for a given
2260 elf_x86_64_gc_mark_hook (asection
*sec
,
2261 struct bfd_link_info
*info
,
2262 Elf_Internal_Rela
*rel
,
2263 struct elf_link_hash_entry
*h
,
2264 Elf_Internal_Sym
*sym
)
2267 switch (ELF32_R_TYPE (rel
->r_info
))
2269 case R_X86_64_GNU_VTINHERIT
:
2270 case R_X86_64_GNU_VTENTRY
:
2274 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2277 /* Update the got entry reference counts for the section being removed. */
2280 elf_x86_64_gc_sweep_hook (bfd
*abfd
, struct bfd_link_info
*info
,
2282 const Elf_Internal_Rela
*relocs
)
2284 struct elf_x86_64_link_hash_table
*htab
;
2285 Elf_Internal_Shdr
*symtab_hdr
;
2286 struct elf_link_hash_entry
**sym_hashes
;
2287 bfd_signed_vma
*local_got_refcounts
;
2288 const Elf_Internal_Rela
*rel
, *relend
;
2290 if (bfd_link_relocatable (info
))
2293 htab
= elf_x86_64_hash_table (info
);
2297 elf_section_data (sec
)->local_dynrel
= NULL
;
2299 symtab_hdr
= &elf_symtab_hdr (abfd
);
2300 sym_hashes
= elf_sym_hashes (abfd
);
2301 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2303 htab
= elf_x86_64_hash_table (info
);
2304 relend
= relocs
+ sec
->reloc_count
;
2305 for (rel
= relocs
; rel
< relend
; rel
++)
2307 unsigned long r_symndx
;
2308 unsigned int r_type
;
2309 struct elf_link_hash_entry
*h
= NULL
;
2310 bfd_boolean pointer_reloc
;
2312 r_symndx
= htab
->r_sym (rel
->r_info
);
2313 if (r_symndx
>= symtab_hdr
->sh_info
)
2315 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2316 while (h
->root
.type
== bfd_link_hash_indirect
2317 || h
->root
.type
== bfd_link_hash_warning
)
2318 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2322 /* A local symbol. */
2323 Elf_Internal_Sym
*isym
;
2325 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2328 /* Check relocation against local STT_GNU_IFUNC symbol. */
2330 && ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
2332 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
, FALSE
);
2340 struct elf_x86_64_link_hash_entry
*eh
;
2341 struct elf_dyn_relocs
**pp
;
2342 struct elf_dyn_relocs
*p
;
2344 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2346 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
2349 /* Everything must go for SEC. */
2355 r_type
= ELF32_R_TYPE (rel
->r_info
);
2356 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, NULL
,
2357 symtab_hdr
, sym_hashes
,
2358 &r_type
, GOT_UNKNOWN
,
2359 rel
, relend
, h
, r_symndx
))
2362 pointer_reloc
= FALSE
;
2365 case R_X86_64_TLSLD
:
2366 if (htab
->tls_ld_got
.refcount
> 0)
2367 htab
->tls_ld_got
.refcount
-= 1;
2370 case R_X86_64_TLSGD
:
2371 case R_X86_64_GOTPC32_TLSDESC
:
2372 case R_X86_64_TLSDESC_CALL
:
2373 case R_X86_64_GOTTPOFF
:
2374 case R_X86_64_GOT32
:
2375 case R_X86_64_GOTPCREL
:
2376 case R_X86_64_GOTPCRELX
:
2377 case R_X86_64_REX_GOTPCRELX
:
2378 case R_X86_64_GOT64
:
2379 case R_X86_64_GOTPCREL64
:
2380 case R_X86_64_GOTPLT64
:
2383 if (h
->got
.refcount
> 0)
2384 h
->got
.refcount
-= 1;
2385 if (h
->type
== STT_GNU_IFUNC
)
2387 if (h
->plt
.refcount
> 0)
2388 h
->plt
.refcount
-= 1;
2391 else if (local_got_refcounts
!= NULL
)
2393 if (local_got_refcounts
[r_symndx
] > 0)
2394 local_got_refcounts
[r_symndx
] -= 1;
2400 pointer_reloc
= !ABI_64_P (abfd
);
2404 pointer_reloc
= TRUE
;
2410 case R_X86_64_PC32_BND
:
2412 case R_X86_64_SIZE32
:
2413 case R_X86_64_SIZE64
:
2415 if (bfd_link_pic (info
)
2416 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2420 case R_X86_64_PLT32
:
2421 case R_X86_64_PLT32_BND
:
2422 case R_X86_64_PLTOFF64
:
2425 if (h
->plt
.refcount
> 0)
2426 h
->plt
.refcount
-= 1;
2427 if (pointer_reloc
&& (sec
->flags
& SEC_READONLY
) == 0)
2429 struct elf_x86_64_link_hash_entry
*eh
2430 = (struct elf_x86_64_link_hash_entry
*) h
;
2431 if (eh
->func_pointer_refcount
> 0)
2432 eh
->func_pointer_refcount
-= 1;
2445 /* Remove undefined weak symbol from the dynamic symbol table if it
2446 is resolved to 0. */
2449 elf_x86_64_fixup_symbol (struct bfd_link_info
*info
,
2450 struct elf_link_hash_entry
*h
)
2452 if (h
->dynindx
!= -1
2453 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2454 elf_x86_64_hash_entry (h
)))
2457 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2463 /* Adjust a symbol defined by a dynamic object and referenced by a
2464 regular object. The current definition is in some section of the
2465 dynamic object, but we're not including those sections. We have to
2466 change the definition to something the rest of the link can
2470 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2471 struct elf_link_hash_entry
*h
)
2473 struct elf_x86_64_link_hash_table
*htab
;
2475 struct elf_x86_64_link_hash_entry
*eh
;
2476 struct elf_dyn_relocs
*p
;
2478 /* STT_GNU_IFUNC symbol must go through PLT. */
2479 if (h
->type
== STT_GNU_IFUNC
)
2481 /* All local STT_GNU_IFUNC references must be treate as local
2482 calls via local PLT. */
2484 && SYMBOL_CALLS_LOCAL (info
, h
))
2486 bfd_size_type pc_count
= 0, count
= 0;
2487 struct elf_dyn_relocs
**pp
;
2489 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2490 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2492 pc_count
+= p
->pc_count
;
2493 p
->count
-= p
->pc_count
;
2502 if (pc_count
|| count
)
2506 if (h
->plt
.refcount
<= 0)
2507 h
->plt
.refcount
= 1;
2509 h
->plt
.refcount
+= 1;
2513 if (h
->plt
.refcount
<= 0)
2515 h
->plt
.offset
= (bfd_vma
) -1;
2521 /* If this is a function, put it in the procedure linkage table. We
2522 will fill in the contents of the procedure linkage table later,
2523 when we know the address of the .got section. */
2524 if (h
->type
== STT_FUNC
2527 if (h
->plt
.refcount
<= 0
2528 || SYMBOL_CALLS_LOCAL (info
, h
)
2529 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2530 && h
->root
.type
== bfd_link_hash_undefweak
))
2532 /* This case can occur if we saw a PLT32 reloc in an input
2533 file, but the symbol was never referred to by a dynamic
2534 object, or if all references were garbage collected. In
2535 such a case, we don't actually need to build a procedure
2536 linkage table, and we can just do a PC32 reloc instead. */
2537 h
->plt
.offset
= (bfd_vma
) -1;
2544 /* It's possible that we incorrectly decided a .plt reloc was
2545 needed for an R_X86_64_PC32 reloc to a non-function sym in
2546 check_relocs. We can't decide accurately between function and
2547 non-function syms in check-relocs; Objects loaded later in
2548 the link may change h->type. So fix it now. */
2549 h
->plt
.offset
= (bfd_vma
) -1;
2551 /* If this is a weak symbol, and there is a real definition, the
2552 processor independent code will have arranged for us to see the
2553 real definition first, and we can just use the same value. */
2554 if (h
->u
.weakdef
!= NULL
)
2556 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2557 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2558 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2559 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2560 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2562 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2563 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2564 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
2569 /* This is a reference to a symbol defined by a dynamic object which
2570 is not a function. */
2572 /* If we are creating a shared library, we must presume that the
2573 only references to the symbol are via the global offset table.
2574 For such cases we need not do anything here; the relocations will
2575 be handled correctly by relocate_section. */
2576 if (!bfd_link_executable (info
))
2579 /* If there are no references to this symbol that do not use the
2580 GOT, we don't need to generate a copy reloc. */
2581 if (!h
->non_got_ref
)
2584 /* If -z nocopyreloc was given, we won't generate them either. */
2585 if (info
->nocopyreloc
)
2591 if (ELIMINATE_COPY_RELOCS
)
2593 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2594 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2596 s
= p
->sec
->output_section
;
2597 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2601 /* If we didn't find any dynamic relocs in read-only sections, then
2602 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2610 /* We must allocate the symbol in our .dynbss section, which will
2611 become part of the .bss section of the executable. There will be
2612 an entry for this symbol in the .dynsym section. The dynamic
2613 object will contain position independent code, so all references
2614 from the dynamic object to this symbol will go through the global
2615 offset table. The dynamic linker will use the .dynsym entry to
2616 determine the address it must put in the global offset table, so
2617 both the dynamic object and the regular object will refer to the
2618 same memory location for the variable. */
2620 htab
= elf_x86_64_hash_table (info
);
2624 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2625 to copy the initial value out of the dynamic object and into the
2626 runtime process image. */
2627 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2629 const struct elf_backend_data
*bed
;
2630 bed
= get_elf_backend_data (info
->output_bfd
);
2631 htab
->srelbss
->size
+= bed
->s
->sizeof_rela
;
2637 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2640 /* Allocate space in .plt, .got and associated reloc sections for
2644 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
2646 struct bfd_link_info
*info
;
2647 struct elf_x86_64_link_hash_table
*htab
;
2648 struct elf_x86_64_link_hash_entry
*eh
;
2649 struct elf_dyn_relocs
*p
;
2650 const struct elf_backend_data
*bed
;
2651 unsigned int plt_entry_size
;
2652 bfd_boolean resolved_to_zero
;
2654 if (h
->root
.type
== bfd_link_hash_indirect
)
2657 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2659 info
= (struct bfd_link_info
*) inf
;
2660 htab
= elf_x86_64_hash_table (info
);
2663 bed
= get_elf_backend_data (info
->output_bfd
);
2664 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
2666 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, eh
);
2668 /* We can't use the GOT PLT if pointer equality is needed since
2669 finish_dynamic_symbol won't clear symbol value and the dynamic
2670 linker won't update the GOT slot. We will get into an infinite
2671 loop at run-time. */
2672 if (htab
->plt_got
!= NULL
2673 && h
->type
!= STT_GNU_IFUNC
2674 && !h
->pointer_equality_needed
2675 && h
->plt
.refcount
> 0
2676 && h
->got
.refcount
> 0)
2678 /* Don't use the regular PLT if there are both GOT and GOTPLT
2680 h
->plt
.offset
= (bfd_vma
) -1;
2682 /* Use the GOT PLT. */
2683 eh
->plt_got
.refcount
= 1;
2686 /* Clear the reference count of function pointer relocations if
2687 symbol isn't a normal function. */
2688 if (h
->type
!= STT_FUNC
)
2689 eh
->func_pointer_refcount
= 0;
2691 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2692 here if it is defined and referenced in a non-shared object. */
2693 if (h
->type
== STT_GNU_IFUNC
2696 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
2698 &htab
->readonly_dynrelocs_against_ifunc
,
2703 asection
*s
= htab
->plt_bnd
;
2704 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
2706 /* Use the .plt.bnd section if it is created. */
2707 eh
->plt_bnd
.offset
= s
->size
;
2709 /* Make room for this entry in the .plt.bnd section. */
2710 s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2718 /* Don't create the PLT entry if there are only function pointer
2719 relocations which can be resolved at run-time. */
2720 else if (htab
->elf
.dynamic_sections_created
2721 && (h
->plt
.refcount
> eh
->func_pointer_refcount
2722 || eh
->plt_got
.refcount
> 0))
2724 bfd_boolean use_plt_got
;
2726 /* Clear the reference count of function pointer relocations
2728 eh
->func_pointer_refcount
= 0;
2730 if ((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2732 /* Don't use the regular PLT for DF_BIND_NOW. */
2733 h
->plt
.offset
= (bfd_vma
) -1;
2735 /* Use the GOT PLT. */
2736 h
->got
.refcount
= 1;
2737 eh
->plt_got
.refcount
= 1;
2740 use_plt_got
= eh
->plt_got
.refcount
> 0;
2742 /* Make sure this symbol is output as a dynamic symbol.
2743 Undefined weak syms won't yet be marked as dynamic. */
2744 if (h
->dynindx
== -1
2746 && !resolved_to_zero
)
2748 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2752 if (bfd_link_pic (info
)
2753 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
2755 asection
*s
= htab
->elf
.splt
;
2756 asection
*bnd_s
= htab
->plt_bnd
;
2757 asection
*got_s
= htab
->plt_got
;
2759 /* If this is the first .plt entry, make room for the special
2760 first entry. The .plt section is used by prelink to undo
2761 prelinking for dynamic relocations. */
2763 s
->size
= plt_entry_size
;
2766 eh
->plt_got
.offset
= got_s
->size
;
2769 h
->plt
.offset
= s
->size
;
2771 eh
->plt_bnd
.offset
= bnd_s
->size
;
2774 /* If this symbol is not defined in a regular file, and we are
2775 not generating a shared library, then set the symbol to this
2776 location in the .plt. This is required to make function
2777 pointers compare as equal between the normal executable and
2778 the shared library. */
2779 if (! bfd_link_pic (info
)
2784 /* We need to make a call to the entry of the GOT PLT
2785 instead of regular PLT entry. */
2786 h
->root
.u
.def
.section
= got_s
;
2787 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
2793 /* We need to make a call to the entry of the second
2794 PLT instead of regular PLT entry. */
2795 h
->root
.u
.def
.section
= bnd_s
;
2796 h
->root
.u
.def
.value
= eh
->plt_bnd
.offset
;
2800 h
->root
.u
.def
.section
= s
;
2801 h
->root
.u
.def
.value
= h
->plt
.offset
;
2806 /* Make room for this entry. */
2808 got_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2811 s
->size
+= plt_entry_size
;
2813 bnd_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
2815 /* We also need to make an entry in the .got.plt section,
2816 which will be placed in the .got section by the linker
2818 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
2820 /* There should be no PLT relocation against resolved
2821 undefined weak symbol in executable. */
2822 if (!resolved_to_zero
)
2824 /* We also need to make an entry in the .rela.plt
2826 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2827 htab
->elf
.srelplt
->reloc_count
++;
2833 eh
->plt_got
.offset
= (bfd_vma
) -1;
2834 h
->plt
.offset
= (bfd_vma
) -1;
2840 eh
->plt_got
.offset
= (bfd_vma
) -1;
2841 h
->plt
.offset
= (bfd_vma
) -1;
2845 eh
->tlsdesc_got
= (bfd_vma
) -1;
2847 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2848 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
2849 if (h
->got
.refcount
> 0
2850 && bfd_link_executable (info
)
2852 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
2854 h
->got
.offset
= (bfd_vma
) -1;
2856 else if (h
->got
.refcount
> 0)
2860 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
2862 /* Make sure this symbol is output as a dynamic symbol.
2863 Undefined weak syms won't yet be marked as dynamic. */
2864 if (h
->dynindx
== -1
2866 && !resolved_to_zero
)
2868 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2872 if (GOT_TLS_GDESC_P (tls_type
))
2874 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
2875 - elf_x86_64_compute_jump_table_size (htab
);
2876 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2877 h
->got
.offset
= (bfd_vma
) -2;
2879 if (! GOT_TLS_GDESC_P (tls_type
)
2880 || GOT_TLS_GD_P (tls_type
))
2883 h
->got
.offset
= s
->size
;
2884 s
->size
+= GOT_ENTRY_SIZE
;
2885 if (GOT_TLS_GD_P (tls_type
))
2886 s
->size
+= GOT_ENTRY_SIZE
;
2888 dyn
= htab
->elf
.dynamic_sections_created
;
2889 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2890 and two if global. R_X86_64_GOTTPOFF needs one dynamic
2891 relocation. No dynamic relocation against resolved undefined
2892 weak symbol in executable. */
2893 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
2894 || tls_type
== GOT_TLS_IE
)
2895 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2896 else if (GOT_TLS_GD_P (tls_type
))
2897 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
2898 else if (! GOT_TLS_GDESC_P (tls_type
)
2899 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2900 && !resolved_to_zero
)
2901 || h
->root
.type
!= bfd_link_hash_undefweak
)
2902 && (bfd_link_pic (info
)
2903 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
2904 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2905 if (GOT_TLS_GDESC_P (tls_type
))
2907 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
2908 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2912 h
->got
.offset
= (bfd_vma
) -1;
2914 if (eh
->dyn_relocs
== NULL
)
2917 /* In the shared -Bsymbolic case, discard space allocated for
2918 dynamic pc-relative relocs against symbols which turn out to be
2919 defined in regular objects. For the normal shared case, discard
2920 space for pc-relative relocs that have become local due to symbol
2921 visibility changes. */
2923 if (bfd_link_pic (info
))
2925 /* Relocs that use pc_count are those that appear on a call
2926 insn, or certain REL relocs that can generated via assembly.
2927 We want calls to protected symbols to resolve directly to the
2928 function rather than going via the plt. If people want
2929 function pointer comparisons to work as expected then they
2930 should avoid writing weird assembly. */
2931 if (SYMBOL_CALLS_LOCAL (info
, h
))
2933 struct elf_dyn_relocs
**pp
;
2935 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2937 p
->count
-= p
->pc_count
;
2946 /* Also discard relocs on undefined weak syms with non-default
2947 visibility or in PIE. */
2948 if (eh
->dyn_relocs
!= NULL
)
2950 if (h
->root
.type
== bfd_link_hash_undefweak
)
2952 /* Undefined weak symbol is never bound locally in shared
2954 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2955 || resolved_to_zero
)
2956 eh
->dyn_relocs
= NULL
;
2957 else if (h
->dynindx
== -1
2958 && ! h
->forced_local
2959 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2962 /* For PIE, discard space for pc-relative relocs against
2963 symbols which turn out to need copy relocs. */
2964 else if (bfd_link_executable (info
)
2965 && (h
->needs_copy
|| eh
->needs_copy
)
2969 struct elf_dyn_relocs
**pp
;
2971 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2973 if (p
->pc_count
!= 0)
2981 else if (ELIMINATE_COPY_RELOCS
)
2983 /* For the non-shared case, discard space for relocs against
2984 symbols which turn out to need copy relocs or are not
2985 dynamic. Keep dynamic relocations for run-time function
2986 pointer initialization. */
2988 if ((!h
->non_got_ref
2989 || eh
->func_pointer_refcount
> 0
2990 || (h
->root
.type
== bfd_link_hash_undefweak
2991 && !resolved_to_zero
))
2994 || (htab
->elf
.dynamic_sections_created
2995 && (h
->root
.type
== bfd_link_hash_undefweak
2996 || h
->root
.type
== bfd_link_hash_undefined
))))
2998 /* Make sure this symbol is output as a dynamic symbol.
2999 Undefined weak syms won't yet be marked as dynamic. */
3000 if (h
->dynindx
== -1
3001 && ! h
->forced_local
3002 && ! resolved_to_zero
3003 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3006 /* If that succeeded, we know we'll be keeping all the
3008 if (h
->dynindx
!= -1)
3012 eh
->dyn_relocs
= NULL
;
3013 eh
->func_pointer_refcount
= 0;
3018 /* Finally, allocate space. */
3019 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3023 sreloc
= elf_section_data (p
->sec
)->sreloc
;
3025 BFD_ASSERT (sreloc
!= NULL
);
3027 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3033 /* Allocate space in .plt, .got and associated reloc sections for
3034 local dynamic relocs. */
3037 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
3039 struct elf_link_hash_entry
*h
3040 = (struct elf_link_hash_entry
*) *slot
;
3042 if (h
->type
!= STT_GNU_IFUNC
3046 || h
->root
.type
!= bfd_link_hash_defined
)
3049 return elf_x86_64_allocate_dynrelocs (h
, inf
);
3052 /* Find any dynamic relocs that apply to read-only sections. */
3055 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
3058 struct elf_x86_64_link_hash_entry
*eh
;
3059 struct elf_dyn_relocs
*p
;
3061 /* Skip local IFUNC symbols. */
3062 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
3065 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3066 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3068 asection
*s
= p
->sec
->output_section
;
3070 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
3072 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3074 info
->flags
|= DF_TEXTREL
;
3076 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3077 || info
->error_textrel
)
3078 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
3079 p
->sec
->owner
, h
->root
.root
.string
,
3082 /* Not an error, just cut short the traversal. */
3089 /* With the local symbol, foo, we convert
3090 mov foo@GOTPCREL(%rip), %reg
3094 call/jmp *foo@GOTPCREL(%rip)
3096 nop call foo/jmp foo nop
3097 When PIC is false, convert
3098 test %reg, foo@GOTPCREL(%rip)
3102 binop foo@GOTPCREL(%rip), %reg
3105 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
3109 elf_x86_64_convert_load (bfd
*abfd
, asection
*sec
,
3110 struct bfd_link_info
*link_info
)
3112 Elf_Internal_Shdr
*symtab_hdr
;
3113 Elf_Internal_Rela
*internal_relocs
;
3114 Elf_Internal_Rela
*irel
, *irelend
;
3116 struct elf_x86_64_link_hash_table
*htab
;
3117 bfd_boolean changed_contents
;
3118 bfd_boolean changed_relocs
;
3119 bfd_signed_vma
*local_got_refcounts
;
3120 bfd_vma maxpagesize
;
3122 bfd_boolean require_reloc_pc32
;
3124 /* Don't even try to convert non-ELF outputs. */
3125 if (!is_elf_hash_table (link_info
->hash
))
3128 /* Nothing to do if there is no need or no output. */
3129 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
3130 || sec
->need_convert_load
== 0
3131 || bfd_is_abs_section (sec
->output_section
))
3134 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3136 /* Load the relocations for this section. */
3137 internal_relocs
= (_bfd_elf_link_read_relocs
3138 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
3139 link_info
->keep_memory
));
3140 if (internal_relocs
== NULL
)
3143 htab
= elf_x86_64_hash_table (link_info
);
3144 changed_contents
= FALSE
;
3145 changed_relocs
= FALSE
;
3146 local_got_refcounts
= elf_local_got_refcounts (abfd
);
3147 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
3149 /* Get the section contents. */
3150 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
3151 contents
= elf_section_data (sec
)->this_hdr
.contents
;
3154 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
3158 is_pic
= bfd_link_pic (link_info
);
3160 /* TRUE if we can convert only to R_X86_64_PC32. Enable it for
3163 = link_info
->disable_target_specific_optimizations
> 1;
3165 irelend
= internal_relocs
+ sec
->reloc_count
;
3166 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3168 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
3169 unsigned int r_symndx
= htab
->r_sym (irel
->r_info
);
3171 struct elf_link_hash_entry
*h
;
3175 bfd_signed_vma raddend
;
3176 unsigned int opcode
;
3179 bfd_boolean to_reloc_pc32
;
3181 relocx
= (r_type
== R_X86_64_GOTPCRELX
3182 || r_type
== R_X86_64_REX_GOTPCRELX
);
3183 if (!relocx
&& r_type
!= R_X86_64_GOTPCREL
)
3186 roff
= irel
->r_offset
;
3187 if (roff
< (r_type
== R_X86_64_REX_GOTPCRELX
? 3 : 2))
3190 raddend
= irel
->r_addend
;
3191 /* Addend for 32-bit PC-relative relocation must be -4. */
3195 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
3197 /* Convert mov to lea since it has been done for a while. */
3200 /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
3201 for call, jmp or one of adc, add, and, cmp, or, sbb, sub,
3202 test, xor instructions. */
3207 /* We convert only to R_X86_64_PC32:
3209 2. R_X86_64_GOTPCREL since we can't modify REX byte.
3210 3. require_reloc_pc32 is true.
3213 to_reloc_pc32
= (opcode
== 0xff
3215 || require_reloc_pc32
3218 /* Get the symbol referred to by the reloc. */
3219 if (r_symndx
< symtab_hdr
->sh_info
)
3221 Elf_Internal_Sym
*isym
;
3223 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
3226 symtype
= ELF_ST_TYPE (isym
->st_info
);
3228 /* STT_GNU_IFUNC must keep GOTPCREL relocations and skip
3229 relocation against undefined symbols. */
3230 if (symtype
== STT_GNU_IFUNC
|| isym
->st_shndx
== SHN_UNDEF
)
3233 if (isym
->st_shndx
== SHN_ABS
)
3234 tsec
= bfd_abs_section_ptr
;
3235 else if (isym
->st_shndx
== SHN_COMMON
)
3236 tsec
= bfd_com_section_ptr
;
3237 else if (isym
->st_shndx
== SHN_X86_64_LCOMMON
)
3238 tsec
= &_bfd_elf_large_com_section
;
3240 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
3243 toff
= isym
->st_value
;
3247 indx
= r_symndx
- symtab_hdr
->sh_info
;
3248 h
= elf_sym_hashes (abfd
)[indx
];
3249 BFD_ASSERT (h
!= NULL
);
3251 while (h
->root
.type
== bfd_link_hash_indirect
3252 || h
->root
.type
== bfd_link_hash_warning
)
3253 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3255 /* STT_GNU_IFUNC must keep GOTPCREL relocations. We also
3256 avoid optimizing GOTPCREL relocations againt _DYNAMIC
3257 since ld.so may use its link-time address. */
3258 if (h
->type
== STT_GNU_IFUNC
)
3261 /* Undefined weak symbol is only bound locally in executable
3262 and its reference is resolved as 0 without relocation
3263 overflow. We can only perform this optimization for
3264 GOTPCRELX relocations since we need to modify REX byte.
3265 It is OK convert mov with R_X86_64_GOTPCREL to
3267 if ((relocx
|| opcode
== 0x8b)
3268 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
,
3269 elf_x86_64_hash_entry (h
)))
3273 /* Skip for branch instructions since R_X86_64_PC32
3275 if (require_reloc_pc32
)
3280 /* For non-branch instructions, we can convert to
3281 R_X86_64_32/R_X86_64_32S since we know if there
3283 to_reloc_pc32
= FALSE
;
3286 /* Since we don't know the current PC when PIC is true,
3287 we can't convert to R_X86_64_PC32. */
3288 if (to_reloc_pc32
&& is_pic
)
3293 else if ((h
->def_regular
3294 || h
->root
.type
== bfd_link_hash_defined
3295 || h
->root
.type
== bfd_link_hash_defweak
)
3296 && h
!= htab
->elf
.hdynamic
3297 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
3299 /* bfd_link_hash_new or bfd_link_hash_undefined is
3300 set by an assignment in a linker script in
3301 bfd_elf_record_link_assignment. */
3303 && (h
->root
.type
== bfd_link_hash_new
3304 || h
->root
.type
== bfd_link_hash_undefined
))
3306 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */
3307 if (require_reloc_pc32
)
3311 tsec
= h
->root
.u
.def
.section
;
3312 toff
= h
->root
.u
.def
.value
;
3319 /* We can only estimate relocation overflow for R_X86_64_PC32. */
3323 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
3325 /* At this stage in linking, no SEC_MERGE symbol has been
3326 adjusted, so all references to such symbols need to be
3327 passed through _bfd_merged_section_offset. (Later, in
3328 relocate_section, all SEC_MERGE symbols *except* for
3329 section symbols have been adjusted.)
3331 gas may reduce relocations against symbols in SEC_MERGE
3332 sections to a relocation against the section symbol when
3333 the original addend was zero. When the reloc is against
3334 a section symbol we should include the addend in the
3335 offset passed to _bfd_merged_section_offset, since the
3336 location of interest is the original symbol. On the
3337 other hand, an access to "sym+addend" where "sym" is not
3338 a section symbol should not include the addend; Such an
3339 access is presumed to be an offset from "sym"; The
3340 location of interest is just "sym". */
3341 if (symtype
== STT_SECTION
)
3344 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
3345 elf_section_data (tsec
)->sec_info
,
3348 if (symtype
!= STT_SECTION
)
3354 /* Don't convert if R_X86_64_PC32 relocation overflows. */
3355 if (tsec
->output_section
== sec
->output_section
)
3357 if ((toff
- roff
+ 0x80000000) > 0xffffffff)
3362 bfd_signed_vma distance
;
3364 /* At this point, we don't know the load addresses of TSEC
3365 section nor SEC section. We estimate the distrance between
3366 SEC and TSEC. We store the estimated distances in the
3367 compressed_size field of the output section, which is only
3368 used to decompress the compressed input section. */
3369 if (sec
->output_section
->compressed_size
== 0)
3372 bfd_size_type size
= 0;
3373 for (asect
= link_info
->output_bfd
->sections
;
3375 asect
= asect
->next
)
3378 for (i
= asect
->map_head
.s
;
3382 size
= align_power (size
, i
->alignment_power
);
3385 asect
->compressed_size
= size
;
3389 /* Don't convert GOTPCREL relocations if TSEC isn't placed
3391 distance
= (tsec
->output_section
->compressed_size
3392 - sec
->output_section
->compressed_size
);
3396 /* Take PT_GNU_RELRO segment into account by adding
3398 if ((toff
+ distance
+ maxpagesize
- roff
+ 0x80000000)
3406 /* We have "call/jmp *foo@GOTPCREL(%rip)". */
3411 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
3413 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
3416 /* Convert to "jmp foo nop". */
3419 nop_offset
= irel
->r_offset
+ 3;
3420 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
3421 irel
->r_offset
-= 1;
3422 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
3426 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
3429 nop
= link_info
->call_nop_byte
;
3430 if (link_info
->call_nop_as_suffix
)
3432 nop_offset
= irel
->r_offset
+ 3;
3433 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
3434 irel
->r_offset
-= 1;
3435 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
3438 nop_offset
= irel
->r_offset
- 2;
3440 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
3441 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
3442 r_type
= R_X86_64_PC32
;
3447 unsigned int rex_mask
= REX_R
;
3449 if (r_type
== R_X86_64_REX_GOTPCRELX
)
3450 rex
= bfd_get_8 (abfd
, contents
+ roff
- 3);
3458 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
3459 "lea foo(%rip), %reg". */
3461 r_type
= R_X86_64_PC32
;
3465 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
3466 "mov $foo, %reg". */
3468 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
3469 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
3470 if ((rex
& REX_W
) != 0
3471 && ABI_64_P (link_info
->output_bfd
))
3473 /* Keep the REX_W bit in REX byte for LP64. */
3474 r_type
= R_X86_64_32S
;
3475 goto rewrite_modrm_rex
;
3479 /* If the REX_W bit in REX byte isn't needed,
3480 use R_X86_64_32 and clear the W bit to avoid
3481 sign-extend imm32 to imm64. */
3482 r_type
= R_X86_64_32
;
3483 /* Clear the W bit in REX byte. */
3485 goto rewrite_modrm_rex
;
3491 /* R_X86_64_PC32 isn't supported. */
3495 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
3498 /* Convert "test %reg, foo@GOTPCREL(%rip)" to
3499 "test $foo, %reg". */
3500 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
3505 /* Convert "binop foo@GOTPCREL(%rip), %reg" to
3506 "binop $foo, %reg". */
3507 modrm
= 0xc0 | (modrm
& 0x38) >> 3 | (opcode
& 0x3c);
3511 /* Use R_X86_64_32 with 32-bit operand to avoid relocation
3512 overflow when sign-extending imm32 to imm64. */
3513 r_type
= (rex
& REX_W
) != 0 ? R_X86_64_32S
: R_X86_64_32
;
3516 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
3520 /* Move the R bit to the B bit in REX byte. */
3521 rex
= (rex
& ~rex_mask
) | (rex
& REX_R
) >> 2;
3522 bfd_put_8 (abfd
, rex
, contents
+ roff
- 3);
3525 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */
3529 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
3532 irel
->r_info
= htab
->r_info (r_symndx
, r_type
);
3533 changed_contents
= TRUE
;
3534 changed_relocs
= TRUE
;
3538 if (h
->got
.refcount
> 0)
3539 h
->got
.refcount
-= 1;
3543 if (local_got_refcounts
!= NULL
3544 && local_got_refcounts
[r_symndx
] > 0)
3545 local_got_refcounts
[r_symndx
] -= 1;
3549 if (contents
!= NULL
3550 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3552 if (!changed_contents
&& !link_info
->keep_memory
)
3556 /* Cache the section contents for elf_link_input_bfd. */
3557 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3561 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3563 if (!changed_relocs
)
3564 free (internal_relocs
);
3566 elf_section_data (sec
)->relocs
= internal_relocs
;
3572 if (contents
!= NULL
3573 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3575 if (internal_relocs
!= NULL
3576 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3577 free (internal_relocs
);
3581 /* Set the sizes of the dynamic sections. */
3584 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
3585 struct bfd_link_info
*info
)
3587 struct elf_x86_64_link_hash_table
*htab
;
3592 const struct elf_backend_data
*bed
;
3594 htab
= elf_x86_64_hash_table (info
);
3597 bed
= get_elf_backend_data (output_bfd
);
3599 dynobj
= htab
->elf
.dynobj
;
3603 if (htab
->elf
.dynamic_sections_created
)
3605 /* Set the contents of the .interp section to the interpreter. */
3606 if (bfd_link_executable (info
) && !info
->nointerp
)
3608 s
= bfd_get_linker_section (dynobj
, ".interp");
3611 s
->size
= htab
->dynamic_interpreter_size
;
3612 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
3617 /* Set up .got offsets for local syms, and space for local dynamic
3619 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3621 bfd_signed_vma
*local_got
;
3622 bfd_signed_vma
*end_local_got
;
3623 char *local_tls_type
;
3624 bfd_vma
*local_tlsdesc_gotent
;
3625 bfd_size_type locsymcount
;
3626 Elf_Internal_Shdr
*symtab_hdr
;
3629 if (! is_x86_64_elf (ibfd
))
3632 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3634 struct elf_dyn_relocs
*p
;
3636 if (!elf_x86_64_convert_load (ibfd
, s
, info
))
3639 for (p
= (struct elf_dyn_relocs
*)
3640 (elf_section_data (s
)->local_dynrel
);
3644 if (!bfd_is_abs_section (p
->sec
)
3645 && bfd_is_abs_section (p
->sec
->output_section
))
3647 /* Input section has been discarded, either because
3648 it is a copy of a linkonce section or due to
3649 linker script /DISCARD/, so we'll be discarding
3652 else if (p
->count
!= 0)
3654 srel
= elf_section_data (p
->sec
)->sreloc
;
3655 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3656 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3657 && (info
->flags
& DF_TEXTREL
) == 0)
3659 info
->flags
|= DF_TEXTREL
;
3660 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3661 || info
->error_textrel
)
3662 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3663 p
->sec
->owner
, p
->sec
);
3669 local_got
= elf_local_got_refcounts (ibfd
);
3673 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3674 locsymcount
= symtab_hdr
->sh_info
;
3675 end_local_got
= local_got
+ locsymcount
;
3676 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
3677 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
3679 srel
= htab
->elf
.srelgot
;
3680 for (; local_got
< end_local_got
;
3681 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3683 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3686 if (GOT_TLS_GDESC_P (*local_tls_type
))
3688 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3689 - elf_x86_64_compute_jump_table_size (htab
);
3690 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3691 *local_got
= (bfd_vma
) -2;
3693 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3694 || GOT_TLS_GD_P (*local_tls_type
))
3696 *local_got
= s
->size
;
3697 s
->size
+= GOT_ENTRY_SIZE
;
3698 if (GOT_TLS_GD_P (*local_tls_type
))
3699 s
->size
+= GOT_ENTRY_SIZE
;
3701 if (bfd_link_pic (info
)
3702 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3703 || *local_tls_type
== GOT_TLS_IE
)
3705 if (GOT_TLS_GDESC_P (*local_tls_type
))
3707 htab
->elf
.srelplt
->size
3708 += bed
->s
->sizeof_rela
;
3709 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3711 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3712 || GOT_TLS_GD_P (*local_tls_type
))
3713 srel
->size
+= bed
->s
->sizeof_rela
;
3717 *local_got
= (bfd_vma
) -1;
3721 if (htab
->tls_ld_got
.refcount
> 0)
3723 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3725 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
3726 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
3727 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3730 htab
->tls_ld_got
.offset
= -1;
3732 /* Allocate global sym .plt and .got entries, and space for global
3733 sym dynamic relocs. */
3734 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
3737 /* Allocate .plt and .got entries, and space for local symbols. */
3738 htab_traverse (htab
->loc_hash_table
,
3739 elf_x86_64_allocate_local_dynrelocs
,
3742 /* For every jump slot reserved in the sgotplt, reloc_count is
3743 incremented. However, when we reserve space for TLS descriptors,
3744 it's not incremented, so in order to compute the space reserved
3745 for them, it suffices to multiply the reloc count by the jump
3748 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3749 so that R_X86_64_IRELATIVE entries come last. */
3750 if (htab
->elf
.srelplt
)
3752 htab
->sgotplt_jump_table_size
3753 = elf_x86_64_compute_jump_table_size (htab
);
3754 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3756 else if (htab
->elf
.irelplt
)
3757 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3759 if (htab
->tlsdesc_plt
)
3761 /* If we're not using lazy TLS relocations, don't generate the
3762 PLT and GOT entries they require. */
3763 if ((info
->flags
& DF_BIND_NOW
))
3764 htab
->tlsdesc_plt
= 0;
3767 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
3768 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
3769 /* Reserve room for the initial entry.
3770 FIXME: we could probably do away with it in this case. */
3771 if (htab
->elf
.splt
->size
== 0)
3772 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3773 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
3774 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3778 if (htab
->elf
.sgotplt
)
3780 /* Don't allocate .got.plt section if there are no GOT nor PLT
3781 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3782 if ((htab
->elf
.hgot
== NULL
3783 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3784 && (htab
->elf
.sgotplt
->size
3785 == get_elf_backend_data (output_bfd
)->got_header_size
)
3786 && (htab
->elf
.splt
== NULL
3787 || htab
->elf
.splt
->size
== 0)
3788 && (htab
->elf
.sgot
== NULL
3789 || htab
->elf
.sgot
->size
== 0)
3790 && (htab
->elf
.iplt
== NULL
3791 || htab
->elf
.iplt
->size
== 0)
3792 && (htab
->elf
.igotplt
== NULL
3793 || htab
->elf
.igotplt
->size
== 0))
3794 htab
->elf
.sgotplt
->size
= 0;
3797 if (htab
->plt_eh_frame
!= NULL
3798 && htab
->elf
.splt
!= NULL
3799 && htab
->elf
.splt
->size
!= 0
3800 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3801 && _bfd_elf_eh_frame_present (info
))
3803 const struct elf_x86_64_backend_data
*arch_data
3804 = get_elf_x86_64_arch_data (bed
);
3805 htab
->plt_eh_frame
->size
= arch_data
->eh_frame_plt_size
;
3808 /* We now have determined the sizes of the various dynamic sections.
3809 Allocate memory for them. */
3811 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3813 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3816 if (s
== htab
->elf
.splt
3817 || s
== htab
->elf
.sgot
3818 || s
== htab
->elf
.sgotplt
3819 || s
== htab
->elf
.iplt
3820 || s
== htab
->elf
.igotplt
3821 || s
== htab
->plt_bnd
3822 || s
== htab
->plt_got
3823 || s
== htab
->plt_eh_frame
3824 || s
== htab
->sdynbss
)
3826 /* Strip this section if we don't need it; see the
3829 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3831 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
3834 /* We use the reloc_count field as a counter if we need
3835 to copy relocs into the output file. */
3836 if (s
!= htab
->elf
.srelplt
)
3841 /* It's not one of our sections, so don't allocate space. */
3847 /* If we don't need this section, strip it from the
3848 output file. This is mostly to handle .rela.bss and
3849 .rela.plt. We must create both sections in
3850 create_dynamic_sections, because they must be created
3851 before the linker maps input sections to output
3852 sections. The linker does that before
3853 adjust_dynamic_symbol is called, and it is that
3854 function which decides whether anything needs to go
3855 into these sections. */
3857 s
->flags
|= SEC_EXCLUDE
;
3861 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3864 /* Allocate memory for the section contents. We use bfd_zalloc
3865 here in case unused entries are not reclaimed before the
3866 section's contents are written out. This should not happen,
3867 but this way if it does, we get a R_X86_64_NONE reloc instead
3869 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3870 if (s
->contents
== NULL
)
3874 if (htab
->plt_eh_frame
!= NULL
3875 && htab
->plt_eh_frame
->contents
!= NULL
)
3877 const struct elf_x86_64_backend_data
*arch_data
3878 = get_elf_x86_64_arch_data (bed
);
3880 memcpy (htab
->plt_eh_frame
->contents
,
3881 arch_data
->eh_frame_plt
, htab
->plt_eh_frame
->size
);
3882 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3883 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3886 if (htab
->elf
.dynamic_sections_created
)
3888 /* Add some entries to the .dynamic section. We fill in the
3889 values later, in elf_x86_64_finish_dynamic_sections, but we
3890 must add the entries now so that we get the correct size for
3891 the .dynamic section. The DT_DEBUG entry is filled in by the
3892 dynamic linker and used by the debugger. */
3893 #define add_dynamic_entry(TAG, VAL) \
3894 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3896 if (bfd_link_executable (info
))
3898 if (!add_dynamic_entry (DT_DEBUG
, 0))
3902 if (htab
->elf
.splt
->size
!= 0)
3904 /* DT_PLTGOT is used by prelink even if there is no PLT
3906 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3909 if (htab
->elf
.srelplt
->size
!= 0)
3911 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3912 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3913 || !add_dynamic_entry (DT_JMPREL
, 0))
3917 if (htab
->tlsdesc_plt
3918 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3919 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3925 if (!add_dynamic_entry (DT_RELA
, 0)
3926 || !add_dynamic_entry (DT_RELASZ
, 0)
3927 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3930 /* If any dynamic relocs apply to a read-only section,
3931 then we need a DT_TEXTREL entry. */
3932 if ((info
->flags
& DF_TEXTREL
) == 0)
3933 elf_link_hash_traverse (&htab
->elf
,
3934 elf_x86_64_readonly_dynrelocs
,
3937 if ((info
->flags
& DF_TEXTREL
) != 0)
3939 if (htab
->readonly_dynrelocs_against_ifunc
)
3941 info
->callbacks
->einfo
3942 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3943 bfd_set_error (bfd_error_bad_value
);
3947 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3952 #undef add_dynamic_entry
3958 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3959 struct bfd_link_info
*info
)
3961 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3965 struct elf_link_hash_entry
*tlsbase
;
3967 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3968 "_TLS_MODULE_BASE_",
3969 FALSE
, FALSE
, FALSE
);
3971 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3973 struct elf_x86_64_link_hash_table
*htab
;
3974 struct bfd_link_hash_entry
*bh
= NULL
;
3975 const struct elf_backend_data
*bed
3976 = get_elf_backend_data (output_bfd
);
3978 htab
= elf_x86_64_hash_table (info
);
3982 if (!(_bfd_generic_link_add_one_symbol
3983 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3984 tls_sec
, 0, NULL
, FALSE
,
3985 bed
->collect
, &bh
)))
3988 htab
->tls_module_base
= bh
;
3990 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3991 tlsbase
->def_regular
= 1;
3992 tlsbase
->other
= STV_HIDDEN
;
3993 tlsbase
->root
.linker_def
= 1;
3994 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
4001 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
4002 executables. Rather than setting it to the beginning of the TLS
4003 section, we have to set it to the end. This function may be called
4004 multiple times, it is idempotent. */
4007 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
4009 struct elf_x86_64_link_hash_table
*htab
;
4010 struct bfd_link_hash_entry
*base
;
4012 if (!bfd_link_executable (info
))
4015 htab
= elf_x86_64_hash_table (info
);
4019 base
= htab
->tls_module_base
;
4023 base
->u
.def
.value
= htab
->elf
.tls_size
;
4026 /* Return the base VMA address which should be subtracted from real addresses
4027 when resolving @dtpoff relocation.
4028 This is PT_TLS segment p_vaddr. */
4031 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
4033 /* If tls_sec is NULL, we should have signalled an error already. */
4034 if (elf_hash_table (info
)->tls_sec
== NULL
)
4036 return elf_hash_table (info
)->tls_sec
->vma
;
4039 /* Return the relocation value for @tpoff relocation
4040 if STT_TLS virtual address is ADDRESS. */
4043 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
4045 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
4046 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
4047 bfd_vma static_tls_size
;
4049 /* If tls_segment is NULL, we should have signalled an error already. */
4050 if (htab
->tls_sec
== NULL
)
4053 /* Consider special static TLS alignment requirements. */
4054 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
4055 return address
- static_tls_size
- htab
->tls_sec
->vma
;
4058 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
4062 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
4064 /* Opcode Instruction
4067 0x0f 0x8x conditional jump */
4069 && (contents
[offset
- 1] == 0xe8
4070 || contents
[offset
- 1] == 0xe9))
4072 && contents
[offset
- 2] == 0x0f
4073 && (contents
[offset
- 1] & 0xf0) == 0x80));
4076 /* Relocate an x86_64 ELF section. */
4079 elf_x86_64_relocate_section (bfd
*output_bfd
,
4080 struct bfd_link_info
*info
,
4082 asection
*input_section
,
4084 Elf_Internal_Rela
*relocs
,
4085 Elf_Internal_Sym
*local_syms
,
4086 asection
**local_sections
)
4088 struct elf_x86_64_link_hash_table
*htab
;
4089 Elf_Internal_Shdr
*symtab_hdr
;
4090 struct elf_link_hash_entry
**sym_hashes
;
4091 bfd_vma
*local_got_offsets
;
4092 bfd_vma
*local_tlsdesc_gotents
;
4093 Elf_Internal_Rela
*rel
;
4094 Elf_Internal_Rela
*wrel
;
4095 Elf_Internal_Rela
*relend
;
4096 const unsigned int plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
4098 BFD_ASSERT (is_x86_64_elf (input_bfd
));
4100 /* Skip if check_relocs failed. */
4101 if (input_section
->check_relocs_failed
)
4104 htab
= elf_x86_64_hash_table (info
);
4107 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
4108 sym_hashes
= elf_sym_hashes (input_bfd
);
4109 local_got_offsets
= elf_local_got_offsets (input_bfd
);
4110 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
4112 elf_x86_64_set_tls_module_base (info
);
4114 rel
= wrel
= relocs
;
4115 relend
= relocs
+ input_section
->reloc_count
;
4116 for (; rel
< relend
; wrel
++, rel
++)
4118 unsigned int r_type
;
4119 reloc_howto_type
*howto
;
4120 unsigned long r_symndx
;
4121 struct elf_link_hash_entry
*h
;
4122 struct elf_x86_64_link_hash_entry
*eh
;
4123 Elf_Internal_Sym
*sym
;
4125 bfd_vma off
, offplt
, plt_offset
;
4127 bfd_boolean unresolved_reloc
;
4128 bfd_reloc_status_type r
;
4130 asection
*base_got
, *resolved_plt
;
4132 bfd_boolean resolved_to_zero
;
4134 r_type
= ELF32_R_TYPE (rel
->r_info
);
4135 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
4136 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
4143 if (r_type
>= (int) R_X86_64_standard
)
4145 (*_bfd_error_handler
)
4146 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
4147 input_bfd
, input_section
, r_type
);
4148 bfd_set_error (bfd_error_bad_value
);
4152 if (r_type
!= (int) R_X86_64_32
4153 || ABI_64_P (output_bfd
))
4154 howto
= x86_64_elf_howto_table
+ r_type
;
4156 howto
= (x86_64_elf_howto_table
4157 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
4158 r_symndx
= htab
->r_sym (rel
->r_info
);
4162 unresolved_reloc
= FALSE
;
4163 if (r_symndx
< symtab_hdr
->sh_info
)
4165 sym
= local_syms
+ r_symndx
;
4166 sec
= local_sections
[r_symndx
];
4168 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
4170 st_size
= sym
->st_size
;
4172 /* Relocate against local STT_GNU_IFUNC symbol. */
4173 if (!bfd_link_relocatable (info
)
4174 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
4176 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
4181 /* Set STT_GNU_IFUNC symbol value. */
4182 h
->root
.u
.def
.value
= sym
->st_value
;
4183 h
->root
.u
.def
.section
= sec
;
4188 bfd_boolean warned ATTRIBUTE_UNUSED
;
4189 bfd_boolean ignored ATTRIBUTE_UNUSED
;
4191 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
4192 r_symndx
, symtab_hdr
, sym_hashes
,
4194 unresolved_reloc
, warned
, ignored
);
4198 if (sec
!= NULL
&& discarded_section (sec
))
4200 _bfd_clear_contents (howto
, input_bfd
, input_section
,
4201 contents
+ rel
->r_offset
);
4202 wrel
->r_offset
= rel
->r_offset
;
4206 /* For ld -r, remove relocations in debug sections against
4207 sections defined in discarded sections. Not done for
4208 eh_frame editing code expects to be present. */
4209 if (bfd_link_relocatable (info
)
4210 && (input_section
->flags
& SEC_DEBUGGING
))
4216 if (bfd_link_relocatable (info
))
4223 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
4225 if (r_type
== R_X86_64_64
)
4227 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
4228 zero-extend it to 64bit if addend is zero. */
4229 r_type
= R_X86_64_32
;
4230 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4232 else if (r_type
== R_X86_64_SIZE64
)
4234 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
4235 zero-extend it to 64bit if addend is zero. */
4236 r_type
= R_X86_64_SIZE32
;
4237 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4241 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
4243 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
4244 it here if it is defined in a non-shared object. */
4246 && h
->type
== STT_GNU_IFUNC
4252 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4254 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4255 sections because such sections are not SEC_ALLOC and
4256 thus ld.so will not process them. */
4257 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
4261 else if (h
->plt
.offset
== (bfd_vma
) -1)
4264 /* STT_GNU_IFUNC symbol must go through PLT. */
4265 if (htab
->elf
.splt
!= NULL
)
4267 if (htab
->plt_bnd
!= NULL
)
4269 resolved_plt
= htab
->plt_bnd
;
4270 plt_offset
= eh
->plt_bnd
.offset
;
4274 resolved_plt
= htab
->elf
.splt
;
4275 plt_offset
= h
->plt
.offset
;
4280 resolved_plt
= htab
->elf
.iplt
;
4281 plt_offset
= h
->plt
.offset
;
4284 relocation
= (resolved_plt
->output_section
->vma
4285 + resolved_plt
->output_offset
+ plt_offset
);
4290 if (h
->root
.root
.string
)
4291 name
= h
->root
.root
.string
;
4293 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4295 (*_bfd_error_handler
)
4296 (_("%B: relocation %s against STT_GNU_IFUNC "
4297 "symbol `%s' isn't handled by %s"), input_bfd
,
4298 howto
->name
, name
, __FUNCTION__
);
4299 bfd_set_error (bfd_error_bad_value
);
4303 if (bfd_link_pic (info
))
4308 if (ABI_64_P (output_bfd
))
4312 if (rel
->r_addend
!= 0)
4314 if (h
->root
.root
.string
)
4315 name
= h
->root
.root
.string
;
4317 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4319 (*_bfd_error_handler
)
4320 (_("%B: relocation %s against STT_GNU_IFUNC "
4321 "symbol `%s' has non-zero addend: %d"),
4322 input_bfd
, howto
->name
, name
, rel
->r_addend
);
4323 bfd_set_error (bfd_error_bad_value
);
4327 /* Generate dynamic relcoation only when there is a
4328 non-GOT reference in a shared object. */
4329 if (bfd_link_pic (info
) && h
->non_got_ref
)
4331 Elf_Internal_Rela outrel
;
4334 /* Need a dynamic relocation to get the real function
4336 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
4340 if (outrel
.r_offset
== (bfd_vma
) -1
4341 || outrel
.r_offset
== (bfd_vma
) -2)
4344 outrel
.r_offset
+= (input_section
->output_section
->vma
4345 + input_section
->output_offset
);
4347 if (h
->dynindx
== -1
4349 || bfd_link_executable (info
))
4351 /* This symbol is resolved locally. */
4352 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4353 outrel
.r_addend
= (h
->root
.u
.def
.value
4354 + h
->root
.u
.def
.section
->output_section
->vma
4355 + h
->root
.u
.def
.section
->output_offset
);
4359 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4360 outrel
.r_addend
= 0;
4363 sreloc
= htab
->elf
.irelifunc
;
4364 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4366 /* If this reloc is against an external symbol, we
4367 do not want to fiddle with the addend. Otherwise,
4368 we need to include the symbol value so that it
4369 becomes an addend for the dynamic reloc. For an
4370 internal symbol, we have updated addend. */
4375 case R_X86_64_PC32_BND
:
4377 case R_X86_64_PLT32
:
4378 case R_X86_64_PLT32_BND
:
4381 case R_X86_64_GOTPCREL
:
4382 case R_X86_64_GOTPCRELX
:
4383 case R_X86_64_REX_GOTPCRELX
:
4384 case R_X86_64_GOTPCREL64
:
4385 base_got
= htab
->elf
.sgot
;
4386 off
= h
->got
.offset
;
4388 if (base_got
== NULL
)
4391 if (off
== (bfd_vma
) -1)
4393 /* We can't use h->got.offset here to save state, or
4394 even just remember the offset, as finish_dynamic_symbol
4395 would use that as offset into .got. */
4397 if (htab
->elf
.splt
!= NULL
)
4399 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4400 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4401 base_got
= htab
->elf
.sgotplt
;
4405 plt_index
= h
->plt
.offset
/ plt_entry_size
;
4406 off
= plt_index
* GOT_ENTRY_SIZE
;
4407 base_got
= htab
->elf
.igotplt
;
4410 if (h
->dynindx
== -1
4414 /* This references the local defitionion. We must
4415 initialize this entry in the global offset table.
4416 Since the offset must always be a multiple of 8,
4417 we use the least significant bit to record
4418 whether we have initialized it already.
4420 When doing a dynamic link, we create a .rela.got
4421 relocation entry to initialize the value. This
4422 is done in the finish_dynamic_symbol routine. */
4427 bfd_put_64 (output_bfd
, relocation
,
4428 base_got
->contents
+ off
);
4429 /* Note that this is harmless for the GOTPLT64
4430 case, as -1 | 1 still is -1. */
4436 relocation
= (base_got
->output_section
->vma
4437 + base_got
->output_offset
+ off
);
4443 resolved_to_zero
= (eh
!= NULL
4444 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, eh
));
4446 /* When generating a shared object, the relocations handled here are
4447 copied into the output file to be resolved at run time. */
4450 case R_X86_64_GOT32
:
4451 case R_X86_64_GOT64
:
4452 /* Relocation is to the entry for this symbol in the global
4454 case R_X86_64_GOTPCREL
:
4455 case R_X86_64_GOTPCRELX
:
4456 case R_X86_64_REX_GOTPCRELX
:
4457 case R_X86_64_GOTPCREL64
:
4458 /* Use global offset table entry as symbol value. */
4459 case R_X86_64_GOTPLT64
:
4460 /* This is obsolete and treated the the same as GOT64. */
4461 base_got
= htab
->elf
.sgot
;
4463 if (htab
->elf
.sgot
== NULL
)
4470 off
= h
->got
.offset
;
4472 && h
->plt
.offset
!= (bfd_vma
)-1
4473 && off
== (bfd_vma
)-1)
4475 /* We can't use h->got.offset here to save
4476 state, or even just remember the offset, as
4477 finish_dynamic_symbol would use that as offset into
4479 bfd_vma plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4480 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4481 base_got
= htab
->elf
.sgotplt
;
4484 dyn
= htab
->elf
.dynamic_sections_created
;
4486 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
4487 || (bfd_link_pic (info
)
4488 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4489 || (ELF_ST_VISIBILITY (h
->other
)
4490 && h
->root
.type
== bfd_link_hash_undefweak
))
4492 /* This is actually a static link, or it is a -Bsymbolic
4493 link and the symbol is defined locally, or the symbol
4494 was forced to be local because of a version file. We
4495 must initialize this entry in the global offset table.
4496 Since the offset must always be a multiple of 8, we
4497 use the least significant bit to record whether we
4498 have initialized it already.
4500 When doing a dynamic link, we create a .rela.got
4501 relocation entry to initialize the value. This is
4502 done in the finish_dynamic_symbol routine. */
4507 bfd_put_64 (output_bfd
, relocation
,
4508 base_got
->contents
+ off
);
4509 /* Note that this is harmless for the GOTPLT64 case,
4510 as -1 | 1 still is -1. */
4515 unresolved_reloc
= FALSE
;
4519 if (local_got_offsets
== NULL
)
4522 off
= local_got_offsets
[r_symndx
];
4524 /* The offset must always be a multiple of 8. We use
4525 the least significant bit to record whether we have
4526 already generated the necessary reloc. */
4531 bfd_put_64 (output_bfd
, relocation
,
4532 base_got
->contents
+ off
);
4534 if (bfd_link_pic (info
))
4537 Elf_Internal_Rela outrel
;
4539 /* We need to generate a R_X86_64_RELATIVE reloc
4540 for the dynamic linker. */
4541 s
= htab
->elf
.srelgot
;
4545 outrel
.r_offset
= (base_got
->output_section
->vma
4546 + base_got
->output_offset
4548 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4549 outrel
.r_addend
= relocation
;
4550 elf_append_rela (output_bfd
, s
, &outrel
);
4553 local_got_offsets
[r_symndx
] |= 1;
4557 if (off
>= (bfd_vma
) -2)
4560 relocation
= base_got
->output_section
->vma
4561 + base_got
->output_offset
+ off
;
4562 if (r_type
!= R_X86_64_GOTPCREL
4563 && r_type
!= R_X86_64_GOTPCRELX
4564 && r_type
!= R_X86_64_REX_GOTPCRELX
4565 && r_type
!= R_X86_64_GOTPCREL64
)
4566 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4567 - htab
->elf
.sgotplt
->output_offset
;
4571 case R_X86_64_GOTOFF64
:
4572 /* Relocation is relative to the start of the global offset
4575 /* Check to make sure it isn't a protected function or data
4576 symbol for shared library since it may not be local when
4577 used as function address or with copy relocation. We also
4578 need to make sure that a symbol is referenced locally. */
4579 if (bfd_link_pic (info
) && h
)
4581 if (!h
->def_regular
)
4585 switch (ELF_ST_VISIBILITY (h
->other
))
4588 v
= _("hidden symbol");
4591 v
= _("internal symbol");
4594 v
= _("protected symbol");
4601 (*_bfd_error_handler
)
4602 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s `%s' can not be used when making a shared object"),
4603 input_bfd
, v
, h
->root
.root
.string
);
4604 bfd_set_error (bfd_error_bad_value
);
4607 else if (!bfd_link_executable (info
)
4608 && !SYMBOL_REFERENCES_LOCAL (info
, h
)
4609 && (h
->type
== STT_FUNC
4610 || h
->type
== STT_OBJECT
)
4611 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4613 (*_bfd_error_handler
)
4614 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s `%s' can not be used when making a shared object"),
4616 h
->type
== STT_FUNC
? "function" : "data",
4617 h
->root
.root
.string
);
4618 bfd_set_error (bfd_error_bad_value
);
4623 /* Note that sgot is not involved in this
4624 calculation. We always want the start of .got.plt. If we
4625 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4626 permitted by the ABI, we might have to change this
4628 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4629 + htab
->elf
.sgotplt
->output_offset
;
4632 case R_X86_64_GOTPC32
:
4633 case R_X86_64_GOTPC64
:
4634 /* Use global offset table as symbol value. */
4635 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4636 + htab
->elf
.sgotplt
->output_offset
;
4637 unresolved_reloc
= FALSE
;
4640 case R_X86_64_PLTOFF64
:
4641 /* Relocation is PLT entry relative to GOT. For local
4642 symbols it's the symbol itself relative to GOT. */
4644 /* See PLT32 handling. */
4645 && h
->plt
.offset
!= (bfd_vma
) -1
4646 && htab
->elf
.splt
!= NULL
)
4648 if (htab
->plt_bnd
!= NULL
)
4650 resolved_plt
= htab
->plt_bnd
;
4651 plt_offset
= eh
->plt_bnd
.offset
;
4655 resolved_plt
= htab
->elf
.splt
;
4656 plt_offset
= h
->plt
.offset
;
4659 relocation
= (resolved_plt
->output_section
->vma
4660 + resolved_plt
->output_offset
4662 unresolved_reloc
= FALSE
;
4665 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4666 + htab
->elf
.sgotplt
->output_offset
;
4669 case R_X86_64_PLT32
:
4670 case R_X86_64_PLT32_BND
:
4671 /* Relocation is to the entry for this symbol in the
4672 procedure linkage table. */
4674 /* Resolve a PLT32 reloc against a local symbol directly,
4675 without using the procedure linkage table. */
4679 if ((h
->plt
.offset
== (bfd_vma
) -1
4680 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4681 || htab
->elf
.splt
== NULL
)
4683 /* We didn't make a PLT entry for this symbol. This
4684 happens when statically linking PIC code, or when
4685 using -Bsymbolic. */
4689 if (h
->plt
.offset
!= (bfd_vma
) -1)
4691 if (htab
->plt_bnd
!= NULL
)
4693 resolved_plt
= htab
->plt_bnd
;
4694 plt_offset
= eh
->plt_bnd
.offset
;
4698 resolved_plt
= htab
->elf
.splt
;
4699 plt_offset
= h
->plt
.offset
;
4704 /* Use the GOT PLT. */
4705 resolved_plt
= htab
->plt_got
;
4706 plt_offset
= eh
->plt_got
.offset
;
4709 relocation
= (resolved_plt
->output_section
->vma
4710 + resolved_plt
->output_offset
4712 unresolved_reloc
= FALSE
;
4715 case R_X86_64_SIZE32
:
4716 case R_X86_64_SIZE64
:
4717 /* Set to symbol size. */
4718 relocation
= st_size
;
4724 case R_X86_64_PC32_BND
:
4725 /* Don't complain about -fPIC if the symbol is undefined when
4726 building executable unless it is unresolved weak symbol. */
4727 if ((input_section
->flags
& SEC_ALLOC
) != 0
4728 && (input_section
->flags
& SEC_READONLY
) != 0
4730 && ((bfd_link_executable (info
)
4731 && h
->root
.type
== bfd_link_hash_undefweak
4732 && !resolved_to_zero
)
4733 || (bfd_link_pic (info
)
4734 && !(bfd_link_pie (info
)
4735 && h
->root
.type
== bfd_link_hash_undefined
))))
4737 bfd_boolean fail
= FALSE
;
4739 = ((r_type
== R_X86_64_PC32
4740 || r_type
== R_X86_64_PC32_BND
)
4741 && is_32bit_relative_branch (contents
, rel
->r_offset
));
4743 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
4745 /* Symbol is referenced locally. Make sure it is
4746 defined locally or for a branch. */
4747 fail
= !h
->def_regular
&& !branch
;
4749 else if (!(bfd_link_pie (info
)
4750 && (h
->needs_copy
|| eh
->needs_copy
)))
4752 /* Symbol doesn't need copy reloc and isn't referenced
4753 locally. We only allow branch to symbol with
4754 non-default visibility. */
4756 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
4760 return elf_x86_64_need_pic (input_bfd
, input_section
,
4761 h
, NULL
, NULL
, howto
);
4770 /* FIXME: The ABI says the linker should make sure the value is
4771 the same when it's zeroextended to 64 bit. */
4774 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4777 /* Don't copy a pc-relative relocation into the output file
4778 if the symbol needs copy reloc or the symbol is undefined
4779 when building executable. Copy dynamic function pointer
4780 relocations. Don't generate dynamic relocations against
4781 resolved undefined weak symbols in PIE. */
4782 if ((bfd_link_pic (info
)
4783 && !(bfd_link_pie (info
)
4787 || h
->root
.type
== bfd_link_hash_undefined
)
4788 && IS_X86_64_PCREL_TYPE (r_type
))
4790 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4791 && !resolved_to_zero
)
4792 || h
->root
.type
!= bfd_link_hash_undefweak
))
4793 && ((! IS_X86_64_PCREL_TYPE (r_type
)
4794 && r_type
!= R_X86_64_SIZE32
4795 && r_type
!= R_X86_64_SIZE64
)
4796 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
4797 || (ELIMINATE_COPY_RELOCS
4798 && !bfd_link_pic (info
)
4802 || eh
->func_pointer_refcount
> 0
4803 || (h
->root
.type
== bfd_link_hash_undefweak
4804 && !resolved_to_zero
))
4805 && ((h
->def_dynamic
&& !h
->def_regular
)
4806 /* Undefined weak symbol is bound locally when
4808 || h
->root
.type
== bfd_link_hash_undefined
)))
4810 Elf_Internal_Rela outrel
;
4811 bfd_boolean skip
, relocate
;
4814 /* When generating a shared object, these relocations
4815 are copied into the output file to be resolved at run
4821 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4823 if (outrel
.r_offset
== (bfd_vma
) -1)
4825 else if (outrel
.r_offset
== (bfd_vma
) -2)
4826 skip
= TRUE
, relocate
= TRUE
;
4828 outrel
.r_offset
+= (input_section
->output_section
->vma
4829 + input_section
->output_offset
);
4832 memset (&outrel
, 0, sizeof outrel
);
4834 /* h->dynindx may be -1 if this symbol was marked to
4838 && (IS_X86_64_PCREL_TYPE (r_type
)
4839 || !(bfd_link_executable (info
)
4840 || SYMBOLIC_BIND (info
, h
))
4841 || ! h
->def_regular
))
4843 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4844 outrel
.r_addend
= rel
->r_addend
;
4848 /* This symbol is local, or marked to become local.
4849 When relocation overflow check is disabled, we
4850 convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */
4851 if (r_type
== htab
->pointer_r_type
4852 || (r_type
== R_X86_64_32
4853 && info
->no_reloc_overflow_check
))
4856 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4857 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4859 else if (r_type
== R_X86_64_64
4860 && !ABI_64_P (output_bfd
))
4863 outrel
.r_info
= htab
->r_info (0,
4864 R_X86_64_RELATIVE64
);
4865 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4866 /* Check addend overflow. */
4867 if ((outrel
.r_addend
& 0x80000000)
4868 != (rel
->r_addend
& 0x80000000))
4871 int addend
= rel
->r_addend
;
4872 if (h
&& h
->root
.root
.string
)
4873 name
= h
->root
.root
.string
;
4875 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4878 (*_bfd_error_handler
)
4879 (_("%B: addend -0x%x in relocation %s against "
4880 "symbol `%s' at 0x%lx in section `%A' is "
4882 input_bfd
, input_section
, addend
,
4884 (unsigned long) rel
->r_offset
);
4886 (*_bfd_error_handler
)
4887 (_("%B: addend 0x%x in relocation %s against "
4888 "symbol `%s' at 0x%lx in section `%A' is "
4890 input_bfd
, input_section
, addend
,
4892 (unsigned long) rel
->r_offset
);
4893 bfd_set_error (bfd_error_bad_value
);
4901 if (bfd_is_abs_section (sec
))
4903 else if (sec
== NULL
|| sec
->owner
== NULL
)
4905 bfd_set_error (bfd_error_bad_value
);
4912 /* We are turning this relocation into one
4913 against a section symbol. It would be
4914 proper to subtract the symbol's value,
4915 osec->vma, from the emitted reloc addend,
4916 but ld.so expects buggy relocs. */
4917 osec
= sec
->output_section
;
4918 sindx
= elf_section_data (osec
)->dynindx
;
4921 asection
*oi
= htab
->elf
.text_index_section
;
4922 sindx
= elf_section_data (oi
)->dynindx
;
4924 BFD_ASSERT (sindx
!= 0);
4927 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
4928 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4932 sreloc
= elf_section_data (input_section
)->sreloc
;
4934 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4936 r
= bfd_reloc_notsupported
;
4937 goto check_relocation_error
;
4940 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4942 /* If this reloc is against an external symbol, we do
4943 not want to fiddle with the addend. Otherwise, we
4944 need to include the symbol value so that it becomes
4945 an addend for the dynamic reloc. */
4952 case R_X86_64_TLSGD
:
4953 case R_X86_64_GOTPC32_TLSDESC
:
4954 case R_X86_64_TLSDESC_CALL
:
4955 case R_X86_64_GOTTPOFF
:
4956 tls_type
= GOT_UNKNOWN
;
4957 if (h
== NULL
&& local_got_offsets
)
4958 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
4960 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
4962 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4963 input_section
, contents
,
4964 symtab_hdr
, sym_hashes
,
4965 &r_type
, tls_type
, rel
,
4966 relend
, h
, r_symndx
))
4969 if (r_type
== R_X86_64_TPOFF32
)
4971 bfd_vma roff
= rel
->r_offset
;
4973 BFD_ASSERT (! unresolved_reloc
);
4975 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4977 /* GD->LE transition. For 64bit, change
4978 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4979 .word 0x6666; rex64; call __tls_get_addr
4982 leaq foo@tpoff(%rax), %rax
4984 leaq foo@tlsgd(%rip), %rdi
4985 .word 0x6666; rex64; call __tls_get_addr
4988 leaq foo@tpoff(%rax), %rax
4989 For largepic, change:
4990 leaq foo@tlsgd(%rip), %rdi
4991 movabsq $__tls_get_addr@pltoff, %rax
4996 leaq foo@tpoff(%rax), %rax
4997 nopw 0x0(%rax,%rax,1) */
4999 if (ABI_64_P (output_bfd
)
5000 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
5002 memcpy (contents
+ roff
- 3,
5003 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
5004 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5007 else if (ABI_64_P (output_bfd
))
5008 memcpy (contents
+ roff
- 4,
5009 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5012 memcpy (contents
+ roff
- 3,
5013 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5015 bfd_put_32 (output_bfd
,
5016 elf_x86_64_tpoff (info
, relocation
),
5017 contents
+ roff
+ 8 + largepic
);
5018 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5023 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5025 /* GDesc -> LE transition.
5026 It's originally something like:
5027 leaq x@tlsdesc(%rip), %rax
5030 movl $x@tpoff, %rax. */
5032 unsigned int val
, type
;
5034 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5035 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5036 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
5037 contents
+ roff
- 3);
5038 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
5039 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
5040 contents
+ roff
- 1);
5041 bfd_put_32 (output_bfd
,
5042 elf_x86_64_tpoff (info
, relocation
),
5046 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5048 /* GDesc -> LE transition.
5053 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5054 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5057 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
5059 /* IE->LE transition:
5060 For 64bit, originally it can be one of:
5061 movq foo@gottpoff(%rip), %reg
5062 addq foo@gottpoff(%rip), %reg
5065 leaq foo(%reg), %reg
5067 For 32bit, originally it can be one of:
5068 movq foo@gottpoff(%rip), %reg
5069 addl foo@gottpoff(%rip), %reg
5072 leal foo(%reg), %reg
5075 unsigned int val
, type
, reg
;
5078 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5081 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
5082 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5088 bfd_put_8 (output_bfd
, 0x49,
5089 contents
+ roff
- 3);
5090 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5091 bfd_put_8 (output_bfd
, 0x41,
5092 contents
+ roff
- 3);
5093 bfd_put_8 (output_bfd
, 0xc7,
5094 contents
+ roff
- 2);
5095 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5096 contents
+ roff
- 1);
5100 /* addq/addl -> addq/addl - addressing with %rsp/%r12
5103 bfd_put_8 (output_bfd
, 0x49,
5104 contents
+ roff
- 3);
5105 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5106 bfd_put_8 (output_bfd
, 0x41,
5107 contents
+ roff
- 3);
5108 bfd_put_8 (output_bfd
, 0x81,
5109 contents
+ roff
- 2);
5110 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5111 contents
+ roff
- 1);
5115 /* addq/addl -> leaq/leal */
5117 bfd_put_8 (output_bfd
, 0x4d,
5118 contents
+ roff
- 3);
5119 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5120 bfd_put_8 (output_bfd
, 0x45,
5121 contents
+ roff
- 3);
5122 bfd_put_8 (output_bfd
, 0x8d,
5123 contents
+ roff
- 2);
5124 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
5125 contents
+ roff
- 1);
5127 bfd_put_32 (output_bfd
,
5128 elf_x86_64_tpoff (info
, relocation
),
5136 if (htab
->elf
.sgot
== NULL
)
5141 off
= h
->got
.offset
;
5142 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
5146 if (local_got_offsets
== NULL
)
5149 off
= local_got_offsets
[r_symndx
];
5150 offplt
= local_tlsdesc_gotents
[r_symndx
];
5157 Elf_Internal_Rela outrel
;
5161 if (htab
->elf
.srelgot
== NULL
)
5164 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
5166 if (GOT_TLS_GDESC_P (tls_type
))
5168 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
5169 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
5170 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
5171 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5172 + htab
->elf
.sgotplt
->output_offset
5174 + htab
->sgotplt_jump_table_size
);
5175 sreloc
= htab
->elf
.srelplt
;
5177 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5179 outrel
.r_addend
= 0;
5180 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5183 sreloc
= htab
->elf
.srelgot
;
5185 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5186 + htab
->elf
.sgot
->output_offset
+ off
);
5188 if (GOT_TLS_GD_P (tls_type
))
5189 dr_type
= R_X86_64_DTPMOD64
;
5190 else if (GOT_TLS_GDESC_P (tls_type
))
5193 dr_type
= R_X86_64_TPOFF64
;
5195 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
5196 outrel
.r_addend
= 0;
5197 if ((dr_type
== R_X86_64_TPOFF64
5198 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
5199 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5200 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
5202 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5204 if (GOT_TLS_GD_P (tls_type
))
5208 BFD_ASSERT (! unresolved_reloc
);
5209 bfd_put_64 (output_bfd
,
5210 relocation
- elf_x86_64_dtpoff_base (info
),
5211 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5215 bfd_put_64 (output_bfd
, 0,
5216 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5217 outrel
.r_info
= htab
->r_info (indx
,
5219 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
5220 elf_append_rela (output_bfd
, sreloc
,
5229 local_got_offsets
[r_symndx
] |= 1;
5232 if (off
>= (bfd_vma
) -2
5233 && ! GOT_TLS_GDESC_P (tls_type
))
5235 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
5237 if (r_type
== R_X86_64_GOTPC32_TLSDESC
5238 || r_type
== R_X86_64_TLSDESC_CALL
)
5239 relocation
= htab
->elf
.sgotplt
->output_section
->vma
5240 + htab
->elf
.sgotplt
->output_offset
5241 + offplt
+ htab
->sgotplt_jump_table_size
;
5243 relocation
= htab
->elf
.sgot
->output_section
->vma
5244 + htab
->elf
.sgot
->output_offset
+ off
;
5245 unresolved_reloc
= FALSE
;
5249 bfd_vma roff
= rel
->r_offset
;
5251 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5253 /* GD->IE transition. For 64bit, change
5254 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5255 .word 0x6666; rex64; call __tls_get_addr@plt
5258 addq foo@gottpoff(%rip), %rax
5260 leaq foo@tlsgd(%rip), %rdi
5261 .word 0x6666; rex64; call __tls_get_addr@plt
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
)
5276 && contents
[roff
+ 5] == (bfd_byte
) '\xb8')
5278 memcpy (contents
+ roff
- 3,
5279 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
5280 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5283 else if (ABI_64_P (output_bfd
))
5284 memcpy (contents
+ roff
- 4,
5285 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5288 memcpy (contents
+ roff
- 3,
5289 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5292 relocation
= (htab
->elf
.sgot
->output_section
->vma
5293 + htab
->elf
.sgot
->output_offset
+ off
5296 - input_section
->output_section
->vma
5297 - input_section
->output_offset
5299 bfd_put_32 (output_bfd
, relocation
,
5300 contents
+ roff
+ 8 + largepic
);
5301 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5306 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5308 /* GDesc -> IE transition.
5309 It's originally something like:
5310 leaq x@tlsdesc(%rip), %rax
5313 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
5315 /* Now modify the instruction as appropriate. To
5316 turn a leaq into a movq in the form we use it, it
5317 suffices to change the second byte from 0x8d to
5319 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
5321 bfd_put_32 (output_bfd
,
5322 htab
->elf
.sgot
->output_section
->vma
5323 + htab
->elf
.sgot
->output_offset
+ off
5325 - input_section
->output_section
->vma
5326 - input_section
->output_offset
5331 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5333 /* GDesc -> IE transition.
5340 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5341 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5349 case R_X86_64_TLSLD
:
5350 if (! elf_x86_64_tls_transition (info
, input_bfd
,
5351 input_section
, contents
,
5352 symtab_hdr
, sym_hashes
,
5353 &r_type
, GOT_UNKNOWN
,
5354 rel
, relend
, h
, r_symndx
))
5357 if (r_type
!= R_X86_64_TLSLD
)
5359 /* LD->LE transition:
5360 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
5361 For 64bit, we change it into:
5362 .word 0x6666; .byte 0x66; movq %fs:0, %rax.
5363 For 32bit, we change it into:
5364 nopl 0x0(%rax); movl %fs:0, %eax.
5365 For largepic, change:
5366 leaq foo@tlsgd(%rip), %rdi
5367 movabsq $__tls_get_addr@pltoff, %rax
5371 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
5374 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
5375 if (ABI_64_P (output_bfd
)
5376 && contents
[rel
->r_offset
+ 5] == (bfd_byte
) '\xb8')
5377 memcpy (contents
+ rel
->r_offset
- 3,
5378 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
5379 "\x64\x48\x8b\x04\x25\0\0\0", 22);
5380 else if (ABI_64_P (output_bfd
))
5381 memcpy (contents
+ rel
->r_offset
- 3,
5382 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
5384 memcpy (contents
+ rel
->r_offset
- 3,
5385 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
5386 /* Skip R_X86_64_PC32/R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5392 if (htab
->elf
.sgot
== NULL
)
5395 off
= htab
->tls_ld_got
.offset
;
5400 Elf_Internal_Rela outrel
;
5402 if (htab
->elf
.srelgot
== NULL
)
5405 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5406 + htab
->elf
.sgot
->output_offset
+ off
);
5408 bfd_put_64 (output_bfd
, 0,
5409 htab
->elf
.sgot
->contents
+ off
);
5410 bfd_put_64 (output_bfd
, 0,
5411 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5412 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
5413 outrel
.r_addend
= 0;
5414 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
5416 htab
->tls_ld_got
.offset
|= 1;
5418 relocation
= htab
->elf
.sgot
->output_section
->vma
5419 + htab
->elf
.sgot
->output_offset
+ off
;
5420 unresolved_reloc
= FALSE
;
5423 case R_X86_64_DTPOFF32
:
5424 if (!bfd_link_executable (info
)
5425 || (input_section
->flags
& SEC_CODE
) == 0)
5426 relocation
-= elf_x86_64_dtpoff_base (info
);
5428 relocation
= elf_x86_64_tpoff (info
, relocation
);
5431 case R_X86_64_TPOFF32
:
5432 case R_X86_64_TPOFF64
:
5433 BFD_ASSERT (bfd_link_executable (info
));
5434 relocation
= elf_x86_64_tpoff (info
, relocation
);
5437 case R_X86_64_DTPOFF64
:
5438 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
5439 relocation
-= elf_x86_64_dtpoff_base (info
);
5446 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5447 because such sections are not SEC_ALLOC and thus ld.so will
5448 not process them. */
5449 if (unresolved_reloc
5450 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
5452 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5453 rel
->r_offset
) != (bfd_vma
) -1)
5455 (*_bfd_error_handler
)
5456 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5459 (long) rel
->r_offset
,
5461 h
->root
.root
.string
);
5466 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5467 contents
, rel
->r_offset
,
5468 relocation
, rel
->r_addend
);
5470 check_relocation_error
:
5471 if (r
!= bfd_reloc_ok
)
5476 name
= h
->root
.root
.string
;
5479 name
= bfd_elf_string_from_elf_section (input_bfd
,
5480 symtab_hdr
->sh_link
,
5485 name
= bfd_section_name (input_bfd
, sec
);
5488 if (r
== bfd_reloc_overflow
)
5490 if (! ((*info
->callbacks
->reloc_overflow
)
5491 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5492 (bfd_vma
) 0, input_bfd
, input_section
,
5498 (*_bfd_error_handler
)
5499 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5500 input_bfd
, input_section
,
5501 (long) rel
->r_offset
, name
, (int) r
);
5512 Elf_Internal_Shdr
*rel_hdr
;
5513 size_t deleted
= rel
- wrel
;
5515 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
5516 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5517 if (rel_hdr
->sh_size
== 0)
5519 /* It is too late to remove an empty reloc section. Leave
5521 ??? What is wrong with an empty section??? */
5522 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
5525 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5526 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5527 input_section
->reloc_count
-= deleted
;
5533 /* Finish up dynamic symbol handling. We set the contents of various
5534 dynamic sections here. */
5537 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
5538 struct bfd_link_info
*info
,
5539 struct elf_link_hash_entry
*h
,
5540 Elf_Internal_Sym
*sym
)
5542 struct elf_x86_64_link_hash_table
*htab
;
5543 const struct elf_x86_64_backend_data
*abed
;
5544 bfd_boolean use_plt_bnd
;
5545 struct elf_x86_64_link_hash_entry
*eh
;
5546 bfd_boolean local_undefweak
;
5548 htab
= elf_x86_64_hash_table (info
);
5552 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5553 section only if there is .plt section. */
5554 use_plt_bnd
= htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
;
5556 ? &elf_x86_64_bnd_arch_bed
5557 : get_elf_x86_64_backend_data (output_bfd
));
5559 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
5561 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5562 resolved undefined weak symbols in executable so that their
5563 references have value 0 at run-time. */
5564 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, eh
);
5566 if (h
->plt
.offset
!= (bfd_vma
) -1)
5569 bfd_vma got_offset
, plt_offset
, plt_plt_offset
, plt_got_offset
;
5570 bfd_vma plt_plt_insn_end
, plt_got_insn_size
;
5571 Elf_Internal_Rela rela
;
5573 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
5574 const struct elf_backend_data
*bed
;
5575 bfd_vma plt_got_pcrel_offset
;
5577 /* When building a static executable, use .iplt, .igot.plt and
5578 .rela.iplt sections for STT_GNU_IFUNC symbols. */
5579 if (htab
->elf
.splt
!= NULL
)
5581 plt
= htab
->elf
.splt
;
5582 gotplt
= htab
->elf
.sgotplt
;
5583 relplt
= htab
->elf
.srelplt
;
5587 plt
= htab
->elf
.iplt
;
5588 gotplt
= htab
->elf
.igotplt
;
5589 relplt
= htab
->elf
.irelplt
;
5592 /* This symbol has an entry in the procedure linkage table. Set
5594 if ((h
->dynindx
== -1
5596 && !((h
->forced_local
|| bfd_link_executable (info
))
5598 && h
->type
== STT_GNU_IFUNC
))
5604 /* Get the index in the procedure linkage table which
5605 corresponds to this symbol. This is the index of this symbol
5606 in all the symbols for which we are making plt entries. The
5607 first entry in the procedure linkage table is reserved.
5609 Get the offset into the .got table of the entry that
5610 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
5611 bytes. The first three are reserved for the dynamic linker.
5613 For static executables, we don't reserve anything. */
5615 if (plt
== htab
->elf
.splt
)
5617 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
5618 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
5622 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
5623 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
5626 plt_plt_insn_end
= abed
->plt_plt_insn_end
;
5627 plt_plt_offset
= abed
->plt_plt_offset
;
5628 plt_got_insn_size
= abed
->plt_got_insn_size
;
5629 plt_got_offset
= abed
->plt_got_offset
;
5632 /* Use the second PLT with BND relocations. */
5633 const bfd_byte
*plt_entry
, *plt2_entry
;
5635 if (eh
->has_bnd_reloc
)
5637 plt_entry
= elf_x86_64_bnd_plt_entry
;
5638 plt2_entry
= elf_x86_64_bnd_plt2_entry
;
5642 plt_entry
= elf_x86_64_legacy_plt_entry
;
5643 plt2_entry
= elf_x86_64_legacy_plt2_entry
;
5645 /* Subtract 1 since there is no BND prefix. */
5646 plt_plt_insn_end
-= 1;
5647 plt_plt_offset
-= 1;
5648 plt_got_insn_size
-= 1;
5649 plt_got_offset
-= 1;
5652 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry
)
5653 == sizeof (elf_x86_64_legacy_plt_entry
));
5655 /* Fill in the entry in the procedure linkage table. */
5656 memcpy (plt
->contents
+ h
->plt
.offset
,
5657 plt_entry
, sizeof (elf_x86_64_legacy_plt_entry
));
5658 /* Fill in the entry in the second PLT. */
5659 memcpy (htab
->plt_bnd
->contents
+ eh
->plt_bnd
.offset
,
5660 plt2_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5662 resolved_plt
= htab
->plt_bnd
;
5663 plt_offset
= eh
->plt_bnd
.offset
;
5667 /* Fill in the entry in the procedure linkage table. */
5668 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
5669 abed
->plt_entry_size
);
5672 plt_offset
= h
->plt
.offset
;
5675 /* Insert the relocation positions of the plt section. */
5677 /* Put offset the PC-relative instruction referring to the GOT entry,
5678 subtracting the size of that instruction. */
5679 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
5680 + gotplt
->output_offset
5682 - resolved_plt
->output_section
->vma
5683 - resolved_plt
->output_offset
5685 - plt_got_insn_size
);
5687 /* Check PC-relative offset overflow in PLT entry. */
5688 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
5689 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5690 output_bfd
, h
->root
.root
.string
);
5692 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
5693 resolved_plt
->contents
+ plt_offset
+ plt_got_offset
);
5695 /* Fill in the entry in the global offset table, initially this
5696 points to the second part of the PLT entry. Leave the entry
5697 as zero for undefined weak symbol in PIE. No PLT relocation
5698 against undefined weak symbol in PIE. */
5699 if (!local_undefweak
)
5701 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5702 + plt
->output_offset
5704 + abed
->plt_lazy_offset
),
5705 gotplt
->contents
+ got_offset
);
5707 /* Fill in the entry in the .rela.plt section. */
5708 rela
.r_offset
= (gotplt
->output_section
->vma
5709 + gotplt
->output_offset
5711 if (h
->dynindx
== -1
5712 || ((bfd_link_executable (info
)
5713 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5715 && h
->type
== STT_GNU_IFUNC
))
5717 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5718 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
5719 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
5720 rela
.r_addend
= (h
->root
.u
.def
.value
5721 + h
->root
.u
.def
.section
->output_section
->vma
5722 + h
->root
.u
.def
.section
->output_offset
);
5723 /* R_X86_64_IRELATIVE comes last. */
5724 plt_index
= htab
->next_irelative_index
--;
5728 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
5730 plt_index
= htab
->next_jump_slot_index
++;
5733 /* Don't fill PLT entry for static executables. */
5734 if (plt
== htab
->elf
.splt
)
5736 bfd_vma plt0_offset
= h
->plt
.offset
+ plt_plt_insn_end
;
5738 /* Put relocation index. */
5739 bfd_put_32 (output_bfd
, plt_index
,
5740 (plt
->contents
+ h
->plt
.offset
5741 + abed
->plt_reloc_offset
));
5743 /* Put offset for jmp .PLT0 and check for overflow. We don't
5744 check relocation index for overflow since branch displacement
5745 will overflow first. */
5746 if (plt0_offset
> 0x80000000)
5747 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5748 output_bfd
, h
->root
.root
.string
);
5749 bfd_put_32 (output_bfd
, - plt0_offset
,
5750 plt
->contents
+ h
->plt
.offset
+ plt_plt_offset
);
5753 bed
= get_elf_backend_data (output_bfd
);
5754 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
5755 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
5758 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5760 bfd_vma got_offset
, plt_offset
, plt_got_offset
, plt_got_insn_size
;
5761 asection
*plt
, *got
;
5762 bfd_boolean got_after_plt
;
5763 int32_t got_pcrel_offset
;
5764 const bfd_byte
*got_plt_entry
;
5766 /* Set the entry in the GOT procedure linkage table. */
5767 plt
= htab
->plt_got
;
5768 got
= htab
->elf
.sgot
;
5769 got_offset
= h
->got
.offset
;
5771 if (got_offset
== (bfd_vma
) -1
5772 || h
->type
== STT_GNU_IFUNC
5777 /* Use the second PLT entry template for the GOT PLT since they
5778 are the identical. */
5779 plt_got_insn_size
= elf_x86_64_bnd_arch_bed
.plt_got_insn_size
;
5780 plt_got_offset
= elf_x86_64_bnd_arch_bed
.plt_got_offset
;
5781 if (eh
->has_bnd_reloc
)
5782 got_plt_entry
= elf_x86_64_bnd_plt2_entry
;
5785 got_plt_entry
= elf_x86_64_legacy_plt2_entry
;
5787 /* Subtract 1 since there is no BND prefix. */
5788 plt_got_insn_size
-= 1;
5789 plt_got_offset
-= 1;
5792 /* Fill in the entry in the GOT procedure linkage table. */
5793 plt_offset
= eh
->plt_got
.offset
;
5794 memcpy (plt
->contents
+ plt_offset
,
5795 got_plt_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5797 /* Put offset the PC-relative instruction referring to the GOT
5798 entry, subtracting the size of that instruction. */
5799 got_pcrel_offset
= (got
->output_section
->vma
5800 + got
->output_offset
5802 - plt
->output_section
->vma
5803 - plt
->output_offset
5805 - plt_got_insn_size
);
5807 /* Check PC-relative offset overflow in GOT PLT entry. */
5808 got_after_plt
= got
->output_section
->vma
> plt
->output_section
->vma
;
5809 if ((got_after_plt
&& got_pcrel_offset
< 0)
5810 || (!got_after_plt
&& got_pcrel_offset
> 0))
5811 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
5812 output_bfd
, h
->root
.root
.string
);
5814 bfd_put_32 (output_bfd
, got_pcrel_offset
,
5815 plt
->contents
+ plt_offset
+ plt_got_offset
);
5818 if (!local_undefweak
5820 && (h
->plt
.offset
!= (bfd_vma
) -1
5821 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5823 /* Mark the symbol as undefined, rather than as defined in
5824 the .plt section. Leave the value if there were any
5825 relocations where pointer equality matters (this is a clue
5826 for the dynamic linker, to make function pointer
5827 comparisons work between an application and shared
5828 library), otherwise set it to zero. If a function is only
5829 called from a binary, there is no need to slow down
5830 shared libraries because of that. */
5831 sym
->st_shndx
= SHN_UNDEF
;
5832 if (!h
->pointer_equality_needed
)
5836 /* Don't generate dynamic GOT relocation against undefined weak
5837 symbol in executable. */
5838 if (h
->got
.offset
!= (bfd_vma
) -1
5839 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
5840 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
5841 && !local_undefweak
)
5843 Elf_Internal_Rela rela
;
5845 /* This symbol has an entry in the global offset table. Set it
5847 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5850 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5851 + htab
->elf
.sgot
->output_offset
5852 + (h
->got
.offset
&~ (bfd_vma
) 1));
5854 /* If this is a static link, or it is a -Bsymbolic link and the
5855 symbol is defined locally or was forced to be local because
5856 of a version file, we just want to emit a RELATIVE reloc.
5857 The entry in the global offset table will already have been
5858 initialized in the relocate_section function. */
5860 && h
->type
== STT_GNU_IFUNC
)
5862 if (bfd_link_pic (info
))
5864 /* Generate R_X86_64_GLOB_DAT. */
5871 if (!h
->pointer_equality_needed
)
5874 /* For non-shared object, we can't use .got.plt, which
5875 contains the real function addres if we need pointer
5876 equality. We load the GOT entry with the PLT entry. */
5877 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
5878 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5879 + plt
->output_offset
5881 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5885 else if (bfd_link_pic (info
)
5886 && SYMBOL_REFERENCES_LOCAL (info
, h
))
5888 if (!h
->def_regular
)
5890 BFD_ASSERT((h
->got
.offset
& 1) != 0);
5891 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
5892 rela
.r_addend
= (h
->root
.u
.def
.value
5893 + h
->root
.u
.def
.section
->output_section
->vma
5894 + h
->root
.u
.def
.section
->output_offset
);
5898 BFD_ASSERT((h
->got
.offset
& 1) == 0);
5900 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5901 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
5902 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
5906 elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &rela
);
5911 Elf_Internal_Rela rela
;
5913 /* This symbol needs a copy reloc. Set it up. */
5915 if (h
->dynindx
== -1
5916 || (h
->root
.type
!= bfd_link_hash_defined
5917 && h
->root
.type
!= bfd_link_hash_defweak
)
5918 || htab
->srelbss
== NULL
)
5921 rela
.r_offset
= (h
->root
.u
.def
.value
5922 + h
->root
.u
.def
.section
->output_section
->vma
5923 + h
->root
.u
.def
.section
->output_offset
);
5924 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
5926 elf_append_rela (output_bfd
, htab
->srelbss
, &rela
);
5932 /* Finish up local dynamic symbol handling. We set the contents of
5933 various dynamic sections here. */
5936 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
5938 struct elf_link_hash_entry
*h
5939 = (struct elf_link_hash_entry
*) *slot
;
5940 struct bfd_link_info
*info
5941 = (struct bfd_link_info
*) inf
;
5943 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5947 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
5948 here since undefined weak symbol may not be dynamic and may not be
5949 called for elf_x86_64_finish_dynamic_symbol. */
5952 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
5955 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
5956 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5958 if (h
->root
.type
!= bfd_link_hash_undefweak
5959 || h
->dynindx
!= -1)
5962 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
5966 /* Used to decide how to sort relocs in an optimal manner for the
5967 dynamic linker, before writing them out. */
5969 static enum elf_reloc_type_class
5970 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info
,
5971 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5972 const Elf_Internal_Rela
*rela
)
5974 bfd
*abfd
= info
->output_bfd
;
5975 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5976 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
5978 if (htab
->elf
.dynsym
!= NULL
5979 && htab
->elf
.dynsym
->contents
!= NULL
)
5981 /* Check relocation against STT_GNU_IFUNC symbol if there are
5983 unsigned long r_symndx
= htab
->r_sym (rela
->r_info
);
5984 Elf_Internal_Sym sym
;
5985 if (!bed
->s
->swap_symbol_in (abfd
,
5986 (htab
->elf
.dynsym
->contents
5987 + r_symndx
* bed
->s
->sizeof_sym
),
5991 if (ELF_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
5992 return reloc_class_ifunc
;
5995 switch ((int) ELF32_R_TYPE (rela
->r_info
))
5997 case R_X86_64_RELATIVE
:
5998 case R_X86_64_RELATIVE64
:
5999 return reloc_class_relative
;
6000 case R_X86_64_JUMP_SLOT
:
6001 return reloc_class_plt
;
6003 return reloc_class_copy
;
6005 return reloc_class_normal
;
6009 /* Finish up the dynamic sections. */
6012 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
6013 struct bfd_link_info
*info
)
6015 struct elf_x86_64_link_hash_table
*htab
;
6018 const struct elf_x86_64_backend_data
*abed
;
6020 htab
= elf_x86_64_hash_table (info
);
6024 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
6025 section only if there is .plt section. */
6026 abed
= (htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
6027 ? &elf_x86_64_bnd_arch_bed
6028 : get_elf_x86_64_backend_data (output_bfd
));
6030 dynobj
= htab
->elf
.dynobj
;
6031 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
6033 if (htab
->elf
.dynamic_sections_created
)
6035 bfd_byte
*dyncon
, *dynconend
;
6036 const struct elf_backend_data
*bed
;
6037 bfd_size_type sizeof_dyn
;
6039 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
6042 bed
= get_elf_backend_data (dynobj
);
6043 sizeof_dyn
= bed
->s
->sizeof_dyn
;
6044 dyncon
= sdyn
->contents
;
6045 dynconend
= sdyn
->contents
+ sdyn
->size
;
6046 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
6048 Elf_Internal_Dyn dyn
;
6051 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
6059 s
= htab
->elf
.sgotplt
;
6060 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
6064 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
6068 s
= htab
->elf
.srelplt
->output_section
;
6069 dyn
.d_un
.d_val
= s
->size
;
6073 /* The procedure linkage table relocs (DT_JMPREL) should
6074 not be included in the overall relocs (DT_RELA).
6075 Therefore, we override the DT_RELASZ entry here to
6076 make it not include the JMPREL relocs. Since the
6077 linker script arranges for .rela.plt to follow all
6078 other relocation sections, we don't have to worry
6079 about changing the DT_RELA entry. */
6080 if (htab
->elf
.srelplt
!= NULL
)
6082 s
= htab
->elf
.srelplt
->output_section
;
6083 dyn
.d_un
.d_val
-= s
->size
;
6087 case DT_TLSDESC_PLT
:
6089 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6090 + htab
->tlsdesc_plt
;
6093 case DT_TLSDESC_GOT
:
6095 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6096 + htab
->tlsdesc_got
;
6100 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
6103 /* Fill in the special first entry in the procedure linkage table. */
6104 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
6106 /* Fill in the first entry in the procedure linkage table. */
6107 memcpy (htab
->elf
.splt
->contents
,
6108 abed
->plt0_entry
, abed
->plt_entry_size
);
6109 /* Add offset for pushq GOT+8(%rip), since the instruction
6110 uses 6 bytes subtract this value. */
6111 bfd_put_32 (output_bfd
,
6112 (htab
->elf
.sgotplt
->output_section
->vma
6113 + htab
->elf
.sgotplt
->output_offset
6115 - htab
->elf
.splt
->output_section
->vma
6116 - htab
->elf
.splt
->output_offset
6118 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
6119 /* Add offset for the PC-relative instruction accessing GOT+16,
6120 subtracting the offset to the end of that instruction. */
6121 bfd_put_32 (output_bfd
,
6122 (htab
->elf
.sgotplt
->output_section
->vma
6123 + htab
->elf
.sgotplt
->output_offset
6125 - htab
->elf
.splt
->output_section
->vma
6126 - htab
->elf
.splt
->output_offset
6127 - abed
->plt0_got2_insn_end
),
6128 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
6130 elf_section_data (htab
->elf
.splt
->output_section
)
6131 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
6133 if (htab
->tlsdesc_plt
)
6135 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6136 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
6138 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
6139 abed
->plt0_entry
, abed
->plt_entry_size
);
6141 /* Add offset for pushq GOT+8(%rip), since the
6142 instruction uses 6 bytes subtract this value. */
6143 bfd_put_32 (output_bfd
,
6144 (htab
->elf
.sgotplt
->output_section
->vma
6145 + htab
->elf
.sgotplt
->output_offset
6147 - htab
->elf
.splt
->output_section
->vma
6148 - htab
->elf
.splt
->output_offset
6151 htab
->elf
.splt
->contents
6152 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
6153 /* Add offset for the PC-relative instruction accessing GOT+TDG,
6154 where TGD stands for htab->tlsdesc_got, subtracting the offset
6155 to the end of that instruction. */
6156 bfd_put_32 (output_bfd
,
6157 (htab
->elf
.sgot
->output_section
->vma
6158 + htab
->elf
.sgot
->output_offset
6160 - htab
->elf
.splt
->output_section
->vma
6161 - htab
->elf
.splt
->output_offset
6163 - abed
->plt0_got2_insn_end
),
6164 htab
->elf
.splt
->contents
6165 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
6170 if (htab
->plt_bnd
!= NULL
)
6171 elf_section_data (htab
->plt_bnd
->output_section
)
6172 ->this_hdr
.sh_entsize
= sizeof (elf_x86_64_bnd_plt2_entry
);
6174 if (htab
->elf
.sgotplt
)
6176 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
6178 (*_bfd_error_handler
)
6179 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
6183 /* Fill in the first three entries in the global offset table. */
6184 if (htab
->elf
.sgotplt
->size
> 0)
6186 /* Set the first entry in the global offset table to the address of
6187 the dynamic section. */
6189 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
6191 bfd_put_64 (output_bfd
,
6192 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
6193 htab
->elf
.sgotplt
->contents
);
6194 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
6195 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
6196 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
6199 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
6203 /* Adjust .eh_frame for .plt section. */
6204 if (htab
->plt_eh_frame
!= NULL
6205 && htab
->plt_eh_frame
->contents
!= NULL
)
6207 if (htab
->elf
.splt
!= NULL
6208 && htab
->elf
.splt
->size
!= 0
6209 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
6210 && htab
->elf
.splt
->output_section
!= NULL
6211 && htab
->plt_eh_frame
->output_section
!= NULL
)
6213 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
6214 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
6215 + htab
->plt_eh_frame
->output_offset
6216 + PLT_FDE_START_OFFSET
;
6217 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6218 htab
->plt_eh_frame
->contents
6219 + PLT_FDE_START_OFFSET
);
6221 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
6223 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6225 htab
->plt_eh_frame
->contents
))
6230 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
6231 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
6234 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
6235 htab_traverse (htab
->loc_hash_table
,
6236 elf_x86_64_finish_local_dynamic_symbol
,
6239 /* Fill PLT entries for undefined weak symbols in PIE. */
6240 if (bfd_link_pie (info
))
6241 bfd_hash_traverse (&info
->hash
->table
,
6242 elf_x86_64_pie_finish_undefweak_symbol
,
6248 /* Return an array of PLT entry symbol values. */
6251 elf_x86_64_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
6254 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
6257 bfd_vma
*plt_sym_val
;
6259 bfd_byte
*plt_contents
;
6260 const struct elf_x86_64_backend_data
*bed
;
6261 Elf_Internal_Shdr
*hdr
;
6264 /* Get the .plt section contents. PLT passed down may point to the
6265 .plt.bnd section. Make sure that PLT always points to the .plt
6267 plt_bnd
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6272 plt
= bfd_get_section_by_name (abfd
, ".plt");
6275 bed
= &elf_x86_64_bnd_arch_bed
;
6278 bed
= get_elf_x86_64_backend_data (abfd
);
6280 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
6281 if (plt_contents
== NULL
)
6283 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
6284 plt_contents
, 0, plt
->size
))
6287 free (plt_contents
);
6291 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
6292 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
6295 hdr
= &elf_section_data (relplt
)->this_hdr
;
6296 count
= relplt
->size
/ hdr
->sh_entsize
;
6298 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
6299 if (plt_sym_val
== NULL
)
6302 for (i
= 0; i
< count
; i
++)
6303 plt_sym_val
[i
] = -1;
6305 plt_offset
= bed
->plt_entry_size
;
6306 p
= relplt
->relocation
;
6307 for (i
= 0; i
< count
; i
++, p
++)
6311 /* Skip unknown relocation. */
6312 if (p
->howto
== NULL
)
6315 if (p
->howto
->type
!= R_X86_64_JUMP_SLOT
6316 && p
->howto
->type
!= R_X86_64_IRELATIVE
)
6319 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
6320 + bed
->plt_reloc_offset
));
6321 if (reloc_index
< count
)
6325 /* This is the index in .plt section. */
6326 long plt_index
= plt_offset
/ bed
->plt_entry_size
;
6327 /* Store VMA + the offset in .plt.bnd section. */
6328 plt_sym_val
[reloc_index
] =
6330 + (plt_index
- 1) * sizeof (elf_x86_64_legacy_plt2_entry
));
6333 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
6335 plt_offset
+= bed
->plt_entry_size
;
6337 /* PR binutils/18437: Skip extra relocations in the .rela.plt
6339 if (plt_offset
>= plt
->size
)
6343 free (plt_contents
);
6348 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
6352 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
6359 /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
6360 as PLT if it exists. */
6361 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6363 plt
= bfd_get_section_by_name (abfd
, ".plt");
6364 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
6365 dynsymcount
, dynsyms
, ret
,
6367 elf_x86_64_get_plt_sym_val
);
6370 /* Handle an x86-64 specific section when reading an object file. This
6371 is called when elfcode.h finds a section with an unknown type. */
6374 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
6375 const char *name
, int shindex
)
6377 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
6380 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
6386 /* Hook called by the linker routine which adds symbols from an object
6387 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
6391 elf_x86_64_add_symbol_hook (bfd
*abfd
,
6392 struct bfd_link_info
*info
,
6393 Elf_Internal_Sym
*sym
,
6394 const char **namep ATTRIBUTE_UNUSED
,
6395 flagword
*flagsp ATTRIBUTE_UNUSED
,
6401 switch (sym
->st_shndx
)
6403 case SHN_X86_64_LCOMMON
:
6404 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
6407 lcomm
= bfd_make_section_with_flags (abfd
,
6411 | SEC_LINKER_CREATED
));
6414 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
6417 *valp
= sym
->st_size
;
6421 if (ELF_ST_BIND (sym
->st_info
) == STB_GNU_UNIQUE
6422 && (abfd
->flags
& DYNAMIC
) == 0
6423 && bfd_get_flavour (info
->output_bfd
) == bfd_target_elf_flavour
)
6424 elf_tdata (info
->output_bfd
)->has_gnu_symbols
6425 |= elf_gnu_symbol_unique
;
6431 /* Given a BFD section, try to locate the corresponding ELF section
6435 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
6436 asection
*sec
, int *index_return
)
6438 if (sec
== &_bfd_elf_large_com_section
)
6440 *index_return
= SHN_X86_64_LCOMMON
;
6446 /* Process a symbol. */
6449 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
6452 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
6454 switch (elfsym
->internal_elf_sym
.st_shndx
)
6456 case SHN_X86_64_LCOMMON
:
6457 asym
->section
= &_bfd_elf_large_com_section
;
6458 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
6459 /* Common symbol doesn't set BSF_GLOBAL. */
6460 asym
->flags
&= ~BSF_GLOBAL
;
6466 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
6468 return (sym
->st_shndx
== SHN_COMMON
6469 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
6473 elf_x86_64_common_section_index (asection
*sec
)
6475 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6478 return SHN_X86_64_LCOMMON
;
6482 elf_x86_64_common_section (asection
*sec
)
6484 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6485 return bfd_com_section_ptr
;
6487 return &_bfd_elf_large_com_section
;
6491 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
6492 const Elf_Internal_Sym
*sym
,
6497 const asection
*oldsec
)
6499 /* A normal common symbol and a large common symbol result in a
6500 normal common symbol. We turn the large common symbol into a
6503 && h
->root
.type
== bfd_link_hash_common
6505 && bfd_is_com_section (*psec
)
6508 if (sym
->st_shndx
== SHN_COMMON
6509 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
6511 h
->root
.u
.c
.p
->section
6512 = bfd_make_section_old_way (oldbfd
, "COMMON");
6513 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
6515 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
6516 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
6517 *psec
= bfd_com_section_ptr
;
6524 elf_x86_64_additional_program_headers (bfd
*abfd
,
6525 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6530 /* Check to see if we need a large readonly segment. */
6531 s
= bfd_get_section_by_name (abfd
, ".lrodata");
6532 if (s
&& (s
->flags
& SEC_LOAD
))
6535 /* Check to see if we need a large data segment. Since .lbss sections
6536 is placed right after the .bss section, there should be no need for
6537 a large data segment just because of .lbss. */
6538 s
= bfd_get_section_by_name (abfd
, ".ldata");
6539 if (s
&& (s
->flags
& SEC_LOAD
))
6545 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6548 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
6550 if (h
->plt
.offset
!= (bfd_vma
) -1
6552 && !h
->pointer_equality_needed
)
6555 return _bfd_elf_hash_symbol (h
);
6558 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
6561 elf_x86_64_relocs_compatible (const bfd_target
*input
,
6562 const bfd_target
*output
)
6564 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
6565 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
6566 && _bfd_elf_relocs_compatible (input
, output
));
6569 static const struct bfd_elf_special_section
6570 elf_x86_64_special_sections
[]=
6572 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6573 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6574 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
6575 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6576 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6577 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6578 { NULL
, 0, 0, 0, 0 }
6581 #define TARGET_LITTLE_SYM x86_64_elf64_vec
6582 #define TARGET_LITTLE_NAME "elf64-x86-64"
6583 #define ELF_ARCH bfd_arch_i386
6584 #define ELF_TARGET_ID X86_64_ELF_DATA
6585 #define ELF_MACHINE_CODE EM_X86_64
6586 #define ELF_MAXPAGESIZE 0x200000
6587 #define ELF_MINPAGESIZE 0x1000
6588 #define ELF_COMMONPAGESIZE 0x1000
6590 #define elf_backend_can_gc_sections 1
6591 #define elf_backend_can_refcount 1
6592 #define elf_backend_want_got_plt 1
6593 #define elf_backend_plt_readonly 1
6594 #define elf_backend_want_plt_sym 0
6595 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
6596 #define elf_backend_rela_normal 1
6597 #define elf_backend_plt_alignment 4
6598 #define elf_backend_extern_protected_data 1
6600 #define elf_info_to_howto elf_x86_64_info_to_howto
6602 #define bfd_elf64_bfd_link_hash_table_create \
6603 elf_x86_64_link_hash_table_create
6604 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
6605 #define bfd_elf64_bfd_reloc_name_lookup \
6606 elf_x86_64_reloc_name_lookup
6608 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
6609 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
6610 #define elf_backend_check_relocs elf_x86_64_check_relocs
6611 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
6612 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
6613 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
6614 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
6615 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
6616 #define elf_backend_gc_sweep_hook elf_x86_64_gc_sweep_hook
6617 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
6618 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
6620 #define elf_backend_write_core_note elf_x86_64_write_core_note
6622 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
6623 #define elf_backend_relocate_section elf_x86_64_relocate_section
6624 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
6625 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
6626 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
6627 #define elf_backend_object_p elf64_x86_64_elf_object_p
6628 #define bfd_elf64_mkobject elf_x86_64_mkobject
6629 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
6631 #define elf_backend_section_from_shdr \
6632 elf_x86_64_section_from_shdr
6634 #define elf_backend_section_from_bfd_section \
6635 elf_x86_64_elf_section_from_bfd_section
6636 #define elf_backend_add_symbol_hook \
6637 elf_x86_64_add_symbol_hook
6638 #define elf_backend_symbol_processing \
6639 elf_x86_64_symbol_processing
6640 #define elf_backend_common_section_index \
6641 elf_x86_64_common_section_index
6642 #define elf_backend_common_section \
6643 elf_x86_64_common_section
6644 #define elf_backend_common_definition \
6645 elf_x86_64_common_definition
6646 #define elf_backend_merge_symbol \
6647 elf_x86_64_merge_symbol
6648 #define elf_backend_special_sections \
6649 elf_x86_64_special_sections
6650 #define elf_backend_additional_program_headers \
6651 elf_x86_64_additional_program_headers
6652 #define elf_backend_hash_symbol \
6653 elf_x86_64_hash_symbol
6654 #define elf_backend_omit_section_dynsym \
6655 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6656 #define elf_backend_fixup_symbol \
6657 elf_x86_64_fixup_symbol
6659 #include "elf64-target.h"
6661 /* CloudABI support. */
6663 #undef TARGET_LITTLE_SYM
6664 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
6665 #undef TARGET_LITTLE_NAME
6666 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
6669 #define ELF_OSABI ELFOSABI_CLOUDABI
6672 #define elf64_bed elf64_x86_64_cloudabi_bed
6674 #include "elf64-target.h"
6676 /* FreeBSD support. */
6678 #undef TARGET_LITTLE_SYM
6679 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
6680 #undef TARGET_LITTLE_NAME
6681 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
6684 #define ELF_OSABI ELFOSABI_FREEBSD
6687 #define elf64_bed elf64_x86_64_fbsd_bed
6689 #include "elf64-target.h"
6691 /* Solaris 2 support. */
6693 #undef TARGET_LITTLE_SYM
6694 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
6695 #undef TARGET_LITTLE_NAME
6696 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
6698 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6699 objects won't be recognized. */
6703 #define elf64_bed elf64_x86_64_sol2_bed
6705 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
6707 #undef elf_backend_static_tls_alignment
6708 #define elf_backend_static_tls_alignment 16
6710 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6712 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6714 #undef elf_backend_want_plt_sym
6715 #define elf_backend_want_plt_sym 1
6717 #undef elf_backend_strtab_flags
6718 #define elf_backend_strtab_flags SHF_STRINGS
6721 elf64_x86_64_set_special_info_link (const bfd
*ibfd ATTRIBUTE_UNUSED
,
6722 bfd
*obfd ATTRIBUTE_UNUSED
,
6723 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
6724 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
6726 /* PR 19938: FIXME: Need to add code for setting the sh_info
6727 and sh_link fields of Solaris specific section types. */
6731 #undef elf_backend_set_special_section_info_and_link
6732 #define elf_backend_set_special_section_info_and_link elf64_x86_64_set_special_info_link
6734 #include "elf64-target.h"
6736 /* Native Client support. */
6739 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
6741 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
6742 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
6746 #undef TARGET_LITTLE_SYM
6747 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
6748 #undef TARGET_LITTLE_NAME
6749 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
6751 #define elf64_bed elf64_x86_64_nacl_bed
6753 #undef ELF_MAXPAGESIZE
6754 #undef ELF_MINPAGESIZE
6755 #undef ELF_COMMONPAGESIZE
6756 #define ELF_MAXPAGESIZE 0x10000
6757 #define ELF_MINPAGESIZE 0x10000
6758 #define ELF_COMMONPAGESIZE 0x10000
6760 /* Restore defaults. */
6762 #undef elf_backend_static_tls_alignment
6763 #undef elf_backend_want_plt_sym
6764 #define elf_backend_want_plt_sym 0
6765 #undef elf_backend_strtab_flags
6766 #undef elf_backend_set_special_section_info_and_link
6768 /* NaCl uses substantially different PLT entries for the same effects. */
6770 #undef elf_backend_plt_alignment
6771 #define elf_backend_plt_alignment 5
6772 #define NACL_PLT_ENTRY_SIZE 64
6773 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6775 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
6777 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
6778 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
6779 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6780 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6781 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6783 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
6784 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
6786 /* 32 bytes of nop to pad out to the standard size. */
6787 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6788 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6789 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6790 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6791 0x66, /* excess data32 prefix */
6795 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6797 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
6798 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6799 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6800 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6802 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
6803 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6804 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6806 /* Lazy GOT entries point here (32-byte aligned). */
6807 0x68, /* pushq immediate */
6808 0, 0, 0, 0, /* replaced with index into relocation table. */
6809 0xe9, /* jmp relative */
6810 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
6812 /* 22 bytes of nop to pad out to the standard size. */
6813 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data32 prefixes */
6814 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6815 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
6818 /* .eh_frame covering the .plt section. */
6820 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
6822 #if (PLT_CIE_LENGTH != 20 \
6823 || PLT_FDE_LENGTH != 36 \
6824 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6825 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6826 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
6828 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6829 0, 0, 0, 0, /* CIE ID */
6830 1, /* CIE version */
6831 'z', 'R', 0, /* Augmentation string */
6832 1, /* Code alignment factor */
6833 0x78, /* Data alignment factor */
6834 16, /* Return address column */
6835 1, /* Augmentation size */
6836 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6837 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
6838 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
6839 DW_CFA_nop
, DW_CFA_nop
,
6841 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6842 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
6843 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
6844 0, 0, 0, 0, /* .plt size goes here */
6845 0, /* Augmentation size */
6846 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
6847 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6848 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
6849 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6850 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6851 13, /* Block length */
6852 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
6853 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
6854 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6855 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
6856 DW_CFA_nop
, DW_CFA_nop
6859 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
6861 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
6862 elf_x86_64_nacl_plt_entry
, /* plt_entry */
6863 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6864 2, /* plt0_got1_offset */
6865 9, /* plt0_got2_offset */
6866 13, /* plt0_got2_insn_end */
6867 3, /* plt_got_offset */
6868 33, /* plt_reloc_offset */
6869 38, /* plt_plt_offset */
6870 7, /* plt_got_insn_size */
6871 42, /* plt_plt_insn_end */
6872 32, /* plt_lazy_offset */
6873 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
6874 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
6877 #undef elf_backend_arch_data
6878 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
6880 #undef elf_backend_object_p
6881 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
6882 #undef elf_backend_modify_segment_map
6883 #define elf_backend_modify_segment_map nacl_modify_segment_map
6884 #undef elf_backend_modify_program_headers
6885 #define elf_backend_modify_program_headers nacl_modify_program_headers
6886 #undef elf_backend_final_write_processing
6887 #define elf_backend_final_write_processing nacl_final_write_processing
6889 #include "elf64-target.h"
6891 /* Native Client x32 support. */
6894 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
6896 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
6897 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
6901 #undef TARGET_LITTLE_SYM
6902 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
6903 #undef TARGET_LITTLE_NAME
6904 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
6906 #define elf32_bed elf32_x86_64_nacl_bed
6908 #define bfd_elf32_bfd_link_hash_table_create \
6909 elf_x86_64_link_hash_table_create
6910 #define bfd_elf32_bfd_reloc_type_lookup \
6911 elf_x86_64_reloc_type_lookup
6912 #define bfd_elf32_bfd_reloc_name_lookup \
6913 elf_x86_64_reloc_name_lookup
6914 #define bfd_elf32_mkobject \
6916 #define bfd_elf32_get_synthetic_symtab \
6917 elf_x86_64_get_synthetic_symtab
6919 #undef elf_backend_object_p
6920 #define elf_backend_object_p \
6921 elf32_x86_64_nacl_elf_object_p
6923 #undef elf_backend_bfd_from_remote_memory
6924 #define elf_backend_bfd_from_remote_memory \
6925 _bfd_elf32_bfd_from_remote_memory
6927 #undef elf_backend_size_info
6928 #define elf_backend_size_info \
6929 _bfd_elf32_size_info
6931 #include "elf32-target.h"
6933 /* Restore defaults. */
6934 #undef elf_backend_object_p
6935 #define elf_backend_object_p elf64_x86_64_elf_object_p
6936 #undef elf_backend_bfd_from_remote_memory
6937 #undef elf_backend_size_info
6938 #undef elf_backend_modify_segment_map
6939 #undef elf_backend_modify_program_headers
6940 #undef elf_backend_final_write_processing
6942 /* Intel L1OM support. */
6945 elf64_l1om_elf_object_p (bfd
*abfd
)
6947 /* Set the right machine number for an L1OM elf64 file. */
6948 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
6952 #undef TARGET_LITTLE_SYM
6953 #define TARGET_LITTLE_SYM l1om_elf64_vec
6954 #undef TARGET_LITTLE_NAME
6955 #define TARGET_LITTLE_NAME "elf64-l1om"
6957 #define ELF_ARCH bfd_arch_l1om
6959 #undef ELF_MACHINE_CODE
6960 #define ELF_MACHINE_CODE EM_L1OM
6965 #define elf64_bed elf64_l1om_bed
6967 #undef elf_backend_object_p
6968 #define elf_backend_object_p elf64_l1om_elf_object_p
6970 /* Restore defaults. */
6971 #undef ELF_MAXPAGESIZE
6972 #undef ELF_MINPAGESIZE
6973 #undef ELF_COMMONPAGESIZE
6974 #define ELF_MAXPAGESIZE 0x200000
6975 #define ELF_MINPAGESIZE 0x1000
6976 #define ELF_COMMONPAGESIZE 0x1000
6977 #undef elf_backend_plt_alignment
6978 #define elf_backend_plt_alignment 4
6979 #undef elf_backend_arch_data
6980 #define elf_backend_arch_data &elf_x86_64_arch_bed
6982 #include "elf64-target.h"
6984 /* FreeBSD L1OM support. */
6986 #undef TARGET_LITTLE_SYM
6987 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
6988 #undef TARGET_LITTLE_NAME
6989 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
6992 #define ELF_OSABI ELFOSABI_FREEBSD
6995 #define elf64_bed elf64_l1om_fbsd_bed
6997 #include "elf64-target.h"
6999 /* Intel K1OM support. */
7002 elf64_k1om_elf_object_p (bfd
*abfd
)
7004 /* Set the right machine number for an K1OM elf64 file. */
7005 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
7009 #undef TARGET_LITTLE_SYM
7010 #define TARGET_LITTLE_SYM k1om_elf64_vec
7011 #undef TARGET_LITTLE_NAME
7012 #define TARGET_LITTLE_NAME "elf64-k1om"
7014 #define ELF_ARCH bfd_arch_k1om
7016 #undef ELF_MACHINE_CODE
7017 #define ELF_MACHINE_CODE EM_K1OM
7022 #define elf64_bed elf64_k1om_bed
7024 #undef elf_backend_object_p
7025 #define elf_backend_object_p elf64_k1om_elf_object_p
7027 #undef elf_backend_static_tls_alignment
7029 #undef elf_backend_want_plt_sym
7030 #define elf_backend_want_plt_sym 0
7032 #include "elf64-target.h"
7034 /* FreeBSD K1OM support. */
7036 #undef TARGET_LITTLE_SYM
7037 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
7038 #undef TARGET_LITTLE_NAME
7039 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
7042 #define ELF_OSABI ELFOSABI_FREEBSD
7045 #define elf64_bed elf64_k1om_fbsd_bed
7047 #include "elf64-target.h"
7049 /* 32bit x86-64 support. */
7051 #undef TARGET_LITTLE_SYM
7052 #define TARGET_LITTLE_SYM x86_64_elf32_vec
7053 #undef TARGET_LITTLE_NAME
7054 #define TARGET_LITTLE_NAME "elf32-x86-64"
7058 #define ELF_ARCH bfd_arch_i386
7060 #undef ELF_MACHINE_CODE
7061 #define ELF_MACHINE_CODE EM_X86_64
7065 #undef elf_backend_object_p
7066 #define elf_backend_object_p \
7067 elf32_x86_64_elf_object_p
7069 #undef elf_backend_bfd_from_remote_memory
7070 #define elf_backend_bfd_from_remote_memory \
7071 _bfd_elf32_bfd_from_remote_memory
7073 #undef elf_backend_size_info
7074 #define elf_backend_size_info \
7075 _bfd_elf32_size_info
7077 #include "elf32-target.h"