1 /* X86-64 specific support for ELF
2 Copyright (C) 2000-2021 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. */
22 #include "elfxx-x86.h"
24 #include "libiberty.h"
26 #include "opcode/i386.h"
27 #include "elf/x86-64.h"
34 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
35 #define MINUS_ONE (~ (bfd_vma) 0)
37 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
38 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
39 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
40 since they are the same. */
42 /* The relocation "howto" table. Order of fields:
43 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
44 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
45 static reloc_howto_type x86_64_elf_howto_table
[] =
47 HOWTO(R_X86_64_NONE
, 0, 3, 0, FALSE
, 0, complain_overflow_dont
,
48 bfd_elf_generic_reloc
, "R_X86_64_NONE", FALSE
, 0x00000000, 0x00000000,
50 HOWTO(R_X86_64_64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
51 bfd_elf_generic_reloc
, "R_X86_64_64", FALSE
, MINUS_ONE
, MINUS_ONE
,
53 HOWTO(R_X86_64_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
54 bfd_elf_generic_reloc
, "R_X86_64_PC32", FALSE
, 0xffffffff, 0xffffffff,
56 HOWTO(R_X86_64_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
57 bfd_elf_generic_reloc
, "R_X86_64_GOT32", FALSE
, 0xffffffff, 0xffffffff,
59 HOWTO(R_X86_64_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
60 bfd_elf_generic_reloc
, "R_X86_64_PLT32", FALSE
, 0xffffffff, 0xffffffff,
62 HOWTO(R_X86_64_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
63 bfd_elf_generic_reloc
, "R_X86_64_COPY", FALSE
, 0xffffffff, 0xffffffff,
65 HOWTO(R_X86_64_GLOB_DAT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
66 bfd_elf_generic_reloc
, "R_X86_64_GLOB_DAT", FALSE
, MINUS_ONE
,
68 HOWTO(R_X86_64_JUMP_SLOT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
69 bfd_elf_generic_reloc
, "R_X86_64_JUMP_SLOT", FALSE
, MINUS_ONE
,
71 HOWTO(R_X86_64_RELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
72 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE", FALSE
, MINUS_ONE
,
74 HOWTO(R_X86_64_GOTPCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
75 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL", FALSE
, 0xffffffff,
77 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
78 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
80 HOWTO(R_X86_64_32S
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
81 bfd_elf_generic_reloc
, "R_X86_64_32S", FALSE
, 0xffffffff, 0xffffffff,
83 HOWTO(R_X86_64_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
84 bfd_elf_generic_reloc
, "R_X86_64_16", FALSE
, 0xffff, 0xffff, FALSE
),
85 HOWTO(R_X86_64_PC16
,0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
86 bfd_elf_generic_reloc
, "R_X86_64_PC16", FALSE
, 0xffff, 0xffff, TRUE
),
87 HOWTO(R_X86_64_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
88 bfd_elf_generic_reloc
, "R_X86_64_8", FALSE
, 0xff, 0xff, FALSE
),
89 HOWTO(R_X86_64_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
90 bfd_elf_generic_reloc
, "R_X86_64_PC8", FALSE
, 0xff, 0xff, TRUE
),
91 HOWTO(R_X86_64_DTPMOD64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
92 bfd_elf_generic_reloc
, "R_X86_64_DTPMOD64", FALSE
, MINUS_ONE
,
94 HOWTO(R_X86_64_DTPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
95 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF64", FALSE
, MINUS_ONE
,
97 HOWTO(R_X86_64_TPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
98 bfd_elf_generic_reloc
, "R_X86_64_TPOFF64", FALSE
, MINUS_ONE
,
100 HOWTO(R_X86_64_TLSGD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
101 bfd_elf_generic_reloc
, "R_X86_64_TLSGD", FALSE
, 0xffffffff,
103 HOWTO(R_X86_64_TLSLD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
104 bfd_elf_generic_reloc
, "R_X86_64_TLSLD", FALSE
, 0xffffffff,
106 HOWTO(R_X86_64_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
107 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF32", FALSE
, 0xffffffff,
109 HOWTO(R_X86_64_GOTTPOFF
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
110 bfd_elf_generic_reloc
, "R_X86_64_GOTTPOFF", FALSE
, 0xffffffff,
112 HOWTO(R_X86_64_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
113 bfd_elf_generic_reloc
, "R_X86_64_TPOFF32", FALSE
, 0xffffffff,
115 HOWTO(R_X86_64_PC64
, 0, 4, 64, TRUE
, 0, complain_overflow_bitfield
,
116 bfd_elf_generic_reloc
, "R_X86_64_PC64", FALSE
, MINUS_ONE
, MINUS_ONE
,
118 HOWTO(R_X86_64_GOTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
119 bfd_elf_generic_reloc
, "R_X86_64_GOTOFF64",
120 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
121 HOWTO(R_X86_64_GOTPC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
122 bfd_elf_generic_reloc
, "R_X86_64_GOTPC32",
123 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
124 HOWTO(R_X86_64_GOT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
125 bfd_elf_generic_reloc
, "R_X86_64_GOT64", FALSE
, MINUS_ONE
, MINUS_ONE
,
127 HOWTO(R_X86_64_GOTPCREL64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
128 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL64", FALSE
, MINUS_ONE
,
130 HOWTO(R_X86_64_GOTPC64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
131 bfd_elf_generic_reloc
, "R_X86_64_GOTPC64",
132 FALSE
, MINUS_ONE
, MINUS_ONE
, TRUE
),
133 HOWTO(R_X86_64_GOTPLT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
134 bfd_elf_generic_reloc
, "R_X86_64_GOTPLT64", FALSE
, MINUS_ONE
,
136 HOWTO(R_X86_64_PLTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
137 bfd_elf_generic_reloc
, "R_X86_64_PLTOFF64", FALSE
, MINUS_ONE
,
139 HOWTO(R_X86_64_SIZE32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
140 bfd_elf_generic_reloc
, "R_X86_64_SIZE32", FALSE
, 0xffffffff, 0xffffffff,
142 HOWTO(R_X86_64_SIZE64
, 0, 4, 64, FALSE
, 0, complain_overflow_unsigned
,
143 bfd_elf_generic_reloc
, "R_X86_64_SIZE64", FALSE
, MINUS_ONE
, MINUS_ONE
,
145 HOWTO(R_X86_64_GOTPC32_TLSDESC
, 0, 2, 32, TRUE
, 0,
146 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
147 "R_X86_64_GOTPC32_TLSDESC",
148 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
149 HOWTO(R_X86_64_TLSDESC_CALL
, 0, 0, 0, FALSE
, 0,
150 complain_overflow_dont
, bfd_elf_generic_reloc
,
151 "R_X86_64_TLSDESC_CALL",
153 HOWTO(R_X86_64_TLSDESC
, 0, 4, 64, FALSE
, 0,
154 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
156 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
157 HOWTO(R_X86_64_IRELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
158 bfd_elf_generic_reloc
, "R_X86_64_IRELATIVE", FALSE
, MINUS_ONE
,
160 HOWTO(R_X86_64_RELATIVE64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
161 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE64", FALSE
, MINUS_ONE
,
163 HOWTO(R_X86_64_PC32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
164 bfd_elf_generic_reloc
, "R_X86_64_PC32_BND", FALSE
, 0xffffffff, 0xffffffff,
166 HOWTO(R_X86_64_PLT32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
167 bfd_elf_generic_reloc
, "R_X86_64_PLT32_BND", FALSE
, 0xffffffff, 0xffffffff,
169 HOWTO(R_X86_64_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
170 bfd_elf_generic_reloc
, "R_X86_64_GOTPCRELX", FALSE
, 0xffffffff,
172 HOWTO(R_X86_64_REX_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
173 bfd_elf_generic_reloc
, "R_X86_64_REX_GOTPCRELX", FALSE
, 0xffffffff,
176 /* We have a gap in the reloc numbers here.
177 R_X86_64_standard counts the number up to this point, and
178 R_X86_64_vt_offset is the value to subtract from a reloc type of
179 R_X86_64_GNU_VT* to form an index into this table. */
180 #define R_X86_64_standard (R_X86_64_REX_GOTPCRELX + 1)
181 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
183 /* GNU extension to record C++ vtable hierarchy. */
184 HOWTO (R_X86_64_GNU_VTINHERIT
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
185 NULL
, "R_X86_64_GNU_VTINHERIT", FALSE
, 0, 0, FALSE
),
187 /* GNU extension to record C++ vtable member usage. */
188 HOWTO (R_X86_64_GNU_VTENTRY
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
189 _bfd_elf_rel_vtable_reloc_fn
, "R_X86_64_GNU_VTENTRY", FALSE
, 0, 0,
192 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
193 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
194 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
198 #define X86_PCREL_TYPE_P(TYPE) \
199 ( ((TYPE) == R_X86_64_PC8) \
200 || ((TYPE) == R_X86_64_PC16) \
201 || ((TYPE) == R_X86_64_PC32) \
202 || ((TYPE) == R_X86_64_PC32_BND) \
203 || ((TYPE) == R_X86_64_PC64))
205 #define X86_SIZE_TYPE_P(TYPE) \
206 ((TYPE) == R_X86_64_SIZE32 || (TYPE) == R_X86_64_SIZE64)
208 /* Map BFD relocs to the x86_64 elf relocs. */
211 bfd_reloc_code_real_type bfd_reloc_val
;
212 unsigned char elf_reloc_val
;
215 static const struct elf_reloc_map x86_64_reloc_map
[] =
217 { BFD_RELOC_NONE
, R_X86_64_NONE
, },
218 { BFD_RELOC_64
, R_X86_64_64
, },
219 { BFD_RELOC_32_PCREL
, R_X86_64_PC32
, },
220 { BFD_RELOC_X86_64_GOT32
, R_X86_64_GOT32
,},
221 { BFD_RELOC_X86_64_PLT32
, R_X86_64_PLT32
,},
222 { BFD_RELOC_X86_64_COPY
, R_X86_64_COPY
, },
223 { BFD_RELOC_X86_64_GLOB_DAT
, R_X86_64_GLOB_DAT
, },
224 { BFD_RELOC_X86_64_JUMP_SLOT
, R_X86_64_JUMP_SLOT
, },
225 { BFD_RELOC_X86_64_RELATIVE
, R_X86_64_RELATIVE
, },
226 { BFD_RELOC_X86_64_GOTPCREL
, R_X86_64_GOTPCREL
, },
227 { BFD_RELOC_32
, R_X86_64_32
, },
228 { BFD_RELOC_X86_64_32S
, R_X86_64_32S
, },
229 { BFD_RELOC_16
, R_X86_64_16
, },
230 { BFD_RELOC_16_PCREL
, R_X86_64_PC16
, },
231 { BFD_RELOC_8
, R_X86_64_8
, },
232 { BFD_RELOC_8_PCREL
, R_X86_64_PC8
, },
233 { BFD_RELOC_X86_64_DTPMOD64
, R_X86_64_DTPMOD64
, },
234 { BFD_RELOC_X86_64_DTPOFF64
, R_X86_64_DTPOFF64
, },
235 { BFD_RELOC_X86_64_TPOFF64
, R_X86_64_TPOFF64
, },
236 { BFD_RELOC_X86_64_TLSGD
, R_X86_64_TLSGD
, },
237 { BFD_RELOC_X86_64_TLSLD
, R_X86_64_TLSLD
, },
238 { BFD_RELOC_X86_64_DTPOFF32
, R_X86_64_DTPOFF32
, },
239 { BFD_RELOC_X86_64_GOTTPOFF
, R_X86_64_GOTTPOFF
, },
240 { BFD_RELOC_X86_64_TPOFF32
, R_X86_64_TPOFF32
, },
241 { BFD_RELOC_64_PCREL
, R_X86_64_PC64
, },
242 { BFD_RELOC_X86_64_GOTOFF64
, R_X86_64_GOTOFF64
, },
243 { BFD_RELOC_X86_64_GOTPC32
, R_X86_64_GOTPC32
, },
244 { BFD_RELOC_X86_64_GOT64
, R_X86_64_GOT64
, },
245 { BFD_RELOC_X86_64_GOTPCREL64
,R_X86_64_GOTPCREL64
, },
246 { BFD_RELOC_X86_64_GOTPC64
, R_X86_64_GOTPC64
, },
247 { BFD_RELOC_X86_64_GOTPLT64
, R_X86_64_GOTPLT64
, },
248 { BFD_RELOC_X86_64_PLTOFF64
, R_X86_64_PLTOFF64
, },
249 { BFD_RELOC_SIZE32
, R_X86_64_SIZE32
, },
250 { BFD_RELOC_SIZE64
, R_X86_64_SIZE64
, },
251 { BFD_RELOC_X86_64_GOTPC32_TLSDESC
, R_X86_64_GOTPC32_TLSDESC
, },
252 { BFD_RELOC_X86_64_TLSDESC_CALL
, R_X86_64_TLSDESC_CALL
, },
253 { BFD_RELOC_X86_64_TLSDESC
, R_X86_64_TLSDESC
, },
254 { BFD_RELOC_X86_64_IRELATIVE
, R_X86_64_IRELATIVE
, },
255 { BFD_RELOC_X86_64_PC32_BND
, R_X86_64_PC32_BND
, },
256 { BFD_RELOC_X86_64_PLT32_BND
, R_X86_64_PLT32_BND
, },
257 { BFD_RELOC_X86_64_GOTPCRELX
, R_X86_64_GOTPCRELX
, },
258 { BFD_RELOC_X86_64_REX_GOTPCRELX
, R_X86_64_REX_GOTPCRELX
, },
259 { BFD_RELOC_VTABLE_INHERIT
, R_X86_64_GNU_VTINHERIT
, },
260 { BFD_RELOC_VTABLE_ENTRY
, R_X86_64_GNU_VTENTRY
, },
263 static reloc_howto_type
*
264 elf_x86_64_rtype_to_howto (bfd
*abfd
, unsigned r_type
)
268 if (r_type
== (unsigned int) R_X86_64_32
)
273 i
= ARRAY_SIZE (x86_64_elf_howto_table
) - 1;
275 else if (r_type
< (unsigned int) R_X86_64_GNU_VTINHERIT
276 || r_type
>= (unsigned int) R_X86_64_max
)
278 if (r_type
>= (unsigned int) R_X86_64_standard
)
280 /* xgettext:c-format */
281 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
283 bfd_set_error (bfd_error_bad_value
);
289 i
= r_type
- (unsigned int) R_X86_64_vt_offset
;
290 BFD_ASSERT (x86_64_elf_howto_table
[i
].type
== r_type
);
291 return &x86_64_elf_howto_table
[i
];
294 /* Given a BFD reloc type, return a HOWTO structure. */
295 static reloc_howto_type
*
296 elf_x86_64_reloc_type_lookup (bfd
*abfd
,
297 bfd_reloc_code_real_type code
)
301 for (i
= 0; i
< sizeof (x86_64_reloc_map
) / sizeof (struct elf_reloc_map
);
304 if (x86_64_reloc_map
[i
].bfd_reloc_val
== code
)
305 return elf_x86_64_rtype_to_howto (abfd
,
306 x86_64_reloc_map
[i
].elf_reloc_val
);
311 static reloc_howto_type
*
312 elf_x86_64_reloc_name_lookup (bfd
*abfd
,
317 if (!ABI_64_P (abfd
) && strcasecmp (r_name
, "R_X86_64_32") == 0)
319 /* Get x32 R_X86_64_32. */
320 reloc_howto_type
*reloc
321 = &x86_64_elf_howto_table
[ARRAY_SIZE (x86_64_elf_howto_table
) - 1];
322 BFD_ASSERT (reloc
->type
== (unsigned int) R_X86_64_32
);
326 for (i
= 0; i
< ARRAY_SIZE (x86_64_elf_howto_table
); i
++)
327 if (x86_64_elf_howto_table
[i
].name
!= NULL
328 && strcasecmp (x86_64_elf_howto_table
[i
].name
, r_name
) == 0)
329 return &x86_64_elf_howto_table
[i
];
334 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
337 elf_x86_64_info_to_howto (bfd
*abfd
, arelent
*cache_ptr
,
338 Elf_Internal_Rela
*dst
)
342 r_type
= ELF32_R_TYPE (dst
->r_info
);
343 cache_ptr
->howto
= elf_x86_64_rtype_to_howto (abfd
, r_type
);
344 if (cache_ptr
->howto
== NULL
)
346 BFD_ASSERT (r_type
== cache_ptr
->howto
->type
|| cache_ptr
->howto
->type
== R_X86_64_NONE
);
350 /* Support for core dump NOTE sections. */
352 elf_x86_64_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
357 switch (note
->descsz
)
362 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
364 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
367 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
375 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
377 elf_tdata (abfd
)->core
->signal
378 = bfd_get_16 (abfd
, note
->descdata
+ 12);
381 elf_tdata (abfd
)->core
->lwpid
382 = bfd_get_32 (abfd
, note
->descdata
+ 32);
391 /* Make a ".reg/999" section. */
392 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
393 size
, note
->descpos
+ offset
);
397 elf_x86_64_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
399 switch (note
->descsz
)
404 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
405 elf_tdata (abfd
)->core
->pid
406 = bfd_get_32 (abfd
, note
->descdata
+ 12);
407 elf_tdata (abfd
)->core
->program
408 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
409 elf_tdata (abfd
)->core
->command
410 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
413 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
414 elf_tdata (abfd
)->core
->pid
415 = bfd_get_32 (abfd
, note
->descdata
+ 24);
416 elf_tdata (abfd
)->core
->program
417 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
418 elf_tdata (abfd
)->core
->command
419 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
422 /* Note that for some reason, a spurious space is tacked
423 onto the end of the args in some (at least one anyway)
424 implementations, so strip it off if it exists. */
427 char *command
= elf_tdata (abfd
)->core
->command
;
428 int n
= strlen (command
);
430 if (0 < n
&& command
[n
- 1] == ' ')
431 command
[n
- 1] = '\0';
438 # if GCC_VERSION >= 8000
439 # pragma GCC diagnostic push
440 # pragma GCC diagnostic ignored "-Wstringop-truncation"
443 elf_x86_64_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
,
446 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
448 const char *fname
, *psargs
;
459 va_start (ap
, note_type
);
460 fname
= va_arg (ap
, const char *);
461 psargs
= va_arg (ap
, const char *);
464 if (bed
->s
->elfclass
== ELFCLASS32
)
467 memset (&data
, 0, sizeof (data
));
468 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
469 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
470 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
471 &data
, sizeof (data
));
476 memset (&data
, 0, sizeof (data
));
477 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
478 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
479 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
480 &data
, sizeof (data
));
485 va_start (ap
, note_type
);
486 pid
= va_arg (ap
, long);
487 cursig
= va_arg (ap
, int);
488 gregs
= va_arg (ap
, const void *);
491 if (bed
->s
->elfclass
== ELFCLASS32
)
493 if (bed
->elf_machine_code
== EM_X86_64
)
495 prstatusx32_t prstat
;
496 memset (&prstat
, 0, sizeof (prstat
));
498 prstat
.pr_cursig
= cursig
;
499 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
500 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
501 &prstat
, sizeof (prstat
));
506 memset (&prstat
, 0, sizeof (prstat
));
508 prstat
.pr_cursig
= cursig
;
509 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
510 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
511 &prstat
, sizeof (prstat
));
517 memset (&prstat
, 0, sizeof (prstat
));
519 prstat
.pr_cursig
= cursig
;
520 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
521 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
522 &prstat
, sizeof (prstat
));
527 # if GCC_VERSION >= 8000
528 # pragma GCC diagnostic pop
532 /* Functions for the x86-64 ELF linker. */
534 /* The size in bytes of an entry in the global offset table. */
536 #define GOT_ENTRY_SIZE 8
538 /* The size in bytes of an entry in the lazy procedure linkage table. */
540 #define LAZY_PLT_ENTRY_SIZE 16
542 /* The size in bytes of an entry in the non-lazy procedure linkage
545 #define NON_LAZY_PLT_ENTRY_SIZE 8
547 /* The first entry in a lazy procedure linkage table looks like this.
548 See the SVR4 ABI i386 supplement and the x86-64 ABI to see how this
551 static const bfd_byte elf_x86_64_lazy_plt0_entry
[LAZY_PLT_ENTRY_SIZE
] =
553 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
554 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
555 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
558 /* Subsequent entries in a lazy procedure linkage table look like this. */
560 static const bfd_byte elf_x86_64_lazy_plt_entry
[LAZY_PLT_ENTRY_SIZE
] =
562 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
563 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
564 0x68, /* pushq immediate */
565 0, 0, 0, 0, /* replaced with index into relocation table. */
566 0xe9, /* jmp relative */
567 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
570 /* The first entry in a lazy procedure linkage table with BND prefix
573 static const bfd_byte elf_x86_64_lazy_bnd_plt0_entry
[LAZY_PLT_ENTRY_SIZE
] =
575 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
576 0xf2, 0xff, 0x25, 16, 0, 0, 0, /* bnd jmpq *GOT+16(%rip) */
577 0x0f, 0x1f, 0 /* nopl (%rax) */
580 /* Subsequent entries for branches with BND prefx in a lazy procedure
581 linkage table look like this. */
583 static const bfd_byte elf_x86_64_lazy_bnd_plt_entry
[LAZY_PLT_ENTRY_SIZE
] =
585 0x68, 0, 0, 0, 0, /* pushq immediate */
586 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
587 0x0f, 0x1f, 0x44, 0, 0 /* nopl 0(%rax,%rax,1) */
590 /* The first entry in the IBT-enabled lazy procedure linkage table is the
591 the same as the lazy PLT with BND prefix so that bound registers are
592 preserved when control is passed to dynamic linker. Subsequent
593 entries for a IBT-enabled lazy procedure linkage table look like
596 static const bfd_byte elf_x86_64_lazy_ibt_plt_entry
[LAZY_PLT_ENTRY_SIZE
] =
598 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */
599 0x68, 0, 0, 0, 0, /* pushq immediate */
600 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
604 /* The first entry in the x32 IBT-enabled lazy procedure linkage table
605 is the same as the normal lazy PLT. Subsequent entries for an
606 x32 IBT-enabled lazy procedure linkage table look like this. */
608 static const bfd_byte elf_x32_lazy_ibt_plt_entry
[LAZY_PLT_ENTRY_SIZE
] =
610 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */
611 0x68, 0, 0, 0, 0, /* pushq immediate */
612 0xe9, 0, 0, 0, 0, /* jmpq relative */
613 0x66, 0x90 /* xchg %ax,%ax */
616 /* Entries in the non-lazey procedure linkage table look like this. */
618 static const bfd_byte elf_x86_64_non_lazy_plt_entry
[NON_LAZY_PLT_ENTRY_SIZE
] =
620 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
621 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
622 0x66, 0x90 /* xchg %ax,%ax */
625 /* Entries for branches with BND prefix in the non-lazey procedure
626 linkage table look like this. */
628 static const bfd_byte elf_x86_64_non_lazy_bnd_plt_entry
[NON_LAZY_PLT_ENTRY_SIZE
] =
630 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
631 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
635 /* Entries for branches with IBT-enabled in the non-lazey procedure
636 linkage table look like this. They have the same size as the lazy
639 static const bfd_byte elf_x86_64_non_lazy_ibt_plt_entry
[LAZY_PLT_ENTRY_SIZE
] =
641 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */
642 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
643 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
644 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nopl 0x0(%rax,%rax,1) */
647 /* Entries for branches with IBT-enabled in the x32 non-lazey procedure
648 linkage table look like this. They have the same size as the lazy
651 static const bfd_byte elf_x32_non_lazy_ibt_plt_entry
[LAZY_PLT_ENTRY_SIZE
] =
653 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */
654 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
655 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
656 0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nopw 0x0(%rax,%rax,1) */
659 /* The TLSDESC entry in a lazy procedure linkage table. */
660 static const bfd_byte elf_x86_64_tlsdesc_plt_entry
[LAZY_PLT_ENTRY_SIZE
] =
662 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */
663 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
664 0xff, 0x25, 16, 0, 0, 0 /* jmpq *GOT+TDG(%rip) */
667 /* .eh_frame covering the lazy .plt section. */
669 static const bfd_byte elf_x86_64_eh_frame_lazy_plt
[] =
671 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
672 0, 0, 0, 0, /* CIE ID */
674 'z', 'R', 0, /* Augmentation string */
675 1, /* Code alignment factor */
676 0x78, /* Data alignment factor */
677 16, /* Return address column */
678 1, /* Augmentation size */
679 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
680 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
681 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
682 DW_CFA_nop
, DW_CFA_nop
,
684 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
685 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
686 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
687 0, 0, 0, 0, /* .plt size goes here */
688 0, /* Augmentation size */
689 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
690 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
691 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
692 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
693 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
694 11, /* Block length */
695 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
696 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
697 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
698 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
699 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
702 /* .eh_frame covering the lazy BND .plt section. */
704 static const bfd_byte elf_x86_64_eh_frame_lazy_bnd_plt
[] =
706 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
707 0, 0, 0, 0, /* CIE ID */
709 'z', 'R', 0, /* Augmentation string */
710 1, /* Code alignment factor */
711 0x78, /* Data alignment factor */
712 16, /* Return address column */
713 1, /* Augmentation size */
714 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
715 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
716 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
717 DW_CFA_nop
, DW_CFA_nop
,
719 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
720 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
721 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
722 0, 0, 0, 0, /* .plt size goes here */
723 0, /* Augmentation size */
724 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
725 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
726 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
727 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
728 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
729 11, /* Block length */
730 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
731 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
732 DW_OP_lit15
, DW_OP_and
, DW_OP_lit5
, DW_OP_ge
,
733 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
734 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
737 /* .eh_frame covering the lazy .plt section with IBT-enabled. */
739 static const bfd_byte elf_x86_64_eh_frame_lazy_ibt_plt
[] =
741 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
742 0, 0, 0, 0, /* CIE ID */
744 'z', 'R', 0, /* Augmentation string */
745 1, /* Code alignment factor */
746 0x78, /* Data alignment factor */
747 16, /* Return address column */
748 1, /* Augmentation size */
749 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
750 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
751 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
752 DW_CFA_nop
, DW_CFA_nop
,
754 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
755 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
756 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
757 0, 0, 0, 0, /* .plt size goes here */
758 0, /* Augmentation size */
759 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
760 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
761 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
762 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
763 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
764 11, /* Block length */
765 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
766 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
767 DW_OP_lit15
, DW_OP_and
, DW_OP_lit10
, DW_OP_ge
,
768 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
769 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
772 /* .eh_frame covering the x32 lazy .plt section with IBT-enabled. */
774 static const bfd_byte elf_x32_eh_frame_lazy_ibt_plt
[] =
776 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
777 0, 0, 0, 0, /* CIE ID */
779 'z', 'R', 0, /* Augmentation string */
780 1, /* Code alignment factor */
781 0x78, /* Data alignment factor */
782 16, /* Return address column */
783 1, /* Augmentation size */
784 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
785 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
786 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
787 DW_CFA_nop
, DW_CFA_nop
,
789 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
790 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
791 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
792 0, 0, 0, 0, /* .plt size goes here */
793 0, /* Augmentation size */
794 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
795 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
796 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
797 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
798 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
799 11, /* Block length */
800 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
801 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
802 DW_OP_lit15
, DW_OP_and
, DW_OP_lit9
, DW_OP_ge
,
803 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
804 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
807 /* .eh_frame covering the non-lazy .plt section. */
809 static const bfd_byte elf_x86_64_eh_frame_non_lazy_plt
[] =
811 #define PLT_GOT_FDE_LENGTH 20
812 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
813 0, 0, 0, 0, /* CIE ID */
815 'z', 'R', 0, /* Augmentation string */
816 1, /* Code alignment factor */
817 0x78, /* Data alignment factor */
818 16, /* Return address column */
819 1, /* Augmentation size */
820 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
821 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
822 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
823 DW_CFA_nop
, DW_CFA_nop
,
825 PLT_GOT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
826 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
827 0, 0, 0, 0, /* the start of non-lazy .plt goes here */
828 0, 0, 0, 0, /* non-lazy .plt size goes here */
829 0, /* Augmentation size */
830 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
,
831 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
834 /* These are the standard parameters. */
835 static const struct elf_x86_lazy_plt_layout elf_x86_64_lazy_plt
=
837 elf_x86_64_lazy_plt0_entry
, /* plt0_entry */
838 LAZY_PLT_ENTRY_SIZE
, /* plt0_entry_size */
839 elf_x86_64_lazy_plt_entry
, /* plt_entry */
840 LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
841 elf_x86_64_tlsdesc_plt_entry
, /* plt_tlsdesc_entry */
842 LAZY_PLT_ENTRY_SIZE
, /* plt_tlsdesc_entry_size */
843 6, /* plt_tlsdesc_got1_offset */
844 12, /* plt_tlsdesc_got2_offset */
845 10, /* plt_tlsdesc_got1_insn_end */
846 16, /* plt_tlsdesc_got2_insn_end */
847 2, /* plt0_got1_offset */
848 8, /* plt0_got2_offset */
849 12, /* plt0_got2_insn_end */
850 2, /* plt_got_offset */
851 7, /* plt_reloc_offset */
852 12, /* plt_plt_offset */
853 6, /* plt_got_insn_size */
854 LAZY_PLT_ENTRY_SIZE
, /* plt_plt_insn_end */
855 6, /* plt_lazy_offset */
856 elf_x86_64_lazy_plt0_entry
, /* pic_plt0_entry */
857 elf_x86_64_lazy_plt_entry
, /* pic_plt_entry */
858 elf_x86_64_eh_frame_lazy_plt
, /* eh_frame_plt */
859 sizeof (elf_x86_64_eh_frame_lazy_plt
) /* eh_frame_plt_size */
862 static const struct elf_x86_non_lazy_plt_layout elf_x86_64_non_lazy_plt
=
864 elf_x86_64_non_lazy_plt_entry
, /* plt_entry */
865 elf_x86_64_non_lazy_plt_entry
, /* pic_plt_entry */
866 NON_LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
867 2, /* plt_got_offset */
868 6, /* plt_got_insn_size */
869 elf_x86_64_eh_frame_non_lazy_plt
, /* eh_frame_plt */
870 sizeof (elf_x86_64_eh_frame_non_lazy_plt
) /* eh_frame_plt_size */
873 static const struct elf_x86_lazy_plt_layout elf_x86_64_lazy_bnd_plt
=
875 elf_x86_64_lazy_bnd_plt0_entry
, /* plt0_entry */
876 LAZY_PLT_ENTRY_SIZE
, /* plt0_entry_size */
877 elf_x86_64_lazy_bnd_plt_entry
, /* plt_entry */
878 LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
879 elf_x86_64_tlsdesc_plt_entry
, /* plt_tlsdesc_entry */
880 LAZY_PLT_ENTRY_SIZE
, /* plt_tlsdesc_entry_size */
881 6, /* plt_tlsdesc_got1_offset */
882 12, /* plt_tlsdesc_got2_offset */
883 10, /* plt_tlsdesc_got1_insn_end */
884 16, /* plt_tlsdesc_got2_insn_end */
885 2, /* plt0_got1_offset */
886 1+8, /* plt0_got2_offset */
887 1+12, /* plt0_got2_insn_end */
888 1+2, /* plt_got_offset */
889 1, /* plt_reloc_offset */
890 7, /* plt_plt_offset */
891 1+6, /* plt_got_insn_size */
892 11, /* plt_plt_insn_end */
893 0, /* plt_lazy_offset */
894 elf_x86_64_lazy_bnd_plt0_entry
, /* pic_plt0_entry */
895 elf_x86_64_lazy_bnd_plt_entry
, /* pic_plt_entry */
896 elf_x86_64_eh_frame_lazy_bnd_plt
, /* eh_frame_plt */
897 sizeof (elf_x86_64_eh_frame_lazy_bnd_plt
) /* eh_frame_plt_size */
900 static const struct elf_x86_non_lazy_plt_layout elf_x86_64_non_lazy_bnd_plt
=
902 elf_x86_64_non_lazy_bnd_plt_entry
, /* plt_entry */
903 elf_x86_64_non_lazy_bnd_plt_entry
, /* pic_plt_entry */
904 NON_LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
905 1+2, /* plt_got_offset */
906 1+6, /* plt_got_insn_size */
907 elf_x86_64_eh_frame_non_lazy_plt
, /* eh_frame_plt */
908 sizeof (elf_x86_64_eh_frame_non_lazy_plt
) /* eh_frame_plt_size */
911 static const struct elf_x86_lazy_plt_layout elf_x86_64_lazy_ibt_plt
=
913 elf_x86_64_lazy_bnd_plt0_entry
, /* plt0_entry */
914 LAZY_PLT_ENTRY_SIZE
, /* plt0_entry_size */
915 elf_x86_64_lazy_ibt_plt_entry
, /* plt_entry */
916 LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
917 elf_x86_64_tlsdesc_plt_entry
, /* plt_tlsdesc_entry */
918 LAZY_PLT_ENTRY_SIZE
, /* plt_tlsdesc_entry_size */
919 6, /* plt_tlsdesc_got1_offset */
920 12, /* plt_tlsdesc_got2_offset */
921 10, /* plt_tlsdesc_got1_insn_end */
922 16, /* plt_tlsdesc_got2_insn_end */
923 2, /* plt0_got1_offset */
924 1+8, /* plt0_got2_offset */
925 1+12, /* plt0_got2_insn_end */
926 4+1+2, /* plt_got_offset */
927 4+1, /* plt_reloc_offset */
928 4+1+6, /* plt_plt_offset */
929 4+1+6, /* plt_got_insn_size */
930 4+1+5+5, /* plt_plt_insn_end */
931 0, /* plt_lazy_offset */
932 elf_x86_64_lazy_bnd_plt0_entry
, /* pic_plt0_entry */
933 elf_x86_64_lazy_ibt_plt_entry
, /* pic_plt_entry */
934 elf_x86_64_eh_frame_lazy_ibt_plt
, /* eh_frame_plt */
935 sizeof (elf_x86_64_eh_frame_lazy_ibt_plt
) /* eh_frame_plt_size */
938 static const struct elf_x86_lazy_plt_layout elf_x32_lazy_ibt_plt
=
940 elf_x86_64_lazy_plt0_entry
, /* plt0_entry */
941 LAZY_PLT_ENTRY_SIZE
, /* plt0_entry_size */
942 elf_x32_lazy_ibt_plt_entry
, /* plt_entry */
943 LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
944 elf_x86_64_tlsdesc_plt_entry
, /* plt_tlsdesc_entry */
945 LAZY_PLT_ENTRY_SIZE
, /* plt_tlsdesc_entry_size */
946 6, /* plt_tlsdesc_got1_offset */
947 12, /* plt_tlsdesc_got2_offset */
948 10, /* plt_tlsdesc_got1_insn_end */
949 16, /* plt_tlsdesc_got2_insn_end */
950 2, /* plt0_got1_offset */
951 8, /* plt0_got2_offset */
952 12, /* plt0_got2_insn_end */
953 4+2, /* plt_got_offset */
954 4+1, /* plt_reloc_offset */
955 4+6, /* plt_plt_offset */
956 4+6, /* plt_got_insn_size */
957 4+5+5, /* plt_plt_insn_end */
958 0, /* plt_lazy_offset */
959 elf_x86_64_lazy_plt0_entry
, /* pic_plt0_entry */
960 elf_x32_lazy_ibt_plt_entry
, /* pic_plt_entry */
961 elf_x32_eh_frame_lazy_ibt_plt
, /* eh_frame_plt */
962 sizeof (elf_x32_eh_frame_lazy_ibt_plt
) /* eh_frame_plt_size */
965 static const struct elf_x86_non_lazy_plt_layout elf_x86_64_non_lazy_ibt_plt
=
967 elf_x86_64_non_lazy_ibt_plt_entry
, /* plt_entry */
968 elf_x86_64_non_lazy_ibt_plt_entry
, /* pic_plt_entry */
969 LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
970 4+1+2, /* plt_got_offset */
971 4+1+6, /* plt_got_insn_size */
972 elf_x86_64_eh_frame_non_lazy_plt
, /* eh_frame_plt */
973 sizeof (elf_x86_64_eh_frame_non_lazy_plt
) /* eh_frame_plt_size */
976 static const struct elf_x86_non_lazy_plt_layout elf_x32_non_lazy_ibt_plt
=
978 elf_x32_non_lazy_ibt_plt_entry
, /* plt_entry */
979 elf_x32_non_lazy_ibt_plt_entry
, /* pic_plt_entry */
980 LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
981 4+2, /* plt_got_offset */
982 4+6, /* plt_got_insn_size */
983 elf_x86_64_eh_frame_non_lazy_plt
, /* eh_frame_plt */
984 sizeof (elf_x86_64_eh_frame_non_lazy_plt
) /* eh_frame_plt_size */
989 elf64_x86_64_elf_object_p (bfd
*abfd
)
991 /* Set the right machine number for an x86-64 elf64 file. */
992 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
997 elf32_x86_64_elf_object_p (bfd
*abfd
)
999 /* Set the right machine number for an x86-64 elf32 file. */
1000 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
1004 /* Return TRUE if the TLS access code sequence support transition
1008 elf_x86_64_check_tls_transition (bfd
*abfd
,
1009 struct bfd_link_info
*info
,
1012 Elf_Internal_Shdr
*symtab_hdr
,
1013 struct elf_link_hash_entry
**sym_hashes
,
1014 unsigned int r_type
,
1015 const Elf_Internal_Rela
*rel
,
1016 const Elf_Internal_Rela
*relend
)
1019 unsigned long r_symndx
;
1020 bfd_boolean largepic
= FALSE
;
1021 struct elf_link_hash_entry
*h
;
1023 struct elf_x86_link_hash_table
*htab
;
1025 bfd_boolean indirect_call
;
1027 htab
= elf_x86_hash_table (info
, X86_64_ELF_DATA
);
1028 offset
= rel
->r_offset
;
1031 case R_X86_64_TLSGD
:
1032 case R_X86_64_TLSLD
:
1033 if ((rel
+ 1) >= relend
)
1036 if (r_type
== R_X86_64_TLSGD
)
1038 /* Check transition from GD access model. For 64bit, only
1039 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1040 .word 0x6666; rex64; call __tls_get_addr@PLT
1042 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1044 call *__tls_get_addr@GOTPCREL(%rip)
1045 which may be converted to
1046 addr32 call __tls_get_addr
1047 can transit to different access model. For 32bit, only
1048 leaq foo@tlsgd(%rip), %rdi
1049 .word 0x6666; rex64; call __tls_get_addr@PLT
1051 leaq foo@tlsgd(%rip), %rdi
1053 call *__tls_get_addr@GOTPCREL(%rip)
1054 which may be converted to
1055 addr32 call __tls_get_addr
1056 can transit to different access model. For largepic,
1058 leaq foo@tlsgd(%rip), %rdi
1059 movabsq $__tls_get_addr@pltoff, %rax
1063 leaq foo@tlsgd(%rip), %rdi
1064 movabsq $__tls_get_addr@pltoff, %rax
1068 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1070 if ((offset
+ 12) > sec
->size
)
1073 call
= contents
+ offset
+ 4;
1075 || !((call
[1] == 0x48
1083 && call
[3] == 0xe8)))
1085 if (!ABI_64_P (abfd
)
1086 || (offset
+ 19) > sec
->size
1088 || memcmp (call
- 7, leaq
+ 1, 3) != 0
1089 || memcmp (call
, "\x48\xb8", 2) != 0
1093 || !((call
[10] == 0x48 && call
[12] == 0xd8)
1094 || (call
[10] == 0x4c && call
[12] == 0xf8)))
1098 else if (ABI_64_P (abfd
))
1101 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1107 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1110 indirect_call
= call
[2] == 0xff;
1114 /* Check transition from LD access model. Only
1115 leaq foo@tlsld(%rip), %rdi;
1116 call __tls_get_addr@PLT
1118 leaq foo@tlsld(%rip), %rdi;
1119 call *__tls_get_addr@GOTPCREL(%rip)
1120 which may be converted to
1121 addr32 call __tls_get_addr
1122 can transit to different access model. For largepic
1124 leaq foo@tlsld(%rip), %rdi
1125 movabsq $__tls_get_addr@pltoff, %rax
1129 leaq foo@tlsld(%rip), %rdi
1130 movabsq $__tls_get_addr@pltoff, %rax
1134 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1136 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1139 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0)
1142 call
= contents
+ offset
+ 4;
1143 if (!(call
[0] == 0xe8
1144 || (call
[0] == 0xff && call
[1] == 0x15)
1145 || (call
[0] == 0x67 && call
[1] == 0xe8)))
1147 if (!ABI_64_P (abfd
)
1148 || (offset
+ 19) > sec
->size
1149 || memcmp (call
, "\x48\xb8", 2) != 0
1153 || !((call
[10] == 0x48 && call
[12] == 0xd8)
1154 || (call
[10] == 0x4c && call
[12] == 0xf8)))
1158 indirect_call
= call
[0] == 0xff;
1161 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1162 if (r_symndx
< symtab_hdr
->sh_info
)
1165 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1167 || !((struct elf_x86_link_hash_entry
*) h
)->tls_get_addr
)
1171 r_type
= (ELF32_R_TYPE (rel
[1].r_info
)
1172 & ~R_X86_64_converted_reloc_bit
);
1174 return r_type
== R_X86_64_PLTOFF64
;
1175 else if (indirect_call
)
1176 return r_type
== R_X86_64_GOTPCRELX
;
1178 return (r_type
== R_X86_64_PC32
|| r_type
== R_X86_64_PLT32
);
1181 case R_X86_64_GOTTPOFF
:
1182 /* Check transition from IE access model:
1183 mov foo@gottpoff(%rip), %reg
1184 add foo@gottpoff(%rip), %reg
1187 /* Check REX prefix first. */
1188 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1190 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1191 if (val
!= 0x48 && val
!= 0x4c)
1193 /* X32 may have 0x44 REX prefix or no REX prefix. */
1194 if (ABI_64_P (abfd
))
1200 /* X32 may not have any REX prefix. */
1201 if (ABI_64_P (abfd
))
1203 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1207 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1208 if (val
!= 0x8b && val
!= 0x03)
1211 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1212 return (val
& 0xc7) == 5;
1214 case R_X86_64_GOTPC32_TLSDESC
:
1215 /* Check transition from GDesc access model:
1216 leaq x@tlsdesc(%rip), %rax <--- LP64 mode.
1217 rex leal x@tlsdesc(%rip), %eax <--- X32 mode.
1219 Make sure it's a leaq adding rip to a 32-bit offset
1220 into any register, although it's probably almost always
1223 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1226 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1228 if (val
!= 0x48 && (ABI_64_P (abfd
) || val
!= 0x40))
1231 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1234 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1235 return (val
& 0xc7) == 0x05;
1237 case R_X86_64_TLSDESC_CALL
:
1238 /* Check transition from GDesc access model:
1239 call *x@tlsdesc(%rax) <--- LP64 mode.
1240 call *x@tlsdesc(%eax) <--- X32 mode.
1242 if (offset
+ 2 <= sec
->size
)
1244 unsigned int prefix
;
1245 call
= contents
+ offset
;
1247 if (!ABI_64_P (abfd
))
1249 /* Check for call *x@tlsdesc(%eax). */
1250 if (call
[0] == 0x67)
1253 if (offset
+ 3 > sec
->size
)
1257 /* Make sure that it's a call *x@tlsdesc(%rax). */
1258 return call
[prefix
] == 0xff && call
[1 + prefix
] == 0x10;
1268 /* Return TRUE if the TLS access transition is OK or no transition
1269 will be performed. Update R_TYPE if there is a transition. */
1272 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1273 asection
*sec
, bfd_byte
*contents
,
1274 Elf_Internal_Shdr
*symtab_hdr
,
1275 struct elf_link_hash_entry
**sym_hashes
,
1276 unsigned int *r_type
, int tls_type
,
1277 const Elf_Internal_Rela
*rel
,
1278 const Elf_Internal_Rela
*relend
,
1279 struct elf_link_hash_entry
*h
,
1280 unsigned long r_symndx
,
1281 bfd_boolean from_relocate_section
)
1283 unsigned int from_type
= *r_type
;
1284 unsigned int to_type
= from_type
;
1285 bfd_boolean check
= TRUE
;
1287 /* Skip TLS transition for functions. */
1289 && (h
->type
== STT_FUNC
1290 || h
->type
== STT_GNU_IFUNC
))
1295 case R_X86_64_TLSGD
:
1296 case R_X86_64_GOTPC32_TLSDESC
:
1297 case R_X86_64_TLSDESC_CALL
:
1298 case R_X86_64_GOTTPOFF
:
1299 if (bfd_link_executable (info
))
1302 to_type
= R_X86_64_TPOFF32
;
1304 to_type
= R_X86_64_GOTTPOFF
;
1307 /* When we are called from elf_x86_64_relocate_section, there may
1308 be additional transitions based on TLS_TYPE. */
1309 if (from_relocate_section
)
1311 unsigned int new_to_type
= to_type
;
1313 if (TLS_TRANSITION_IE_TO_LE_P (info
, h
, tls_type
))
1314 new_to_type
= R_X86_64_TPOFF32
;
1316 if (to_type
== R_X86_64_TLSGD
1317 || to_type
== R_X86_64_GOTPC32_TLSDESC
1318 || to_type
== R_X86_64_TLSDESC_CALL
)
1320 if (tls_type
== GOT_TLS_IE
)
1321 new_to_type
= R_X86_64_GOTTPOFF
;
1324 /* We checked the transition before when we were called from
1325 elf_x86_64_check_relocs. We only want to check the new
1326 transition which hasn't been checked before. */
1327 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1328 to_type
= new_to_type
;
1333 case R_X86_64_TLSLD
:
1334 if (bfd_link_executable (info
))
1335 to_type
= R_X86_64_TPOFF32
;
1342 /* Return TRUE if there is no transition. */
1343 if (from_type
== to_type
)
1346 /* Check if the transition can be performed. */
1348 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1349 symtab_hdr
, sym_hashes
,
1350 from_type
, rel
, relend
))
1352 reloc_howto_type
*from
, *to
;
1355 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1356 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1358 if (from
== NULL
|| to
== NULL
)
1362 name
= h
->root
.root
.string
;
1365 struct elf_x86_link_hash_table
*htab
;
1367 htab
= elf_x86_hash_table (info
, X86_64_ELF_DATA
);
1372 Elf_Internal_Sym
*isym
;
1374 isym
= bfd_sym_from_r_symndx (&htab
->elf
.sym_cache
,
1376 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1381 /* xgettext:c-format */
1382 (_("%pB: TLS transition from %s to %s against `%s' at %#" PRIx64
1383 " in section `%pA' failed"),
1384 abfd
, from
->name
, to
->name
, name
, (uint64_t) rel
->r_offset
, sec
);
1385 bfd_set_error (bfd_error_bad_value
);
1393 /* Rename some of the generic section flags to better document how they
1395 #define check_relocs_failed sec_flg0
1398 elf_x86_64_need_pic (struct bfd_link_info
*info
,
1399 bfd
*input_bfd
, asection
*sec
,
1400 struct elf_link_hash_entry
*h
,
1401 Elf_Internal_Shdr
*symtab_hdr
,
1402 Elf_Internal_Sym
*isym
,
1403 reloc_howto_type
*howto
)
1406 const char *und
= "";
1407 const char *pic
= "";
1413 name
= h
->root
.root
.string
;
1414 switch (ELF_ST_VISIBILITY (h
->other
))
1417 v
= _("hidden symbol ");
1420 v
= _("internal symbol ");
1423 v
= _("protected symbol ");
1426 if (((struct elf_x86_link_hash_entry
*) h
)->def_protected
)
1427 v
= _("protected symbol ");
1434 if (!SYMBOL_DEFINED_NON_SHARED_P (h
) && !h
->def_dynamic
)
1435 und
= _("undefined ");
1439 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, isym
, NULL
);
1443 if (bfd_link_dll (info
))
1445 object
= _("a shared object");
1447 pic
= _("; recompile with -fPIC");
1451 if (bfd_link_pie (info
))
1452 object
= _("a PIE object");
1454 object
= _("a PDE object");
1456 pic
= _("; recompile with -fPIE");
1459 /* xgettext:c-format */
1460 _bfd_error_handler (_("%pB: relocation %s against %s%s`%s' can "
1461 "not be used when making %s%s"),
1462 input_bfd
, howto
->name
, und
, v
, name
,
1464 bfd_set_error (bfd_error_bad_value
);
1465 sec
->check_relocs_failed
= 1;
1469 /* With the local symbol, foo, we convert
1470 mov foo@GOTPCREL(%rip), %reg
1474 call/jmp *foo@GOTPCREL(%rip)
1476 nop call foo/jmp foo nop
1477 When PIC is false, convert
1478 test %reg, foo@GOTPCREL(%rip)
1482 binop foo@GOTPCREL(%rip), %reg
1485 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1489 elf_x86_64_convert_load_reloc (bfd
*abfd
,
1491 unsigned int *r_type_p
,
1492 Elf_Internal_Rela
*irel
,
1493 struct elf_link_hash_entry
*h
,
1494 bfd_boolean
*converted
,
1495 struct bfd_link_info
*link_info
)
1497 struct elf_x86_link_hash_table
*htab
;
1499 bfd_boolean no_overflow
;
1501 bfd_boolean to_reloc_pc32
;
1502 bfd_boolean abs_symbol
;
1503 bfd_boolean local_ref
;
1505 bfd_signed_vma raddend
;
1506 unsigned int opcode
;
1508 unsigned int r_type
= *r_type_p
;
1509 unsigned int r_symndx
;
1510 bfd_vma roff
= irel
->r_offset
;
1511 bfd_vma abs_relocation
;
1513 if (roff
< (r_type
== R_X86_64_REX_GOTPCRELX
? 3 : 2))
1516 raddend
= irel
->r_addend
;
1517 /* Addend for 32-bit PC-relative relocation must be -4. */
1521 htab
= elf_x86_hash_table (link_info
, X86_64_ELF_DATA
);
1522 is_pic
= bfd_link_pic (link_info
);
1524 relocx
= (r_type
== R_X86_64_GOTPCRELX
1525 || r_type
== R_X86_64_REX_GOTPCRELX
);
1527 /* TRUE if --no-relax is used. */
1528 no_overflow
= link_info
->disable_target_specific_optimizations
> 1;
1530 r_symndx
= htab
->r_sym (irel
->r_info
);
1532 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
1534 /* Convert mov to lea since it has been done for a while. */
1537 /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
1538 for call, jmp or one of adc, add, and, cmp, or, sbb, sub,
1539 test, xor instructions. */
1544 /* We convert only to R_X86_64_PC32:
1546 2. R_X86_64_GOTPCREL since we can't modify REX byte.
1547 3. no_overflow is true.
1550 to_reloc_pc32
= (opcode
== 0xff
1558 /* Get the symbol referred to by the reloc. */
1561 Elf_Internal_Sym
*isym
1562 = bfd_sym_from_r_symndx (&htab
->elf
.sym_cache
, abfd
, r_symndx
);
1564 /* Skip relocation against undefined symbols. */
1565 if (isym
->st_shndx
== SHN_UNDEF
)
1569 if (isym
->st_shndx
== SHN_ABS
)
1571 tsec
= bfd_abs_section_ptr
;
1573 abs_relocation
= isym
->st_value
;
1575 else if (isym
->st_shndx
== SHN_COMMON
)
1576 tsec
= bfd_com_section_ptr
;
1577 else if (isym
->st_shndx
== SHN_X86_64_LCOMMON
)
1578 tsec
= &_bfd_elf_large_com_section
;
1580 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1584 /* Undefined weak symbol is only bound locally in executable
1585 and its reference is resolved as 0 without relocation
1586 overflow. We can only perform this optimization for
1587 GOTPCRELX relocations since we need to modify REX byte.
1588 It is OK convert mov with R_X86_64_GOTPCREL to
1590 struct elf_x86_link_hash_entry
*eh
= elf_x86_hash_entry (h
);
1592 abs_symbol
= ABS_SYMBOL_P (h
);
1593 abs_relocation
= h
->root
.u
.def
.value
;
1595 /* NB: Also set linker_def via SYMBOL_REFERENCES_LOCAL_P. */
1596 local_ref
= SYMBOL_REFERENCES_LOCAL_P (link_info
, h
);
1597 if ((relocx
|| opcode
== 0x8b)
1598 && (h
->root
.type
== bfd_link_hash_undefweak
1604 /* Skip for branch instructions since R_X86_64_PC32
1611 /* For non-branch instructions, we can convert to
1612 R_X86_64_32/R_X86_64_32S since we know if there
1614 to_reloc_pc32
= FALSE
;
1617 /* Since we don't know the current PC when PIC is true,
1618 we can't convert to R_X86_64_PC32. */
1619 if (to_reloc_pc32
&& is_pic
)
1624 /* Avoid optimizing GOTPCREL relocations againt _DYNAMIC since
1625 ld.so may use its link-time address. */
1626 else if (h
->start_stop
1629 || h
->root
.type
== bfd_link_hash_defined
1630 || h
->root
.type
== bfd_link_hash_defweak
)
1631 && h
!= htab
->elf
.hdynamic
1634 /* bfd_link_hash_new or bfd_link_hash_undefined is
1635 set by an assignment in a linker script in
1636 bfd_elf_record_link_assignment. start_stop is set
1637 on __start_SECNAME/__stop_SECNAME which mark section
1642 && (h
->root
.type
== bfd_link_hash_new
1643 || h
->root
.type
== bfd_link_hash_undefined
1644 || ((h
->root
.type
== bfd_link_hash_defined
1645 || h
->root
.type
== bfd_link_hash_defweak
)
1646 && h
->root
.u
.def
.section
== bfd_und_section_ptr
))))
1648 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */
1653 tsec
= h
->root
.u
.def
.section
;
1659 /* Don't convert GOTPCREL relocation against large section. */
1660 if (elf_section_data (tsec
) != NULL
1661 && (elf_section_flags (tsec
) & SHF_X86_64_LARGE
) != 0)
1664 /* Skip since R_X86_64_PC32/R_X86_64_32/R_X86_64_32S may overflow. */
1671 /* We have "call/jmp *foo@GOTPCREL(%rip)". */
1676 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
1678 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
1681 /* Convert to "jmp foo nop". */
1684 nop_offset
= irel
->r_offset
+ 3;
1685 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
1686 irel
->r_offset
-= 1;
1687 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
1691 struct elf_x86_link_hash_entry
*eh
1692 = (struct elf_x86_link_hash_entry
*) h
;
1694 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
1697 /* To support TLS optimization, always use addr32 prefix for
1698 "call *__tls_get_addr@GOTPCREL(%rip)". */
1699 if (eh
&& eh
->tls_get_addr
)
1702 nop_offset
= irel
->r_offset
- 2;
1706 nop
= htab
->params
->call_nop_byte
;
1707 if (htab
->params
->call_nop_as_suffix
)
1709 nop_offset
= irel
->r_offset
+ 3;
1710 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
1711 irel
->r_offset
-= 1;
1712 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
1715 nop_offset
= irel
->r_offset
- 2;
1718 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
1719 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
1720 r_type
= R_X86_64_PC32
;
1725 unsigned int rex_mask
= REX_R
;
1727 if (r_type
== R_X86_64_REX_GOTPCRELX
)
1728 rex
= bfd_get_8 (abfd
, contents
+ roff
- 3);
1734 if (abs_symbol
&& local_ref
&& relocx
)
1735 to_reloc_pc32
= FALSE
;
1739 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
1740 "lea foo(%rip), %reg". */
1742 r_type
= R_X86_64_PC32
;
1746 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
1747 "mov $foo, %reg". */
1749 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
1750 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
1751 if ((rex
& REX_W
) != 0
1752 && ABI_64_P (link_info
->output_bfd
))
1754 /* Keep the REX_W bit in REX byte for LP64. */
1755 r_type
= R_X86_64_32S
;
1756 goto rewrite_modrm_rex
;
1760 /* If the REX_W bit in REX byte isn't needed,
1761 use R_X86_64_32 and clear the W bit to avoid
1762 sign-extend imm32 to imm64. */
1763 r_type
= R_X86_64_32
;
1764 /* Clear the W bit in REX byte. */
1766 goto rewrite_modrm_rex
;
1772 /* R_X86_64_PC32 isn't supported. */
1776 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
1779 /* Convert "test %reg, foo@GOTPCREL(%rip)" to
1780 "test $foo, %reg". */
1781 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
1786 /* Convert "binop foo@GOTPCREL(%rip), %reg" to
1787 "binop $foo, %reg". */
1788 modrm
= 0xc0 | (modrm
& 0x38) >> 3 | (opcode
& 0x3c);
1792 /* Use R_X86_64_32 with 32-bit operand to avoid relocation
1793 overflow when sign-extending imm32 to imm64. */
1794 r_type
= (rex
& REX_W
) != 0 ? R_X86_64_32S
: R_X86_64_32
;
1799 /* Check if R_X86_64_32S/R_X86_64_32 fits. */
1800 if (r_type
== R_X86_64_32S
)
1802 if ((abs_relocation
+ 0x80000000) > 0xffffffff)
1807 if (abs_relocation
> 0xffffffff)
1812 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
1816 /* Move the R bit to the B bit in REX byte. */
1817 rex
= (rex
& ~rex_mask
) | (rex
& REX_R
) >> 2;
1818 bfd_put_8 (abfd
, rex
, contents
+ roff
- 3);
1821 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */
1825 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
1829 irel
->r_info
= htab
->r_info (r_symndx
,
1830 r_type
| R_X86_64_converted_reloc_bit
);
1837 /* Look through the relocs for a section during the first phase, and
1838 calculate needed space in the global offset table, procedure
1839 linkage table, and dynamic reloc sections. */
1842 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1844 const Elf_Internal_Rela
*relocs
)
1846 struct elf_x86_link_hash_table
*htab
;
1847 Elf_Internal_Shdr
*symtab_hdr
;
1848 struct elf_link_hash_entry
**sym_hashes
;
1849 const Elf_Internal_Rela
*rel
;
1850 const Elf_Internal_Rela
*rel_end
;
1853 bfd_boolean converted
;
1855 if (bfd_link_relocatable (info
))
1858 htab
= elf_x86_hash_table (info
, X86_64_ELF_DATA
);
1861 sec
->check_relocs_failed
= 1;
1865 BFD_ASSERT (is_x86_elf (abfd
, htab
));
1867 /* Get the section contents. */
1868 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1869 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1870 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1872 sec
->check_relocs_failed
= 1;
1876 symtab_hdr
= &elf_symtab_hdr (abfd
);
1877 sym_hashes
= elf_sym_hashes (abfd
);
1883 rel_end
= relocs
+ sec
->reloc_count
;
1884 for (rel
= relocs
; rel
< rel_end
; rel
++)
1886 unsigned int r_type
;
1887 unsigned int r_symndx
;
1888 struct elf_link_hash_entry
*h
;
1889 struct elf_x86_link_hash_entry
*eh
;
1890 Elf_Internal_Sym
*isym
;
1892 bfd_boolean size_reloc
;
1893 bfd_boolean converted_reloc
;
1894 bfd_boolean no_dynreloc
;
1896 r_symndx
= htab
->r_sym (rel
->r_info
);
1897 r_type
= ELF32_R_TYPE (rel
->r_info
);
1899 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1901 /* xgettext:c-format */
1902 _bfd_error_handler (_("%pB: bad symbol index: %d"),
1907 if (r_symndx
< symtab_hdr
->sh_info
)
1909 /* A local symbol. */
1910 isym
= bfd_sym_from_r_symndx (&htab
->elf
.sym_cache
,
1915 /* Check relocation against local STT_GNU_IFUNC symbol. */
1916 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1918 h
= _bfd_elf_x86_get_local_sym_hash (htab
, abfd
, rel
,
1923 /* Fake a STT_GNU_IFUNC symbol. */
1924 h
->root
.root
.string
= bfd_elf_sym_name (abfd
, symtab_hdr
,
1926 h
->type
= STT_GNU_IFUNC
;
1929 h
->forced_local
= 1;
1930 h
->root
.type
= bfd_link_hash_defined
;
1938 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1939 while (h
->root
.type
== bfd_link_hash_indirect
1940 || h
->root
.type
== bfd_link_hash_warning
)
1941 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1944 /* Check invalid x32 relocations. */
1945 if (!ABI_64_P (abfd
))
1951 case R_X86_64_DTPOFF64
:
1952 case R_X86_64_TPOFF64
:
1954 case R_X86_64_GOTOFF64
:
1955 case R_X86_64_GOT64
:
1956 case R_X86_64_GOTPCREL64
:
1957 case R_X86_64_GOTPC64
:
1958 case R_X86_64_GOTPLT64
:
1959 case R_X86_64_PLTOFF64
:
1962 name
= h
->root
.root
.string
;
1964 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1967 /* xgettext:c-format */
1968 (_("%pB: relocation %s against symbol `%s' isn't "
1969 "supported in x32 mode"), abfd
,
1970 x86_64_elf_howto_table
[r_type
].name
, name
);
1971 bfd_set_error (bfd_error_bad_value
);
1979 /* It is referenced by a non-shared object. */
1983 converted_reloc
= FALSE
;
1984 if ((r_type
== R_X86_64_GOTPCREL
1985 || r_type
== R_X86_64_GOTPCRELX
1986 || r_type
== R_X86_64_REX_GOTPCRELX
)
1987 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
1989 Elf_Internal_Rela
*irel
= (Elf_Internal_Rela
*) rel
;
1990 if (!elf_x86_64_convert_load_reloc (abfd
, contents
, &r_type
,
1991 irel
, h
, &converted_reloc
,
1995 if (converted_reloc
)
1999 if (!_bfd_elf_x86_valid_reloc_p (sec
, info
, htab
, rel
, h
, isym
,
2000 symtab_hdr
, &no_dynreloc
))
2003 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, contents
,
2004 symtab_hdr
, sym_hashes
,
2005 &r_type
, GOT_UNKNOWN
,
2006 rel
, rel_end
, h
, r_symndx
, FALSE
))
2009 /* Check if _GLOBAL_OFFSET_TABLE_ is referenced. */
2010 if (h
== htab
->elf
.hgot
)
2011 htab
->got_referenced
= TRUE
;
2013 eh
= (struct elf_x86_link_hash_entry
*) h
;
2016 case R_X86_64_TLSLD
:
2017 htab
->tls_ld_or_ldm_got
.refcount
= 1;
2020 case R_X86_64_TPOFF32
:
2021 if (!bfd_link_executable (info
) && ABI_64_P (abfd
))
2022 return elf_x86_64_need_pic (info
, abfd
, sec
, h
, symtab_hdr
, isym
,
2023 &x86_64_elf_howto_table
[r_type
]);
2025 eh
->zero_undefweak
&= 0x2;
2028 case R_X86_64_GOTTPOFF
:
2029 if (!bfd_link_executable (info
))
2030 info
->flags
|= DF_STATIC_TLS
;
2033 case R_X86_64_GOT32
:
2034 case R_X86_64_GOTPCREL
:
2035 case R_X86_64_GOTPCRELX
:
2036 case R_X86_64_REX_GOTPCRELX
:
2037 case R_X86_64_TLSGD
:
2038 case R_X86_64_GOT64
:
2039 case R_X86_64_GOTPCREL64
:
2040 case R_X86_64_GOTPLT64
:
2041 case R_X86_64_GOTPC32_TLSDESC
:
2042 case R_X86_64_TLSDESC_CALL
:
2043 /* This symbol requires a global offset table entry. */
2045 int tls_type
, old_tls_type
;
2050 tls_type
= GOT_NORMAL
;
2053 if (ABS_SYMBOL_P (h
))
2056 else if (isym
->st_shndx
== SHN_ABS
)
2059 case R_X86_64_TLSGD
:
2060 tls_type
= GOT_TLS_GD
;
2062 case R_X86_64_GOTTPOFF
:
2063 tls_type
= GOT_TLS_IE
;
2065 case R_X86_64_GOTPC32_TLSDESC
:
2066 case R_X86_64_TLSDESC_CALL
:
2067 tls_type
= GOT_TLS_GDESC
;
2073 h
->got
.refcount
= 1;
2074 old_tls_type
= eh
->tls_type
;
2078 bfd_signed_vma
*local_got_refcounts
;
2080 /* This is a global offset table entry for a local symbol. */
2081 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2082 if (local_got_refcounts
== NULL
)
2086 size
= symtab_hdr
->sh_info
;
2087 size
*= sizeof (bfd_signed_vma
)
2088 + sizeof (bfd_vma
) + sizeof (char);
2089 local_got_refcounts
= ((bfd_signed_vma
*)
2090 bfd_zalloc (abfd
, size
));
2091 if (local_got_refcounts
== NULL
)
2093 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2094 elf_x86_local_tlsdesc_gotent (abfd
)
2095 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
2096 elf_x86_local_got_tls_type (abfd
)
2097 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
2099 local_got_refcounts
[r_symndx
] = 1;
2101 = elf_x86_local_got_tls_type (abfd
) [r_symndx
];
2104 /* If a TLS symbol is accessed using IE at least once,
2105 there is no point to use dynamic model for it. */
2106 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
2107 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
2108 || tls_type
!= GOT_TLS_IE
))
2110 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
2111 tls_type
= old_tls_type
;
2112 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
2113 && GOT_TLS_GD_ANY_P (tls_type
))
2114 tls_type
|= old_tls_type
;
2118 name
= h
->root
.root
.string
;
2120 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
2123 /* xgettext:c-format */
2124 (_("%pB: '%s' accessed both as normal and"
2125 " thread local symbol"),
2127 bfd_set_error (bfd_error_bad_value
);
2132 if (old_tls_type
!= tls_type
)
2135 eh
->tls_type
= tls_type
;
2137 elf_x86_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
2142 case R_X86_64_GOTOFF64
:
2143 case R_X86_64_GOTPC32
:
2144 case R_X86_64_GOTPC64
:
2147 eh
->zero_undefweak
&= 0x2;
2150 case R_X86_64_PLT32
:
2151 case R_X86_64_PLT32_BND
:
2152 /* This symbol requires a procedure linkage table entry. We
2153 actually build the entry in adjust_dynamic_symbol,
2154 because this might be a case of linking PIC code which is
2155 never referenced by a dynamic object, in which case we
2156 don't need to generate a procedure linkage table entry
2159 /* If this is a local symbol, we resolve it directly without
2160 creating a procedure linkage table entry. */
2164 eh
->zero_undefweak
&= 0x2;
2166 h
->plt
.refcount
= 1;
2169 case R_X86_64_PLTOFF64
:
2170 /* This tries to form the 'address' of a function relative
2171 to GOT. For global symbols we need a PLT entry. */
2175 h
->plt
.refcount
= 1;
2179 case R_X86_64_SIZE32
:
2180 case R_X86_64_SIZE64
:
2185 if (!ABI_64_P (abfd
))
2191 /* Check relocation overflow as these relocs may lead to
2192 run-time relocation overflow. Don't error out for
2193 sections we don't care about, such as debug sections or
2194 when relocation overflow check is disabled. */
2195 if (!htab
->params
->no_reloc_overflow_check
2197 && (bfd_link_pic (info
)
2198 || (bfd_link_executable (info
)
2202 && (sec
->flags
& SEC_READONLY
) == 0)))
2203 return elf_x86_64_need_pic (info
, abfd
, sec
, h
, symtab_hdr
, isym
,
2204 &x86_64_elf_howto_table
[r_type
]);
2210 case R_X86_64_PC32_BND
:
2214 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2215 eh
->zero_undefweak
|= 0x2;
2216 /* We are called after all symbols have been resolved. Only
2217 relocation against STT_GNU_IFUNC symbol must go through
2220 && (bfd_link_executable (info
)
2221 || h
->type
== STT_GNU_IFUNC
))
2223 bfd_boolean func_pointer_ref
= FALSE
;
2225 if (r_type
== R_X86_64_PC32
)
2227 /* Since something like ".long foo - ." may be used
2228 as pointer, make sure that PLT is used if foo is
2229 a function defined in a shared library. */
2230 if ((sec
->flags
& SEC_CODE
) == 0)
2232 h
->pointer_equality_needed
= 1;
2233 if (bfd_link_pie (info
)
2234 && h
->type
== STT_FUNC
2239 h
->plt
.refcount
= 1;
2243 else if (r_type
!= R_X86_64_PC32_BND
2244 && r_type
!= R_X86_64_PC64
)
2246 h
->pointer_equality_needed
= 1;
2247 /* At run-time, R_X86_64_64 can be resolved for both
2248 x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2249 can only be resolved for x32. */
2250 if ((sec
->flags
& SEC_READONLY
) == 0
2251 && (r_type
== R_X86_64_64
2252 || (!ABI_64_P (abfd
)
2253 && (r_type
== R_X86_64_32
2254 || r_type
== R_X86_64_32S
))))
2255 func_pointer_ref
= TRUE
;
2258 if (!func_pointer_ref
)
2260 /* If this reloc is in a read-only section, we might
2261 need a copy reloc. We can't check reliably at this
2262 stage whether the section is read-only, as input
2263 sections have not yet been mapped to output sections.
2264 Tentatively set the flag for now, and correct in
2265 adjust_dynamic_symbol. */
2268 /* We may need a .plt entry if the symbol is a function
2269 defined in a shared lib or is a function referenced
2270 from the code or read-only section. */
2272 || (sec
->flags
& (SEC_CODE
| SEC_READONLY
)) != 0)
2273 h
->plt
.refcount
= 1;
2280 && NEED_DYNAMIC_RELOCATION_P (info
, TRUE
, h
, sec
, r_type
,
2281 htab
->pointer_r_type
))
2283 struct elf_dyn_relocs
*p
;
2284 struct elf_dyn_relocs
**head
;
2286 /* We must copy these reloc types into the output file.
2287 Create a reloc section in dynobj and make room for
2291 sreloc
= _bfd_elf_make_dynamic_reloc_section
2292 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
2293 abfd
, /*rela?*/ TRUE
);
2299 /* If this is a global symbol, we count the number of
2300 relocations we need for this symbol. */
2302 head
= &h
->dyn_relocs
;
2305 /* Track dynamic relocs needed for local syms too.
2306 We really need local syms available to do this
2311 isym
= bfd_sym_from_r_symndx (&htab
->elf
.sym_cache
,
2316 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2320 /* Beware of type punned pointers vs strict aliasing
2322 vpp
= &(elf_section_data (s
)->local_dynrel
);
2323 head
= (struct elf_dyn_relocs
**)vpp
;
2327 if (p
== NULL
|| p
->sec
!= sec
)
2329 size_t amt
= sizeof *p
;
2331 p
= ((struct elf_dyn_relocs
*)
2332 bfd_alloc (htab
->elf
.dynobj
, amt
));
2343 /* Count size relocation as PC-relative relocation. */
2344 if (X86_PCREL_TYPE_P (r_type
) || size_reloc
)
2349 /* This relocation describes the C++ object vtable hierarchy.
2350 Reconstruct it for later use during GC. */
2351 case R_X86_64_GNU_VTINHERIT
:
2352 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2356 /* This relocation describes which C++ vtable entries are actually
2357 used. Record for later use during GC. */
2358 case R_X86_64_GNU_VTENTRY
:
2359 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2368 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2370 if (!converted
&& !info
->keep_memory
)
2374 /* Cache the section contents for elf_link_input_bfd if any
2375 load is converted or --no-keep-memory isn't used. */
2376 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2380 /* Cache relocations if any load is converted. */
2381 if (elf_section_data (sec
)->relocs
!= relocs
&& converted
)
2382 elf_section_data (sec
)->relocs
= (Elf_Internal_Rela
*) relocs
;
2387 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2389 sec
->check_relocs_failed
= 1;
2393 /* Return the relocation value for @tpoff relocation
2394 if STT_TLS virtual address is ADDRESS. */
2397 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
2399 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2400 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
2401 bfd_vma static_tls_size
;
2403 /* If tls_segment is NULL, we should have signalled an error already. */
2404 if (htab
->tls_sec
== NULL
)
2407 /* Consider special static TLS alignment requirements. */
2408 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
2409 return address
- static_tls_size
- htab
->tls_sec
->vma
;
2412 /* Relocate an x86_64 ELF section. */
2415 elf_x86_64_relocate_section (bfd
*output_bfd
,
2416 struct bfd_link_info
*info
,
2418 asection
*input_section
,
2420 Elf_Internal_Rela
*relocs
,
2421 Elf_Internal_Sym
*local_syms
,
2422 asection
**local_sections
)
2424 struct elf_x86_link_hash_table
*htab
;
2425 Elf_Internal_Shdr
*symtab_hdr
;
2426 struct elf_link_hash_entry
**sym_hashes
;
2427 bfd_vma
*local_got_offsets
;
2428 bfd_vma
*local_tlsdesc_gotents
;
2429 Elf_Internal_Rela
*rel
;
2430 Elf_Internal_Rela
*wrel
;
2431 Elf_Internal_Rela
*relend
;
2432 unsigned int plt_entry_size
;
2434 /* Skip if check_relocs failed. */
2435 if (input_section
->check_relocs_failed
)
2438 htab
= elf_x86_hash_table (info
, X86_64_ELF_DATA
);
2442 if (!is_x86_elf (input_bfd
, htab
))
2444 bfd_set_error (bfd_error_wrong_format
);
2448 plt_entry_size
= htab
->plt
.plt_entry_size
;
2449 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
2450 sym_hashes
= elf_sym_hashes (input_bfd
);
2451 local_got_offsets
= elf_local_got_offsets (input_bfd
);
2452 local_tlsdesc_gotents
= elf_x86_local_tlsdesc_gotent (input_bfd
);
2454 _bfd_x86_elf_set_tls_module_base (info
);
2456 rel
= wrel
= relocs
;
2457 relend
= relocs
+ input_section
->reloc_count
;
2458 for (; rel
< relend
; wrel
++, rel
++)
2460 unsigned int r_type
, r_type_tls
;
2461 reloc_howto_type
*howto
;
2462 unsigned long r_symndx
;
2463 struct elf_link_hash_entry
*h
;
2464 struct elf_x86_link_hash_entry
*eh
;
2465 Elf_Internal_Sym
*sym
;
2467 bfd_vma off
, offplt
, plt_offset
;
2469 bfd_boolean unresolved_reloc
;
2470 bfd_reloc_status_type r
;
2472 asection
*base_got
, *resolved_plt
;
2474 bfd_boolean resolved_to_zero
;
2475 bfd_boolean relative_reloc
;
2476 bfd_boolean converted_reloc
;
2477 bfd_boolean need_copy_reloc_in_pie
;
2478 bfd_boolean no_copyreloc_p
;
2480 r_type
= ELF32_R_TYPE (rel
->r_info
);
2481 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
2482 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
2489 r_symndx
= htab
->r_sym (rel
->r_info
);
2490 converted_reloc
= (r_type
& R_X86_64_converted_reloc_bit
) != 0;
2491 if (converted_reloc
)
2493 r_type
&= ~R_X86_64_converted_reloc_bit
;
2494 rel
->r_info
= htab
->r_info (r_symndx
, r_type
);
2497 howto
= elf_x86_64_rtype_to_howto (input_bfd
, r_type
);
2499 return _bfd_unrecognized_reloc (input_bfd
, input_section
, r_type
);
2504 unresolved_reloc
= FALSE
;
2505 if (r_symndx
< symtab_hdr
->sh_info
)
2507 sym
= local_syms
+ r_symndx
;
2508 sec
= local_sections
[r_symndx
];
2510 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
2512 st_size
= sym
->st_size
;
2514 /* Relocate against local STT_GNU_IFUNC symbol. */
2515 if (!bfd_link_relocatable (info
)
2516 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
2518 h
= _bfd_elf_x86_get_local_sym_hash (htab
, input_bfd
,
2523 /* Set STT_GNU_IFUNC symbol value. */
2524 h
->root
.u
.def
.value
= sym
->st_value
;
2525 h
->root
.u
.def
.section
= sec
;
2530 bfd_boolean warned ATTRIBUTE_UNUSED
;
2531 bfd_boolean ignored ATTRIBUTE_UNUSED
;
2533 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2534 r_symndx
, symtab_hdr
, sym_hashes
,
2536 unresolved_reloc
, warned
, ignored
);
2540 if (sec
!= NULL
&& discarded_section (sec
))
2542 _bfd_clear_contents (howto
, input_bfd
, input_section
,
2543 contents
, rel
->r_offset
);
2544 wrel
->r_offset
= rel
->r_offset
;
2548 /* For ld -r, remove relocations in debug sections against
2549 sections defined in discarded sections. Not done for
2550 eh_frame editing code expects to be present. */
2551 if (bfd_link_relocatable (info
)
2552 && (input_section
->flags
& SEC_DEBUGGING
))
2558 if (bfd_link_relocatable (info
))
2565 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
2567 if (r_type
== R_X86_64_64
)
2569 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
2570 zero-extend it to 64bit if addend is zero. */
2571 r_type
= R_X86_64_32
;
2572 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
2574 else if (r_type
== R_X86_64_SIZE64
)
2576 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
2577 zero-extend it to 64bit if addend is zero. */
2578 r_type
= R_X86_64_SIZE32
;
2579 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
2583 eh
= (struct elf_x86_link_hash_entry
*) h
;
2585 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
2586 it here if it is defined in a non-shared object. */
2588 && h
->type
== STT_GNU_IFUNC
2594 if ((input_section
->flags
& SEC_ALLOC
) == 0)
2596 /* If this is a SHT_NOTE section without SHF_ALLOC, treat
2597 STT_GNU_IFUNC symbol as STT_FUNC. */
2598 if (elf_section_type (input_section
) == SHT_NOTE
)
2600 /* Dynamic relocs are not propagated for SEC_DEBUGGING
2601 sections because such sections are not SEC_ALLOC and
2602 thus ld.so will not process them. */
2603 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
2613 case R_X86_64_GOTPCREL
:
2614 case R_X86_64_GOTPCRELX
:
2615 case R_X86_64_REX_GOTPCRELX
:
2616 case R_X86_64_GOTPCREL64
:
2617 base_got
= htab
->elf
.sgot
;
2618 off
= h
->got
.offset
;
2620 if (base_got
== NULL
)
2623 if (off
== (bfd_vma
) -1)
2625 /* We can't use h->got.offset here to save state, or
2626 even just remember the offset, as finish_dynamic_symbol
2627 would use that as offset into .got. */
2629 if (h
->plt
.offset
== (bfd_vma
) -1)
2632 if (htab
->elf
.splt
!= NULL
)
2634 plt_index
= (h
->plt
.offset
/ plt_entry_size
2635 - htab
->plt
.has_plt0
);
2636 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
2637 base_got
= htab
->elf
.sgotplt
;
2641 plt_index
= h
->plt
.offset
/ plt_entry_size
;
2642 off
= plt_index
* GOT_ENTRY_SIZE
;
2643 base_got
= htab
->elf
.igotplt
;
2646 if (h
->dynindx
== -1
2650 /* This references the local defitionion. We must
2651 initialize this entry in the global offset table.
2652 Since the offset must always be a multiple of 8,
2653 we use the least significant bit to record
2654 whether we have initialized it already.
2656 When doing a dynamic link, we create a .rela.got
2657 relocation entry to initialize the value. This
2658 is done in the finish_dynamic_symbol routine. */
2663 bfd_put_64 (output_bfd
, relocation
,
2664 base_got
->contents
+ off
);
2665 /* Note that this is harmless for the GOTPLT64
2666 case, as -1 | 1 still is -1. */
2672 relocation
= (base_got
->output_section
->vma
2673 + base_got
->output_offset
+ off
);
2678 if (h
->plt
.offset
== (bfd_vma
) -1)
2680 /* Handle static pointers of STT_GNU_IFUNC symbols. */
2681 if (r_type
== htab
->pointer_r_type
2682 && (input_section
->flags
& SEC_CODE
) == 0)
2683 goto do_ifunc_pointer
;
2684 goto bad_ifunc_reloc
;
2687 /* STT_GNU_IFUNC symbol must go through PLT. */
2688 if (htab
->elf
.splt
!= NULL
)
2690 if (htab
->plt_second
!= NULL
)
2692 resolved_plt
= htab
->plt_second
;
2693 plt_offset
= eh
->plt_second
.offset
;
2697 resolved_plt
= htab
->elf
.splt
;
2698 plt_offset
= h
->plt
.offset
;
2703 resolved_plt
= htab
->elf
.iplt
;
2704 plt_offset
= h
->plt
.offset
;
2707 relocation
= (resolved_plt
->output_section
->vma
2708 + resolved_plt
->output_offset
+ plt_offset
);
2714 if (h
->root
.root
.string
)
2715 name
= h
->root
.root
.string
;
2717 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
2720 /* xgettext:c-format */
2721 (_("%pB: relocation %s against STT_GNU_IFUNC "
2722 "symbol `%s' isn't supported"), input_bfd
,
2724 bfd_set_error (bfd_error_bad_value
);
2728 if (bfd_link_pic (info
))
2733 if (ABI_64_P (output_bfd
))
2738 if (rel
->r_addend
!= 0)
2740 if (h
->root
.root
.string
)
2741 name
= h
->root
.root
.string
;
2743 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
2746 /* xgettext:c-format */
2747 (_("%pB: relocation %s against STT_GNU_IFUNC "
2748 "symbol `%s' has non-zero addend: %" PRId64
),
2749 input_bfd
, howto
->name
, name
, (int64_t) rel
->r_addend
);
2750 bfd_set_error (bfd_error_bad_value
);
2754 /* Generate dynamic relcoation only when there is a
2755 non-GOT reference in a shared object or there is no
2757 if ((bfd_link_pic (info
) && h
->non_got_ref
)
2758 || h
->plt
.offset
== (bfd_vma
) -1)
2760 Elf_Internal_Rela outrel
;
2763 /* Need a dynamic relocation to get the real function
2765 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
2769 if (outrel
.r_offset
== (bfd_vma
) -1
2770 || outrel
.r_offset
== (bfd_vma
) -2)
2773 outrel
.r_offset
+= (input_section
->output_section
->vma
2774 + input_section
->output_offset
);
2776 if (POINTER_LOCAL_IFUNC_P (info
, h
))
2778 info
->callbacks
->minfo (_("Local IFUNC function `%s' in %pB\n"),
2779 h
->root
.root
.string
,
2780 h
->root
.u
.def
.section
->owner
);
2782 /* This symbol is resolved locally. */
2783 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
2784 outrel
.r_addend
= (h
->root
.u
.def
.value
2785 + h
->root
.u
.def
.section
->output_section
->vma
2786 + h
->root
.u
.def
.section
->output_offset
);
2788 if (htab
->params
->report_relative_reloc
)
2789 _bfd_x86_elf_link_report_relative_reloc
2790 (info
, input_section
, h
, sym
,
2791 "R_X86_64_IRELATIVE", &outrel
);
2795 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
2796 outrel
.r_addend
= 0;
2799 /* Dynamic relocations are stored in
2800 1. .rela.ifunc section in PIC object.
2801 2. .rela.got section in dynamic executable.
2802 3. .rela.iplt section in static executable. */
2803 if (bfd_link_pic (info
))
2804 sreloc
= htab
->elf
.irelifunc
;
2805 else if (htab
->elf
.splt
!= NULL
)
2806 sreloc
= htab
->elf
.srelgot
;
2808 sreloc
= htab
->elf
.irelplt
;
2809 elf_append_rela (output_bfd
, sreloc
, &outrel
);
2811 /* If this reloc is against an external symbol, we
2812 do not want to fiddle with the addend. Otherwise,
2813 we need to include the symbol value so that it
2814 becomes an addend for the dynamic reloc. For an
2815 internal symbol, we have updated addend. */
2820 case R_X86_64_PC32_BND
:
2822 case R_X86_64_PLT32
:
2823 case R_X86_64_PLT32_BND
:
2829 resolved_to_zero
= (eh
!= NULL
2830 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, eh
));
2832 /* When generating a shared object, the relocations handled here are
2833 copied into the output file to be resolved at run time. */
2836 case R_X86_64_GOT32
:
2837 case R_X86_64_GOT64
:
2838 /* Relocation is to the entry for this symbol in the global
2840 case R_X86_64_GOTPCREL
:
2841 case R_X86_64_GOTPCRELX
:
2842 case R_X86_64_REX_GOTPCRELX
:
2843 case R_X86_64_GOTPCREL64
:
2844 /* Use global offset table entry as symbol value. */
2845 case R_X86_64_GOTPLT64
:
2846 /* This is obsolete and treated the same as GOT64. */
2847 base_got
= htab
->elf
.sgot
;
2849 if (htab
->elf
.sgot
== NULL
)
2852 relative_reloc
= FALSE
;
2855 off
= h
->got
.offset
;
2857 && h
->plt
.offset
!= (bfd_vma
)-1
2858 && off
== (bfd_vma
)-1)
2860 /* We can't use h->got.offset here to save
2861 state, or even just remember the offset, as
2862 finish_dynamic_symbol would use that as offset into
2864 bfd_vma plt_index
= (h
->plt
.offset
/ plt_entry_size
2865 - htab
->plt
.has_plt0
);
2866 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
2867 base_got
= htab
->elf
.sgotplt
;
2870 if (RESOLVED_LOCALLY_P (info
, h
, htab
))
2872 /* We must initialize this entry in the global offset
2873 table. Since the offset must always be a multiple
2874 of 8, we use the least significant bit to record
2875 whether we have initialized it already.
2877 When doing a dynamic link, we create a .rela.got
2878 relocation entry to initialize the value. This is
2879 done in the finish_dynamic_symbol routine. */
2884 bfd_put_64 (output_bfd
, relocation
,
2885 base_got
->contents
+ off
);
2886 /* Note that this is harmless for the GOTPLT64 case,
2887 as -1 | 1 still is -1. */
2890 if (GENERATE_RELATIVE_RELOC_P (info
, h
))
2892 /* If this symbol isn't dynamic in PIC,
2893 generate R_X86_64_RELATIVE here. */
2894 eh
->no_finish_dynamic_symbol
= 1;
2895 relative_reloc
= TRUE
;
2900 unresolved_reloc
= FALSE
;
2904 if (local_got_offsets
== NULL
)
2907 off
= local_got_offsets
[r_symndx
];
2909 /* The offset must always be a multiple of 8. We use
2910 the least significant bit to record whether we have
2911 already generated the necessary reloc. */
2916 bfd_put_64 (output_bfd
, relocation
,
2917 base_got
->contents
+ off
);
2918 local_got_offsets
[r_symndx
] |= 1;
2920 /* NB: GOTPCREL relocations against local absolute
2921 symbol store relocation value in the GOT slot
2922 without relative relocation. */
2923 if (bfd_link_pic (info
)
2924 && !(sym
->st_shndx
== SHN_ABS
2925 && (r_type
== R_X86_64_GOTPCREL
2926 || r_type
== R_X86_64_GOTPCRELX
2927 || r_type
== R_X86_64_REX_GOTPCRELX
)))
2928 relative_reloc
= TRUE
;
2935 Elf_Internal_Rela outrel
;
2937 /* We need to generate a R_X86_64_RELATIVE reloc
2938 for the dynamic linker. */
2939 s
= htab
->elf
.srelgot
;
2943 outrel
.r_offset
= (base_got
->output_section
->vma
2944 + base_got
->output_offset
2946 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
2947 outrel
.r_addend
= relocation
;
2949 if (htab
->params
->report_relative_reloc
)
2950 _bfd_x86_elf_link_report_relative_reloc
2951 (info
, input_section
, h
, sym
, "R_X86_64_RELATIVE",
2954 elf_append_rela (output_bfd
, s
, &outrel
);
2957 if (off
>= (bfd_vma
) -2)
2960 relocation
= base_got
->output_section
->vma
2961 + base_got
->output_offset
+ off
;
2962 if (r_type
!= R_X86_64_GOTPCREL
2963 && r_type
!= R_X86_64_GOTPCRELX
2964 && r_type
!= R_X86_64_REX_GOTPCRELX
2965 && r_type
!= R_X86_64_GOTPCREL64
)
2966 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
2967 - htab
->elf
.sgotplt
->output_offset
;
2971 case R_X86_64_GOTOFF64
:
2972 /* Relocation is relative to the start of the global offset
2975 /* Check to make sure it isn't a protected function or data
2976 symbol for shared library since it may not be local when
2977 used as function address or with copy relocation. We also
2978 need to make sure that a symbol is referenced locally. */
2979 if (bfd_link_pic (info
) && h
)
2981 if (!h
->def_regular
)
2985 switch (ELF_ST_VISIBILITY (h
->other
))
2988 v
= _("hidden symbol");
2991 v
= _("internal symbol");
2994 v
= _("protected symbol");
3002 /* xgettext:c-format */
3003 (_("%pB: relocation R_X86_64_GOTOFF64 against undefined %s"
3004 " `%s' can not be used when making a shared object"),
3005 input_bfd
, v
, h
->root
.root
.string
);
3006 bfd_set_error (bfd_error_bad_value
);
3009 else if (!bfd_link_executable (info
)
3010 && !SYMBOL_REFERENCES_LOCAL_P (info
, h
)
3011 && (h
->type
== STT_FUNC
3012 || h
->type
== STT_OBJECT
)
3013 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
3016 /* xgettext:c-format */
3017 (_("%pB: relocation R_X86_64_GOTOFF64 against protected %s"
3018 " `%s' can not be used when making a shared object"),
3020 h
->type
== STT_FUNC
? "function" : "data",
3021 h
->root
.root
.string
);
3022 bfd_set_error (bfd_error_bad_value
);
3027 /* Note that sgot is not involved in this
3028 calculation. We always want the start of .got.plt. If we
3029 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3030 permitted by the ABI, we might have to change this
3032 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3033 + htab
->elf
.sgotplt
->output_offset
;
3036 case R_X86_64_GOTPC32
:
3037 case R_X86_64_GOTPC64
:
3038 /* Use global offset table as symbol value. */
3039 relocation
= htab
->elf
.sgotplt
->output_section
->vma
3040 + htab
->elf
.sgotplt
->output_offset
;
3041 unresolved_reloc
= FALSE
;
3044 case R_X86_64_PLTOFF64
:
3045 /* Relocation is PLT entry relative to GOT. For local
3046 symbols it's the symbol itself relative to GOT. */
3048 /* See PLT32 handling. */
3049 && (h
->plt
.offset
!= (bfd_vma
) -1
3050 || eh
->plt_got
.offset
!= (bfd_vma
) -1)
3051 && htab
->elf
.splt
!= NULL
)
3053 if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
3055 /* Use the GOT PLT. */
3056 resolved_plt
= htab
->plt_got
;
3057 plt_offset
= eh
->plt_got
.offset
;
3059 else if (htab
->plt_second
!= NULL
)
3061 resolved_plt
= htab
->plt_second
;
3062 plt_offset
= eh
->plt_second
.offset
;
3066 resolved_plt
= htab
->elf
.splt
;
3067 plt_offset
= h
->plt
.offset
;
3070 relocation
= (resolved_plt
->output_section
->vma
3071 + resolved_plt
->output_offset
3073 unresolved_reloc
= FALSE
;
3076 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3077 + htab
->elf
.sgotplt
->output_offset
;
3080 case R_X86_64_PLT32
:
3081 case R_X86_64_PLT32_BND
:
3082 /* Relocation is to the entry for this symbol in the
3083 procedure linkage table. */
3085 /* Resolve a PLT32 reloc against a local symbol directly,
3086 without using the procedure linkage table. */
3090 if ((h
->plt
.offset
== (bfd_vma
) -1
3091 && eh
->plt_got
.offset
== (bfd_vma
) -1)
3092 || htab
->elf
.splt
== NULL
)
3094 /* We didn't make a PLT entry for this symbol. This
3095 happens when statically linking PIC code, or when
3096 using -Bsymbolic. */
3101 if (h
->plt
.offset
!= (bfd_vma
) -1)
3103 if (htab
->plt_second
!= NULL
)
3105 resolved_plt
= htab
->plt_second
;
3106 plt_offset
= eh
->plt_second
.offset
;
3110 resolved_plt
= htab
->elf
.splt
;
3111 plt_offset
= h
->plt
.offset
;
3116 /* Use the GOT PLT. */
3117 resolved_plt
= htab
->plt_got
;
3118 plt_offset
= eh
->plt_got
.offset
;
3121 relocation
= (resolved_plt
->output_section
->vma
3122 + resolved_plt
->output_offset
3124 unresolved_reloc
= FALSE
;
3127 case R_X86_64_SIZE32
:
3128 case R_X86_64_SIZE64
:
3129 /* Set to symbol size. */
3130 relocation
= st_size
;
3136 case R_X86_64_PC32_BND
:
3137 /* Don't complain about -fPIC if the symbol is undefined when
3138 building executable unless it is unresolved weak symbol,
3139 references a dynamic definition in PIE or -z nocopyreloc
3142 = (info
->nocopyreloc
3144 && !h
->root
.linker_def
3145 && !h
->root
.ldscript_def
3146 && eh
->def_protected
3147 && elf_has_no_copy_on_protected (h
->root
.u
.def
.section
->owner
)));
3149 if ((input_section
->flags
& SEC_ALLOC
) != 0
3150 && (input_section
->flags
& SEC_READONLY
) != 0
3152 && ((bfd_link_executable (info
)
3153 && ((h
->root
.type
== bfd_link_hash_undefweak
3155 || !UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
3157 || (bfd_link_pie (info
)
3158 && !SYMBOL_DEFINED_NON_SHARED_P (h
)
3162 && !(h
->root
.u
.def
.section
->flags
& SEC_CODE
))))
3163 || bfd_link_dll (info
)))
3165 bfd_boolean fail
= FALSE
;
3166 if (SYMBOL_REFERENCES_LOCAL_P (info
, h
))
3168 /* Symbol is referenced locally. Make sure it is
3170 fail
= !SYMBOL_DEFINED_NON_SHARED_P (h
);
3172 else if (bfd_link_pie (info
))
3174 /* We can only use PC-relative relocations in PIE
3175 from non-code sections. */
3176 if (h
->type
== STT_FUNC
3177 && (sec
->flags
& SEC_CODE
) != 0)
3180 else if (no_copyreloc_p
|| bfd_link_dll (info
))
3182 /* Symbol doesn't need copy reloc and isn't
3183 referenced locally. Don't allow PC-relative
3184 relocations against default and protected
3185 symbols since address of protected function
3186 and location of protected data may not be in
3187 the shared object. */
3188 fail
= (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3189 || ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
);
3193 return elf_x86_64_need_pic (info
, input_bfd
, input_section
,
3194 h
, NULL
, NULL
, howto
);
3196 /* Since x86-64 has PC-relative PLT, we can use PLT in PIE
3197 as function address. */
3199 && (input_section
->flags
& SEC_CODE
) == 0
3200 && bfd_link_pie (info
)
3201 && h
->type
== STT_FUNC
3212 /* FIXME: The ABI says the linker should make sure the value is
3213 the same when it's zeroextended to 64 bit. */
3216 if ((input_section
->flags
& SEC_ALLOC
) == 0)
3219 need_copy_reloc_in_pie
= (bfd_link_pie (info
)
3224 == bfd_link_hash_undefined
))
3225 && (X86_PCREL_TYPE_P (r_type
)
3226 || X86_SIZE_TYPE_P (r_type
)));
3228 if (GENERATE_DYNAMIC_RELOCATION_P (info
, eh
, r_type
, sec
,
3229 need_copy_reloc_in_pie
,
3230 resolved_to_zero
, FALSE
))
3232 Elf_Internal_Rela outrel
;
3233 bfd_boolean skip
, relocate
;
3235 const char *relative_reloc_name
= NULL
;
3237 /* When generating a shared object, these relocations
3238 are copied into the output file to be resolved at run
3244 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3246 if (outrel
.r_offset
== (bfd_vma
) -1)
3248 else if (outrel
.r_offset
== (bfd_vma
) -2)
3249 skip
= TRUE
, relocate
= TRUE
;
3251 outrel
.r_offset
+= (input_section
->output_section
->vma
3252 + input_section
->output_offset
);
3255 memset (&outrel
, 0, sizeof outrel
);
3257 else if (COPY_INPUT_RELOC_P (info
, h
, r_type
))
3259 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
3260 outrel
.r_addend
= rel
->r_addend
;
3264 /* This symbol is local, or marked to become local.
3265 When relocation overflow check is disabled, we
3266 convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */
3267 if (r_type
== htab
->pointer_r_type
3268 || (r_type
== R_X86_64_32
3269 && htab
->params
->no_reloc_overflow_check
))
3272 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
3273 outrel
.r_addend
= relocation
+ rel
->r_addend
;
3274 relative_reloc_name
= "R_X86_64_RELATIVE";
3276 else if (r_type
== R_X86_64_64
3277 && !ABI_64_P (output_bfd
))
3280 outrel
.r_info
= htab
->r_info (0,
3281 R_X86_64_RELATIVE64
);
3282 outrel
.r_addend
= relocation
+ rel
->r_addend
;
3283 relative_reloc_name
= "R_X86_64_RELATIVE64";
3284 /* Check addend overflow. */
3285 if ((outrel
.r_addend
& 0x80000000)
3286 != (rel
->r_addend
& 0x80000000))
3289 int addend
= rel
->r_addend
;
3290 if (h
&& h
->root
.root
.string
)
3291 name
= h
->root
.root
.string
;
3293 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
3296 /* xgettext:c-format */
3297 (_("%pB: addend %s%#x in relocation %s against "
3298 "symbol `%s' at %#" PRIx64
3299 " in section `%pA' is out of range"),
3300 input_bfd
, addend
< 0 ? "-" : "", addend
,
3301 howto
->name
, name
, (uint64_t) rel
->r_offset
,
3303 bfd_set_error (bfd_error_bad_value
);
3311 if (bfd_is_abs_section (sec
))
3313 else if (sec
== NULL
|| sec
->owner
== NULL
)
3315 bfd_set_error (bfd_error_bad_value
);
3322 /* We are turning this relocation into one
3323 against a section symbol. It would be
3324 proper to subtract the symbol's value,
3325 osec->vma, from the emitted reloc addend,
3326 but ld.so expects buggy relocs. */
3327 osec
= sec
->output_section
;
3328 sindx
= elf_section_data (osec
)->dynindx
;
3331 asection
*oi
= htab
->elf
.text_index_section
;
3332 sindx
= elf_section_data (oi
)->dynindx
;
3334 BFD_ASSERT (sindx
!= 0);
3337 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
3338 outrel
.r_addend
= relocation
+ rel
->r_addend
;
3342 sreloc
= elf_section_data (input_section
)->sreloc
;
3344 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
3346 r
= bfd_reloc_notsupported
;
3347 goto check_relocation_error
;
3350 if (relative_reloc_name
3351 && htab
->params
->report_relative_reloc
)
3352 _bfd_x86_elf_link_report_relative_reloc
3353 (info
, input_section
, h
, sym
, relative_reloc_name
,
3356 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3358 /* If this reloc is against an external symbol, we do
3359 not want to fiddle with the addend. Otherwise, we
3360 need to include the symbol value so that it becomes
3361 an addend for the dynamic reloc. */
3368 case R_X86_64_TLSGD
:
3369 case R_X86_64_GOTPC32_TLSDESC
:
3370 case R_X86_64_TLSDESC_CALL
:
3371 case R_X86_64_GOTTPOFF
:
3372 tls_type
= GOT_UNKNOWN
;
3373 if (h
== NULL
&& local_got_offsets
)
3374 tls_type
= elf_x86_local_got_tls_type (input_bfd
) [r_symndx
];
3376 tls_type
= elf_x86_hash_entry (h
)->tls_type
;
3378 r_type_tls
= r_type
;
3379 if (! elf_x86_64_tls_transition (info
, input_bfd
,
3380 input_section
, contents
,
3381 symtab_hdr
, sym_hashes
,
3382 &r_type_tls
, tls_type
, rel
,
3383 relend
, h
, r_symndx
, TRUE
))
3386 if (r_type_tls
== R_X86_64_TPOFF32
)
3388 bfd_vma roff
= rel
->r_offset
;
3390 BFD_ASSERT (! unresolved_reloc
);
3392 if (r_type
== R_X86_64_TLSGD
)
3394 /* GD->LE transition. For 64bit, change
3395 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3396 .word 0x6666; rex64; call __tls_get_addr@PLT
3398 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3400 call *__tls_get_addr@GOTPCREL(%rip)
3401 which may be converted to
3402 addr32 call __tls_get_addr
3405 leaq foo@tpoff(%rax), %rax
3407 leaq foo@tlsgd(%rip), %rdi
3408 .word 0x6666; rex64; call __tls_get_addr@PLT
3410 leaq foo@tlsgd(%rip), %rdi
3412 call *__tls_get_addr@GOTPCREL(%rip)
3413 which may be converted to
3414 addr32 call __tls_get_addr
3417 leaq foo@tpoff(%rax), %rax
3418 For largepic, change:
3419 leaq foo@tlsgd(%rip), %rdi
3420 movabsq $__tls_get_addr@pltoff, %rax
3425 leaq foo@tpoff(%rax), %rax
3426 nopw 0x0(%rax,%rax,1) */
3428 if (ABI_64_P (output_bfd
))
3430 if (contents
[roff
+ 5] == 0xb8)
3433 || (roff
- 3 + 22) > input_section
->size
)
3436 info
->callbacks
->einfo
3437 (_("%F%P: corrupt input: %pB\n"),
3441 memcpy (contents
+ roff
- 3,
3442 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
3443 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
3449 || (roff
- 4 + 16) > input_section
->size
)
3451 memcpy (contents
+ roff
- 4,
3452 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3459 || (roff
- 3 + 15) > input_section
->size
)
3461 memcpy (contents
+ roff
- 3,
3462 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3465 bfd_put_32 (output_bfd
,
3466 elf_x86_64_tpoff (info
, relocation
),
3467 contents
+ roff
+ 8 + largepic
);
3468 /* Skip R_X86_64_PC32, R_X86_64_PLT32,
3469 R_X86_64_GOTPCRELX and R_X86_64_PLTOFF64. */
3474 else if (r_type
== R_X86_64_GOTPC32_TLSDESC
)
3476 /* GDesc -> LE transition.
3477 It's originally something like:
3478 leaq x@tlsdesc(%rip), %rax <--- LP64 mode.
3479 rex leal x@tlsdesc(%rip), %eax <--- X32 mode.
3482 movq $x@tpoff, %rax <--- LP64 mode.
3483 rex movl $x@tpoff, %eax <--- X32 mode.
3486 unsigned int val
, type
;
3490 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
3491 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
3492 bfd_put_8 (output_bfd
,
3493 (type
& 0x48) | ((type
>> 2) & 1),
3494 contents
+ roff
- 3);
3495 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
3496 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
3497 contents
+ roff
- 1);
3498 bfd_put_32 (output_bfd
,
3499 elf_x86_64_tpoff (info
, relocation
),
3503 else if (r_type
== R_X86_64_TLSDESC_CALL
)
3505 /* GDesc -> LE transition.
3507 call *(%rax) <--- LP64 mode.
3508 call *(%eax) <--- X32 mode.
3510 xchg %ax,%ax <-- LP64 mode.
3511 nopl (%rax) <-- X32 mode.
3513 unsigned int prefix
= 0;
3514 if (!ABI_64_P (input_bfd
))
3516 /* Check for call *x@tlsdesc(%eax). */
3517 if (contents
[roff
] == 0x67)
3522 bfd_put_8 (output_bfd
, 0x0f, contents
+ roff
);
3523 bfd_put_8 (output_bfd
, 0x1f, contents
+ roff
+ 1);
3524 bfd_put_8 (output_bfd
, 0x00, contents
+ roff
+ 2);
3528 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
3529 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
3533 else if (r_type
== R_X86_64_GOTTPOFF
)
3535 /* IE->LE transition:
3536 For 64bit, originally it can be one of:
3537 movq foo@gottpoff(%rip), %reg
3538 addq foo@gottpoff(%rip), %reg
3541 leaq foo(%reg), %reg
3543 For 32bit, originally it can be one of:
3544 movq foo@gottpoff(%rip), %reg
3545 addl foo@gottpoff(%rip), %reg
3548 leal foo(%reg), %reg
3551 unsigned int val
, type
, reg
;
3554 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
3561 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
3562 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
3571 bfd_put_8 (output_bfd
, 0x49,
3572 contents
+ roff
- 3);
3574 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
3578 bfd_put_8 (output_bfd
, 0x41,
3579 contents
+ roff
- 3);
3581 bfd_put_8 (output_bfd
, 0xc7,
3582 contents
+ roff
- 2);
3583 bfd_put_8 (output_bfd
, 0xc0 | reg
,
3584 contents
+ roff
- 1);
3588 /* addq/addl -> addq/addl - addressing with %rsp/%r12
3594 bfd_put_8 (output_bfd
, 0x49,
3595 contents
+ roff
- 3);
3597 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
3601 bfd_put_8 (output_bfd
, 0x41,
3602 contents
+ roff
- 3);
3604 bfd_put_8 (output_bfd
, 0x81,
3605 contents
+ roff
- 2);
3606 bfd_put_8 (output_bfd
, 0xc0 | reg
,
3607 contents
+ roff
- 1);
3611 /* addq/addl -> leaq/leal */
3616 bfd_put_8 (output_bfd
, 0x4d,
3617 contents
+ roff
- 3);
3619 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
3623 bfd_put_8 (output_bfd
, 0x45,
3624 contents
+ roff
- 3);
3626 bfd_put_8 (output_bfd
, 0x8d,
3627 contents
+ roff
- 2);
3628 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
3629 contents
+ roff
- 1);
3631 bfd_put_32 (output_bfd
,
3632 elf_x86_64_tpoff (info
, relocation
),
3640 if (htab
->elf
.sgot
== NULL
)
3645 off
= h
->got
.offset
;
3646 offplt
= elf_x86_hash_entry (h
)->tlsdesc_got
;
3650 if (local_got_offsets
== NULL
)
3653 off
= local_got_offsets
[r_symndx
];
3654 offplt
= local_tlsdesc_gotents
[r_symndx
];
3661 Elf_Internal_Rela outrel
;
3665 if (htab
->elf
.srelgot
== NULL
)
3668 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
3670 if (GOT_TLS_GDESC_P (tls_type
))
3672 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
3673 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
3674 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
3675 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
3676 + htab
->elf
.sgotplt
->output_offset
3678 + htab
->sgotplt_jump_table_size
);
3679 sreloc
= htab
->elf
.srelplt
;
3681 outrel
.r_addend
= relocation
- _bfd_x86_elf_dtpoff_base (info
);
3683 outrel
.r_addend
= 0;
3684 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3687 sreloc
= htab
->elf
.srelgot
;
3689 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
3690 + htab
->elf
.sgot
->output_offset
+ off
);
3692 if (GOT_TLS_GD_P (tls_type
))
3693 dr_type
= R_X86_64_DTPMOD64
;
3694 else if (GOT_TLS_GDESC_P (tls_type
))
3697 dr_type
= R_X86_64_TPOFF64
;
3699 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
3700 outrel
.r_addend
= 0;
3701 if ((dr_type
== R_X86_64_TPOFF64
3702 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
3703 outrel
.r_addend
= relocation
- _bfd_x86_elf_dtpoff_base (info
);
3704 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
3706 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3708 if (GOT_TLS_GD_P (tls_type
))
3712 BFD_ASSERT (! unresolved_reloc
);
3713 bfd_put_64 (output_bfd
,
3714 relocation
- _bfd_x86_elf_dtpoff_base (info
),
3715 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
3719 bfd_put_64 (output_bfd
, 0,
3720 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
3721 outrel
.r_info
= htab
->r_info (indx
,
3723 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
3724 elf_append_rela (output_bfd
, sreloc
,
3733 local_got_offsets
[r_symndx
] |= 1;
3736 if (off
>= (bfd_vma
) -2
3737 && ! GOT_TLS_GDESC_P (tls_type
))
3739 if (r_type_tls
== r_type
)
3741 if (r_type
== R_X86_64_GOTPC32_TLSDESC
3742 || r_type
== R_X86_64_TLSDESC_CALL
)
3743 relocation
= htab
->elf
.sgotplt
->output_section
->vma
3744 + htab
->elf
.sgotplt
->output_offset
3745 + offplt
+ htab
->sgotplt_jump_table_size
;
3747 relocation
= htab
->elf
.sgot
->output_section
->vma
3748 + htab
->elf
.sgot
->output_offset
+ off
;
3749 unresolved_reloc
= FALSE
;
3753 bfd_vma roff
= rel
->r_offset
;
3755 if (r_type
== R_X86_64_TLSGD
)
3757 /* GD->IE transition. For 64bit, change
3758 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3759 .word 0x6666; rex64; call __tls_get_addr@PLT
3761 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3763 call *__tls_get_addr@GOTPCREL(%rip
3764 which may be converted to
3765 addr32 call __tls_get_addr
3768 addq foo@gottpoff(%rip), %rax
3770 leaq foo@tlsgd(%rip), %rdi
3771 .word 0x6666; rex64; call __tls_get_addr@PLT
3773 leaq foo@tlsgd(%rip), %rdi
3775 call *__tls_get_addr@GOTPCREL(%rip)
3776 which may be converted to
3777 addr32 call __tls_get_addr
3780 addq foo@gottpoff(%rip), %rax
3781 For largepic, change:
3782 leaq foo@tlsgd(%rip), %rdi
3783 movabsq $__tls_get_addr@pltoff, %rax
3788 addq foo@gottpoff(%rax), %rax
3789 nopw 0x0(%rax,%rax,1) */
3791 if (ABI_64_P (output_bfd
))
3793 if (contents
[roff
+ 5] == 0xb8)
3796 || (roff
- 3 + 22) > input_section
->size
)
3798 memcpy (contents
+ roff
- 3,
3799 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
3800 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
3806 || (roff
- 4 + 16) > input_section
->size
)
3808 memcpy (contents
+ roff
- 4,
3809 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
3816 || (roff
- 3 + 15) > input_section
->size
)
3818 memcpy (contents
+ roff
- 3,
3819 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
3823 relocation
= (htab
->elf
.sgot
->output_section
->vma
3824 + htab
->elf
.sgot
->output_offset
+ off
3827 - input_section
->output_section
->vma
3828 - input_section
->output_offset
3830 bfd_put_32 (output_bfd
, relocation
,
3831 contents
+ roff
+ 8 + largepic
);
3832 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
3837 else if (r_type
== R_X86_64_GOTPC32_TLSDESC
)
3839 /* GDesc -> IE transition.
3840 It's originally something like:
3841 leaq x@tlsdesc(%rip), %rax <--- LP64 mode.
3842 rex leal x@tlsdesc(%rip), %eax <--- X32 mode.
3845 # before xchg %ax,%ax in LP64 mode.
3846 movq x@gottpoff(%rip), %rax
3847 # before nopl (%rax) in X32 mode.
3848 rex movl x@gottpoff(%rip), %eax
3851 /* Now modify the instruction as appropriate. To
3852 turn a lea into a mov in the form we use it, it
3853 suffices to change the second byte from 0x8d to
3857 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
3859 bfd_put_32 (output_bfd
,
3860 htab
->elf
.sgot
->output_section
->vma
3861 + htab
->elf
.sgot
->output_offset
+ off
3863 - input_section
->output_section
->vma
3864 - input_section
->output_offset
3869 else if (r_type
== R_X86_64_TLSDESC_CALL
)
3871 /* GDesc -> IE transition.
3873 call *(%rax) <--- LP64 mode.
3874 call *(%eax) <--- X32 mode.
3877 xchg %ax, %ax <-- LP64 mode.
3878 nopl (%rax) <-- X32 mode.
3881 unsigned int prefix
= 0;
3882 if (!ABI_64_P (input_bfd
))
3884 /* Check for call *x@tlsdesc(%eax). */
3885 if (contents
[roff
] == 0x67)
3890 bfd_put_8 (output_bfd
, 0x0f, contents
+ roff
);
3891 bfd_put_8 (output_bfd
, 0x1f, contents
+ roff
+ 1);
3892 bfd_put_8 (output_bfd
, 0x00, contents
+ roff
+ 2);
3896 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
3897 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
3906 case R_X86_64_TLSLD
:
3907 if (! elf_x86_64_tls_transition (info
, input_bfd
,
3908 input_section
, contents
,
3909 symtab_hdr
, sym_hashes
,
3910 &r_type
, GOT_UNKNOWN
, rel
,
3911 relend
, h
, r_symndx
, TRUE
))
3914 if (r_type
!= R_X86_64_TLSLD
)
3916 /* LD->LE transition:
3917 leaq foo@tlsld(%rip), %rdi
3918 call __tls_get_addr@PLT
3919 For 64bit, we change it into:
3920 .word 0x6666; .byte 0x66; movq %fs:0, %rax
3921 For 32bit, we change it into:
3922 nopl 0x0(%rax); movl %fs:0, %eax
3924 leaq foo@tlsld(%rip), %rdi;
3925 call *__tls_get_addr@GOTPCREL(%rip)
3926 which may be converted to
3927 addr32 call __tls_get_addr
3928 For 64bit, we change it into:
3929 .word 0x6666; .word 0x6666; movq %fs:0, %rax
3930 For 32bit, we change it into:
3931 nopw 0x0(%rax); movl %fs:0, %eax
3932 For largepic, change:
3933 leaq foo@tlsgd(%rip), %rdi
3934 movabsq $__tls_get_addr@pltoff, %rax
3938 data16 data16 data16 nopw %cs:0x0(%rax,%rax,1)
3941 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
3942 if (ABI_64_P (output_bfd
))
3944 if ((rel
->r_offset
+ 5) >= input_section
->size
)
3946 if (contents
[rel
->r_offset
+ 5] == 0xb8)
3948 if (rel
->r_offset
< 3
3949 || (rel
->r_offset
- 3 + 22) > input_section
->size
)
3951 memcpy (contents
+ rel
->r_offset
- 3,
3952 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
3953 "\x64\x48\x8b\x04\x25\0\0\0", 22);
3955 else if (contents
[rel
->r_offset
+ 4] == 0xff
3956 || contents
[rel
->r_offset
+ 4] == 0x67)
3958 if (rel
->r_offset
< 3
3959 || (rel
->r_offset
- 3 + 13) > input_section
->size
)
3961 memcpy (contents
+ rel
->r_offset
- 3,
3962 "\x66\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0",
3968 if (rel
->r_offset
< 3
3969 || (rel
->r_offset
- 3 + 12) > input_section
->size
)
3971 memcpy (contents
+ rel
->r_offset
- 3,
3972 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
3977 if ((rel
->r_offset
+ 4) >= input_section
->size
)
3979 if (contents
[rel
->r_offset
+ 4] == 0xff)
3981 if (rel
->r_offset
< 3
3982 || (rel
->r_offset
- 3 + 13) > input_section
->size
)
3984 memcpy (contents
+ rel
->r_offset
- 3,
3985 "\x66\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0",
3990 if (rel
->r_offset
< 3
3991 || (rel
->r_offset
- 3 + 12) > input_section
->size
)
3993 memcpy (contents
+ rel
->r_offset
- 3,
3994 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
3997 /* Skip R_X86_64_PC32, R_X86_64_PLT32, R_X86_64_GOTPCRELX
3998 and R_X86_64_PLTOFF64. */
4004 if (htab
->elf
.sgot
== NULL
)
4007 off
= htab
->tls_ld_or_ldm_got
.offset
;
4012 Elf_Internal_Rela outrel
;
4014 if (htab
->elf
.srelgot
== NULL
)
4017 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4018 + htab
->elf
.sgot
->output_offset
+ off
);
4020 bfd_put_64 (output_bfd
, 0,
4021 htab
->elf
.sgot
->contents
+ off
);
4022 bfd_put_64 (output_bfd
, 0,
4023 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4024 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
4025 outrel
.r_addend
= 0;
4026 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
4028 htab
->tls_ld_or_ldm_got
.offset
|= 1;
4030 relocation
= htab
->elf
.sgot
->output_section
->vma
4031 + htab
->elf
.sgot
->output_offset
+ off
;
4032 unresolved_reloc
= FALSE
;
4035 case R_X86_64_DTPOFF32
:
4036 if (!bfd_link_executable (info
)
4037 || (input_section
->flags
& SEC_CODE
) == 0)
4038 relocation
-= _bfd_x86_elf_dtpoff_base (info
);
4040 relocation
= elf_x86_64_tpoff (info
, relocation
);
4043 case R_X86_64_TPOFF32
:
4044 case R_X86_64_TPOFF64
:
4045 BFD_ASSERT (bfd_link_executable (info
));
4046 relocation
= elf_x86_64_tpoff (info
, relocation
);
4049 case R_X86_64_DTPOFF64
:
4050 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
4051 relocation
-= _bfd_x86_elf_dtpoff_base (info
);
4058 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4059 because such sections are not SEC_ALLOC and thus ld.so will
4060 not process them. */
4061 if (unresolved_reloc
4062 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
4064 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4065 rel
->r_offset
) != (bfd_vma
) -1)
4070 sec
= h
->root
.u
.def
.section
;
4071 if ((info
->nocopyreloc
4072 || (eh
->def_protected
4073 && elf_has_no_copy_on_protected (h
->root
.u
.def
.section
->owner
)))
4074 && !(h
->root
.u
.def
.section
->flags
& SEC_CODE
))
4075 return elf_x86_64_need_pic (info
, input_bfd
, input_section
,
4076 h
, NULL
, NULL
, howto
);
4081 /* xgettext:c-format */
4082 (_("%pB(%pA+%#" PRIx64
"): "
4083 "unresolvable %s relocation against symbol `%s'"),
4086 (uint64_t) rel
->r_offset
,
4088 h
->root
.root
.string
);
4094 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4095 contents
, rel
->r_offset
,
4096 relocation
, rel
->r_addend
);
4098 check_relocation_error
:
4099 if (r
!= bfd_reloc_ok
)
4104 name
= h
->root
.root
.string
;
4107 name
= bfd_elf_string_from_elf_section (input_bfd
,
4108 symtab_hdr
->sh_link
,
4113 name
= bfd_section_name (sec
);
4116 if (r
== bfd_reloc_overflow
)
4118 if (converted_reloc
)
4120 info
->callbacks
->einfo
4121 (_("%F%P: failed to convert GOTPCREL relocation; relink with --no-relax\n"));
4124 (*info
->callbacks
->reloc_overflow
)
4125 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
4126 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
4131 /* xgettext:c-format */
4132 (_("%pB(%pA+%#" PRIx64
"): reloc against `%s': error %d"),
4133 input_bfd
, input_section
,
4134 (uint64_t) rel
->r_offset
, name
, (int) r
);
4145 Elf_Internal_Shdr
*rel_hdr
;
4146 size_t deleted
= rel
- wrel
;
4148 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
4149 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
4150 if (rel_hdr
->sh_size
== 0)
4152 /* It is too late to remove an empty reloc section. Leave
4154 ??? What is wrong with an empty section??? */
4155 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
4158 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
4159 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
4160 input_section
->reloc_count
-= deleted
;
4166 /* Finish up dynamic symbol handling. We set the contents of various
4167 dynamic sections here. */
4170 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
4171 struct bfd_link_info
*info
,
4172 struct elf_link_hash_entry
*h
,
4173 Elf_Internal_Sym
*sym
)
4175 struct elf_x86_link_hash_table
*htab
;
4176 bfd_boolean use_plt_second
;
4177 struct elf_x86_link_hash_entry
*eh
;
4178 bfd_boolean local_undefweak
;
4180 htab
= elf_x86_hash_table (info
, X86_64_ELF_DATA
);
4184 /* Use the second PLT section only if there is .plt section. */
4185 use_plt_second
= htab
->elf
.splt
!= NULL
&& htab
->plt_second
!= NULL
;
4187 eh
= (struct elf_x86_link_hash_entry
*) h
;
4188 if (eh
->no_finish_dynamic_symbol
)
4191 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
4192 resolved undefined weak symbols in executable so that their
4193 references have value 0 at run-time. */
4194 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
, eh
);
4196 if (h
->plt
.offset
!= (bfd_vma
) -1)
4199 bfd_vma got_offset
, plt_offset
;
4200 Elf_Internal_Rela rela
;
4202 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
4203 const struct elf_backend_data
*bed
;
4204 bfd_vma plt_got_pcrel_offset
;
4206 /* When building a static executable, use .iplt, .igot.plt and
4207 .rela.iplt sections for STT_GNU_IFUNC symbols. */
4208 if (htab
->elf
.splt
!= NULL
)
4210 plt
= htab
->elf
.splt
;
4211 gotplt
= htab
->elf
.sgotplt
;
4212 relplt
= htab
->elf
.srelplt
;
4216 plt
= htab
->elf
.iplt
;
4217 gotplt
= htab
->elf
.igotplt
;
4218 relplt
= htab
->elf
.irelplt
;
4221 VERIFY_PLT_ENTRY (info
, h
, plt
, gotplt
, relplt
, local_undefweak
)
4223 /* Get the index in the procedure linkage table which
4224 corresponds to this symbol. This is the index of this symbol
4225 in all the symbols for which we are making plt entries. The
4226 first entry in the procedure linkage table is reserved.
4228 Get the offset into the .got table of the entry that
4229 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
4230 bytes. The first three are reserved for the dynamic linker.
4232 For static executables, we don't reserve anything. */
4234 if (plt
== htab
->elf
.splt
)
4236 got_offset
= (h
->plt
.offset
/ htab
->plt
.plt_entry_size
4237 - htab
->plt
.has_plt0
);
4238 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
4242 got_offset
= h
->plt
.offset
/ htab
->plt
.plt_entry_size
;
4243 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
4246 /* Fill in the entry in the procedure linkage table. */
4247 memcpy (plt
->contents
+ h
->plt
.offset
, htab
->plt
.plt_entry
,
4248 htab
->plt
.plt_entry_size
);
4251 memcpy (htab
->plt_second
->contents
+ eh
->plt_second
.offset
,
4252 htab
->non_lazy_plt
->plt_entry
,
4253 htab
->non_lazy_plt
->plt_entry_size
);
4255 resolved_plt
= htab
->plt_second
;
4256 plt_offset
= eh
->plt_second
.offset
;
4261 plt_offset
= h
->plt
.offset
;
4264 /* Insert the relocation positions of the plt section. */
4266 /* Put offset the PC-relative instruction referring to the GOT entry,
4267 subtracting the size of that instruction. */
4268 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
4269 + gotplt
->output_offset
4271 - resolved_plt
->output_section
->vma
4272 - resolved_plt
->output_offset
4274 - htab
->plt
.plt_got_insn_size
);
4276 /* Check PC-relative offset overflow in PLT entry. */
4277 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
4278 /* xgettext:c-format */
4279 info
->callbacks
->einfo (_("%F%pB: PC-relative offset overflow in PLT entry for `%s'\n"),
4280 output_bfd
, h
->root
.root
.string
);
4282 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
4283 (resolved_plt
->contents
+ plt_offset
4284 + htab
->plt
.plt_got_offset
));
4286 /* Fill in the entry in the global offset table, initially this
4287 points to the second part of the PLT entry. Leave the entry
4288 as zero for undefined weak symbol in PIE. No PLT relocation
4289 against undefined weak symbol in PIE. */
4290 if (!local_undefweak
)
4292 if (htab
->plt
.has_plt0
)
4293 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
4294 + plt
->output_offset
4296 + htab
->lazy_plt
->plt_lazy_offset
),
4297 gotplt
->contents
+ got_offset
);
4299 /* Fill in the entry in the .rela.plt section. */
4300 rela
.r_offset
= (gotplt
->output_section
->vma
4301 + gotplt
->output_offset
4303 if (PLT_LOCAL_IFUNC_P (info
, h
))
4305 info
->callbacks
->minfo (_("Local IFUNC function `%s' in %pB\n"),
4306 h
->root
.root
.string
,
4307 h
->root
.u
.def
.section
->owner
);
4309 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4310 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
4311 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4312 rela
.r_addend
= (h
->root
.u
.def
.value
4313 + h
->root
.u
.def
.section
->output_section
->vma
4314 + h
->root
.u
.def
.section
->output_offset
);
4316 if (htab
->params
->report_relative_reloc
)
4317 _bfd_x86_elf_link_report_relative_reloc
4318 (info
, relplt
, h
, sym
, "R_X86_64_IRELATIVE", &rela
);
4320 /* R_X86_64_IRELATIVE comes last. */
4321 plt_index
= htab
->next_irelative_index
--;
4325 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
4327 plt_index
= htab
->next_jump_slot_index
++;
4330 /* Don't fill the second and third slots in PLT entry for
4331 static executables nor without PLT0. */
4332 if (plt
== htab
->elf
.splt
&& htab
->plt
.has_plt0
)
4335 = h
->plt
.offset
+ htab
->lazy_plt
->plt_plt_insn_end
;
4337 /* Put relocation index. */
4338 bfd_put_32 (output_bfd
, plt_index
,
4339 (plt
->contents
+ h
->plt
.offset
4340 + htab
->lazy_plt
->plt_reloc_offset
));
4342 /* Put offset for jmp .PLT0 and check for overflow. We don't
4343 check relocation index for overflow since branch displacement
4344 will overflow first. */
4345 if (plt0_offset
> 0x80000000)
4346 /* xgettext:c-format */
4347 info
->callbacks
->einfo (_("%F%pB: branch displacement overflow in PLT entry for `%s'\n"),
4348 output_bfd
, h
->root
.root
.string
);
4349 bfd_put_32 (output_bfd
, - plt0_offset
,
4350 (plt
->contents
+ h
->plt
.offset
4351 + htab
->lazy_plt
->plt_plt_offset
));
4354 bed
= get_elf_backend_data (output_bfd
);
4355 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
4356 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
4359 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
4361 bfd_vma got_offset
, plt_offset
;
4362 asection
*plt
, *got
;
4363 bfd_boolean got_after_plt
;
4364 int32_t got_pcrel_offset
;
4366 /* Set the entry in the GOT procedure linkage table. */
4367 plt
= htab
->plt_got
;
4368 got
= htab
->elf
.sgot
;
4369 got_offset
= h
->got
.offset
;
4371 if (got_offset
== (bfd_vma
) -1
4372 || (h
->type
== STT_GNU_IFUNC
&& h
->def_regular
)
4377 /* Use the non-lazy PLT entry template for the GOT PLT since they
4378 are the identical. */
4379 /* Fill in the entry in the GOT procedure linkage table. */
4380 plt_offset
= eh
->plt_got
.offset
;
4381 memcpy (plt
->contents
+ plt_offset
,
4382 htab
->non_lazy_plt
->plt_entry
,
4383 htab
->non_lazy_plt
->plt_entry_size
);
4385 /* Put offset the PC-relative instruction referring to the GOT
4386 entry, subtracting the size of that instruction. */
4387 got_pcrel_offset
= (got
->output_section
->vma
4388 + got
->output_offset
4390 - plt
->output_section
->vma
4391 - plt
->output_offset
4393 - htab
->non_lazy_plt
->plt_got_insn_size
);
4395 /* Check PC-relative offset overflow in GOT PLT entry. */
4396 got_after_plt
= got
->output_section
->vma
> plt
->output_section
->vma
;
4397 if ((got_after_plt
&& got_pcrel_offset
< 0)
4398 || (!got_after_plt
&& got_pcrel_offset
> 0))
4399 /* xgettext:c-format */
4400 info
->callbacks
->einfo (_("%F%pB: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
4401 output_bfd
, h
->root
.root
.string
);
4403 bfd_put_32 (output_bfd
, got_pcrel_offset
,
4404 (plt
->contents
+ plt_offset
4405 + htab
->non_lazy_plt
->plt_got_offset
));
4408 if (!local_undefweak
4410 && (h
->plt
.offset
!= (bfd_vma
) -1
4411 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
4413 /* Mark the symbol as undefined, rather than as defined in
4414 the .plt section. Leave the value if there were any
4415 relocations where pointer equality matters (this is a clue
4416 for the dynamic linker, to make function pointer
4417 comparisons work between an application and shared
4418 library), otherwise set it to zero. If a function is only
4419 called from a binary, there is no need to slow down
4420 shared libraries because of that. */
4421 sym
->st_shndx
= SHN_UNDEF
;
4422 if (!h
->pointer_equality_needed
)
4426 _bfd_x86_elf_link_fixup_ifunc_symbol (info
, htab
, h
, sym
);
4428 /* Don't generate dynamic GOT relocation against undefined weak
4429 symbol in executable. */
4430 if (h
->got
.offset
!= (bfd_vma
) -1
4431 && ! GOT_TLS_GD_ANY_P (elf_x86_hash_entry (h
)->tls_type
)
4432 && elf_x86_hash_entry (h
)->tls_type
!= GOT_TLS_IE
4433 && !local_undefweak
)
4435 Elf_Internal_Rela rela
;
4436 asection
*relgot
= htab
->elf
.srelgot
;
4437 const char *relative_reloc_name
= NULL
;
4439 /* This symbol has an entry in the global offset table. Set it
4441 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
4444 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4445 + htab
->elf
.sgot
->output_offset
4446 + (h
->got
.offset
&~ (bfd_vma
) 1));
4448 /* If this is a static link, or it is a -Bsymbolic link and the
4449 symbol is defined locally or was forced to be local because
4450 of a version file, we just want to emit a RELATIVE reloc.
4451 The entry in the global offset table will already have been
4452 initialized in the relocate_section function. */
4454 && h
->type
== STT_GNU_IFUNC
)
4456 if (h
->plt
.offset
== (bfd_vma
) -1)
4458 /* STT_GNU_IFUNC is referenced without PLT. */
4459 if (htab
->elf
.splt
== NULL
)
4461 /* use .rel[a].iplt section to store .got relocations
4462 in static executable. */
4463 relgot
= htab
->elf
.irelplt
;
4465 if (SYMBOL_REFERENCES_LOCAL_P (info
, h
))
4467 info
->callbacks
->minfo (_("Local IFUNC function `%s' in %pB\n"),
4468 h
->root
.root
.string
,
4469 h
->root
.u
.def
.section
->owner
);
4471 rela
.r_info
= htab
->r_info (0,
4472 R_X86_64_IRELATIVE
);
4473 rela
.r_addend
= (h
->root
.u
.def
.value
4474 + h
->root
.u
.def
.section
->output_section
->vma
4475 + h
->root
.u
.def
.section
->output_offset
);
4476 relative_reloc_name
= "R_X86_64_IRELATIVE";
4481 else if (bfd_link_pic (info
))
4483 /* Generate R_X86_64_GLOB_DAT. */
4491 if (!h
->pointer_equality_needed
)
4494 /* For non-shared object, we can't use .got.plt, which
4495 contains the real function addres if we need pointer
4496 equality. We load the GOT entry with the PLT entry. */
4497 if (htab
->plt_second
!= NULL
)
4499 plt
= htab
->plt_second
;
4500 plt_offset
= eh
->plt_second
.offset
;
4504 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
4505 plt_offset
= h
->plt
.offset
;
4507 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
4508 + plt
->output_offset
4510 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
4514 else if (bfd_link_pic (info
)
4515 && SYMBOL_REFERENCES_LOCAL_P (info
, h
))
4517 if (!SYMBOL_DEFINED_NON_SHARED_P (h
))
4519 BFD_ASSERT((h
->got
.offset
& 1) != 0);
4520 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4521 rela
.r_addend
= (h
->root
.u
.def
.value
4522 + h
->root
.u
.def
.section
->output_section
->vma
4523 + h
->root
.u
.def
.section
->output_offset
);
4524 relative_reloc_name
= "R_X86_64_RELATIVE";
4528 BFD_ASSERT((h
->got
.offset
& 1) == 0);
4530 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
4531 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
4532 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
4536 if (relative_reloc_name
!= NULL
4537 && htab
->params
->report_relative_reloc
)
4538 _bfd_x86_elf_link_report_relative_reloc
4539 (info
, relgot
, h
, sym
, relative_reloc_name
, &rela
);
4541 elf_append_rela (output_bfd
, relgot
, &rela
);
4546 Elf_Internal_Rela rela
;
4549 /* This symbol needs a copy reloc. Set it up. */
4550 VERIFY_COPY_RELOC (h
, htab
)
4552 rela
.r_offset
= (h
->root
.u
.def
.value
4553 + h
->root
.u
.def
.section
->output_section
->vma
4554 + h
->root
.u
.def
.section
->output_offset
);
4555 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
4557 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
4558 s
= htab
->elf
.sreldynrelro
;
4560 s
= htab
->elf
.srelbss
;
4561 elf_append_rela (output_bfd
, s
, &rela
);
4567 /* Finish up local dynamic symbol handling. We set the contents of
4568 various dynamic sections here. */
4571 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
4573 struct elf_link_hash_entry
*h
4574 = (struct elf_link_hash_entry
*) *slot
;
4575 struct bfd_link_info
*info
4576 = (struct bfd_link_info
*) inf
;
4578 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
4582 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
4583 here since undefined weak symbol may not be dynamic and may not be
4584 called for elf_x86_64_finish_dynamic_symbol. */
4587 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
4590 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
4591 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
4593 if (h
->root
.type
!= bfd_link_hash_undefweak
4594 || h
->dynindx
!= -1)
4597 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
4601 /* Used to decide how to sort relocs in an optimal manner for the
4602 dynamic linker, before writing them out. */
4604 static enum elf_reloc_type_class
4605 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info
,
4606 const asection
*rel_sec ATTRIBUTE_UNUSED
,
4607 const Elf_Internal_Rela
*rela
)
4609 bfd
*abfd
= info
->output_bfd
;
4610 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4611 struct elf_x86_link_hash_table
*htab
4612 = elf_x86_hash_table (info
, X86_64_ELF_DATA
);
4614 if (htab
->elf
.dynsym
!= NULL
4615 && htab
->elf
.dynsym
->contents
!= NULL
)
4617 /* Check relocation against STT_GNU_IFUNC symbol if there are
4619 unsigned long r_symndx
= htab
->r_sym (rela
->r_info
);
4620 if (r_symndx
!= STN_UNDEF
)
4622 Elf_Internal_Sym sym
;
4623 if (!bed
->s
->swap_symbol_in (abfd
,
4624 (htab
->elf
.dynsym
->contents
4625 + r_symndx
* bed
->s
->sizeof_sym
),
4629 if (ELF_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
4630 return reloc_class_ifunc
;
4634 switch ((int) ELF32_R_TYPE (rela
->r_info
))
4636 case R_X86_64_IRELATIVE
:
4637 return reloc_class_ifunc
;
4638 case R_X86_64_RELATIVE
:
4639 case R_X86_64_RELATIVE64
:
4640 return reloc_class_relative
;
4641 case R_X86_64_JUMP_SLOT
:
4642 return reloc_class_plt
;
4644 return reloc_class_copy
;
4646 return reloc_class_normal
;
4650 /* Finish up the dynamic sections. */
4653 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
4654 struct bfd_link_info
*info
)
4656 struct elf_x86_link_hash_table
*htab
;
4658 htab
= _bfd_x86_elf_finish_dynamic_sections (output_bfd
, info
);
4662 if (! htab
->elf
.dynamic_sections_created
)
4665 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
4667 elf_section_data (htab
->elf
.splt
->output_section
)
4668 ->this_hdr
.sh_entsize
= htab
->plt
.plt_entry_size
;
4670 if (htab
->plt
.has_plt0
)
4672 /* Fill in the special first entry in the procedure linkage
4674 memcpy (htab
->elf
.splt
->contents
,
4675 htab
->lazy_plt
->plt0_entry
,
4676 htab
->lazy_plt
->plt0_entry_size
);
4677 /* Add offset for pushq GOT+8(%rip), since the instruction
4678 uses 6 bytes subtract this value. */
4679 bfd_put_32 (output_bfd
,
4680 (htab
->elf
.sgotplt
->output_section
->vma
4681 + htab
->elf
.sgotplt
->output_offset
4683 - htab
->elf
.splt
->output_section
->vma
4684 - htab
->elf
.splt
->output_offset
4686 (htab
->elf
.splt
->contents
4687 + htab
->lazy_plt
->plt0_got1_offset
));
4688 /* Add offset for the PC-relative instruction accessing
4689 GOT+16, subtracting the offset to the end of that
4691 bfd_put_32 (output_bfd
,
4692 (htab
->elf
.sgotplt
->output_section
->vma
4693 + htab
->elf
.sgotplt
->output_offset
4695 - htab
->elf
.splt
->output_section
->vma
4696 - htab
->elf
.splt
->output_offset
4697 - htab
->lazy_plt
->plt0_got2_insn_end
),
4698 (htab
->elf
.splt
->contents
4699 + htab
->lazy_plt
->plt0_got2_offset
));
4702 if (htab
->elf
.tlsdesc_plt
)
4704 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
4705 htab
->elf
.sgot
->contents
+ htab
->elf
.tlsdesc_got
);
4707 memcpy (htab
->elf
.splt
->contents
+ htab
->elf
.tlsdesc_plt
,
4708 htab
->lazy_plt
->plt_tlsdesc_entry
,
4709 htab
->lazy_plt
->plt_tlsdesc_entry_size
);
4711 /* Add offset for pushq GOT+8(%rip), since ENDBR64 uses 4
4712 bytes and the instruction uses 6 bytes, subtract these
4714 bfd_put_32 (output_bfd
,
4715 (htab
->elf
.sgotplt
->output_section
->vma
4716 + htab
->elf
.sgotplt
->output_offset
4718 - htab
->elf
.splt
->output_section
->vma
4719 - htab
->elf
.splt
->output_offset
4720 - htab
->elf
.tlsdesc_plt
4721 - htab
->lazy_plt
->plt_tlsdesc_got1_insn_end
),
4722 (htab
->elf
.splt
->contents
4723 + htab
->elf
.tlsdesc_plt
4724 + htab
->lazy_plt
->plt_tlsdesc_got1_offset
));
4725 /* Add offset for indirect branch via GOT+TDG, where TDG
4726 stands for htab->tlsdesc_got, subtracting the offset
4727 to the end of that instruction. */
4728 bfd_put_32 (output_bfd
,
4729 (htab
->elf
.sgot
->output_section
->vma
4730 + htab
->elf
.sgot
->output_offset
4731 + htab
->elf
.tlsdesc_got
4732 - htab
->elf
.splt
->output_section
->vma
4733 - htab
->elf
.splt
->output_offset
4734 - htab
->elf
.tlsdesc_plt
4735 - htab
->lazy_plt
->plt_tlsdesc_got2_insn_end
),
4736 (htab
->elf
.splt
->contents
4737 + htab
->elf
.tlsdesc_plt
4738 + htab
->lazy_plt
->plt_tlsdesc_got2_offset
));
4742 /* Fill PLT entries for undefined weak symbols in PIE. */
4743 if (bfd_link_pie (info
))
4744 bfd_hash_traverse (&info
->hash
->table
,
4745 elf_x86_64_pie_finish_undefweak_symbol
,
4751 /* Fill PLT/GOT entries and allocate dynamic relocations for local
4752 STT_GNU_IFUNC symbols, which aren't in the ELF linker hash table.
4753 It has to be done before elf_link_sort_relocs is called so that
4754 dynamic relocations are properly sorted. */
4757 elf_x86_64_output_arch_local_syms
4758 (bfd
*output_bfd ATTRIBUTE_UNUSED
,
4759 struct bfd_link_info
*info
,
4760 void *flaginfo ATTRIBUTE_UNUSED
,
4761 int (*func
) (void *, const char *,
4764 struct elf_link_hash_entry
*) ATTRIBUTE_UNUSED
)
4766 struct elf_x86_link_hash_table
*htab
4767 = elf_x86_hash_table (info
, X86_64_ELF_DATA
);
4771 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
4772 htab_traverse (htab
->loc_hash_table
,
4773 elf_x86_64_finish_local_dynamic_symbol
,
4779 /* Similar to _bfd_elf_get_synthetic_symtab. Support PLTs with all
4780 dynamic relocations. */
4783 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
4784 long symcount ATTRIBUTE_UNUSED
,
4785 asymbol
**syms ATTRIBUTE_UNUSED
,
4792 bfd_byte
*plt_contents
;
4794 const struct elf_x86_lazy_plt_layout
*lazy_plt
;
4795 const struct elf_x86_non_lazy_plt_layout
*non_lazy_plt
;
4796 const struct elf_x86_lazy_plt_layout
*lazy_bnd_plt
;
4797 const struct elf_x86_non_lazy_plt_layout
*non_lazy_bnd_plt
;
4798 const struct elf_x86_lazy_plt_layout
*lazy_ibt_plt
;
4799 const struct elf_x86_non_lazy_plt_layout
*non_lazy_ibt_plt
;
4801 enum elf_x86_plt_type plt_type
;
4802 struct elf_x86_plt plts
[] =
4804 { ".plt", NULL
, NULL
, plt_unknown
, 0, 0, 0, 0 },
4805 { ".plt.got", NULL
, NULL
, plt_non_lazy
, 0, 0, 0, 0 },
4806 { ".plt.sec", NULL
, NULL
, plt_second
, 0, 0, 0, 0 },
4807 { ".plt.bnd", NULL
, NULL
, plt_second
, 0, 0, 0, 0 },
4808 { NULL
, NULL
, NULL
, plt_non_lazy
, 0, 0, 0, 0 }
4813 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
4816 if (dynsymcount
<= 0)
4819 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
4823 lazy_plt
= &elf_x86_64_lazy_plt
;
4824 non_lazy_plt
= &elf_x86_64_non_lazy_plt
;
4825 lazy_bnd_plt
= &elf_x86_64_lazy_bnd_plt
;
4826 non_lazy_bnd_plt
= &elf_x86_64_non_lazy_bnd_plt
;
4827 if (ABI_64_P (abfd
))
4829 lazy_ibt_plt
= &elf_x86_64_lazy_ibt_plt
;
4830 non_lazy_ibt_plt
= &elf_x86_64_non_lazy_ibt_plt
;
4834 lazy_ibt_plt
= &elf_x32_lazy_ibt_plt
;
4835 non_lazy_ibt_plt
= &elf_x32_non_lazy_ibt_plt
;
4839 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
4841 plt
= bfd_get_section_by_name (abfd
, plts
[j
].name
);
4842 if (plt
== NULL
|| plt
->size
== 0)
4845 /* Get the PLT section contents. */
4846 if (!bfd_malloc_and_get_section (abfd
, plt
, &plt_contents
))
4849 /* Check what kind of PLT it is. */
4850 plt_type
= plt_unknown
;
4851 if (plts
[j
].type
== plt_unknown
4852 && (plt
->size
>= (lazy_plt
->plt_entry_size
4853 + lazy_plt
->plt_entry_size
)))
4855 /* Match lazy PLT first. Need to check the first two
4857 if ((memcmp (plt_contents
, lazy_plt
->plt0_entry
,
4858 lazy_plt
->plt0_got1_offset
) == 0)
4859 && (memcmp (plt_contents
+ 6, lazy_plt
->plt0_entry
+ 6,
4861 plt_type
= plt_lazy
;
4862 else if (lazy_bnd_plt
!= NULL
4863 && (memcmp (plt_contents
, lazy_bnd_plt
->plt0_entry
,
4864 lazy_bnd_plt
->plt0_got1_offset
) == 0)
4865 && (memcmp (plt_contents
+ 6,
4866 lazy_bnd_plt
->plt0_entry
+ 6, 3) == 0))
4868 plt_type
= plt_lazy
| plt_second
;
4869 /* The fist entry in the lazy IBT PLT is the same as the
4871 if ((memcmp (plt_contents
+ lazy_ibt_plt
->plt_entry_size
,
4872 lazy_ibt_plt
->plt_entry
,
4873 lazy_ibt_plt
->plt_got_offset
) == 0))
4874 lazy_plt
= lazy_ibt_plt
;
4876 lazy_plt
= lazy_bnd_plt
;
4880 if (non_lazy_plt
!= NULL
4881 && (plt_type
== plt_unknown
|| plt_type
== plt_non_lazy
)
4882 && plt
->size
>= non_lazy_plt
->plt_entry_size
)
4884 /* Match non-lazy PLT. */
4885 if (memcmp (plt_contents
, non_lazy_plt
->plt_entry
,
4886 non_lazy_plt
->plt_got_offset
) == 0)
4887 plt_type
= plt_non_lazy
;
4890 if (plt_type
== plt_unknown
|| plt_type
== plt_second
)
4892 if (non_lazy_bnd_plt
!= NULL
4893 && plt
->size
>= non_lazy_bnd_plt
->plt_entry_size
4894 && (memcmp (plt_contents
, non_lazy_bnd_plt
->plt_entry
,
4895 non_lazy_bnd_plt
->plt_got_offset
) == 0))
4897 /* Match BND PLT. */
4898 plt_type
= plt_second
;
4899 non_lazy_plt
= non_lazy_bnd_plt
;
4901 else if (non_lazy_ibt_plt
!= NULL
4902 && plt
->size
>= non_lazy_ibt_plt
->plt_entry_size
4903 && (memcmp (plt_contents
,
4904 non_lazy_ibt_plt
->plt_entry
,
4905 non_lazy_ibt_plt
->plt_got_offset
) == 0))
4907 /* Match IBT PLT. */
4908 plt_type
= plt_second
;
4909 non_lazy_plt
= non_lazy_ibt_plt
;
4913 if (plt_type
== plt_unknown
)
4915 free (plt_contents
);
4920 plts
[j
].type
= plt_type
;
4922 if ((plt_type
& plt_lazy
))
4924 plts
[j
].plt_got_offset
= lazy_plt
->plt_got_offset
;
4925 plts
[j
].plt_got_insn_size
= lazy_plt
->plt_got_insn_size
;
4926 plts
[j
].plt_entry_size
= lazy_plt
->plt_entry_size
;
4927 /* Skip PLT0 in lazy PLT. */
4932 plts
[j
].plt_got_offset
= non_lazy_plt
->plt_got_offset
;
4933 plts
[j
].plt_got_insn_size
= non_lazy_plt
->plt_got_insn_size
;
4934 plts
[j
].plt_entry_size
= non_lazy_plt
->plt_entry_size
;
4938 /* Skip lazy PLT when the second PLT is used. */
4939 if (plt_type
== (plt_lazy
| plt_second
))
4943 n
= plt
->size
/ plts
[j
].plt_entry_size
;
4948 plts
[j
].contents
= plt_contents
;
4951 return _bfd_x86_elf_get_synthetic_symtab (abfd
, count
, relsize
,
4952 (bfd_vma
) 0, plts
, dynsyms
,
4956 /* Handle an x86-64 specific section when reading an object file. This
4957 is called when elfcode.h finds a section with an unknown type. */
4960 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
4961 const char *name
, int shindex
)
4963 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
4966 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
4972 /* Hook called by the linker routine which adds symbols from an object
4973 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
4977 elf_x86_64_add_symbol_hook (bfd
*abfd
,
4978 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4979 Elf_Internal_Sym
*sym
,
4980 const char **namep ATTRIBUTE_UNUSED
,
4981 flagword
*flagsp ATTRIBUTE_UNUSED
,
4987 switch (sym
->st_shndx
)
4989 case SHN_X86_64_LCOMMON
:
4990 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
4993 lcomm
= bfd_make_section_with_flags (abfd
,
4997 | SEC_LINKER_CREATED
));
5000 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
5003 *valp
= sym
->st_size
;
5011 /* Given a BFD section, try to locate the corresponding ELF section
5015 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
5016 asection
*sec
, int *index_return
)
5018 if (sec
== &_bfd_elf_large_com_section
)
5020 *index_return
= SHN_X86_64_LCOMMON
;
5026 /* Process a symbol. */
5029 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
5032 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
5034 switch (elfsym
->internal_elf_sym
.st_shndx
)
5036 case SHN_X86_64_LCOMMON
:
5037 asym
->section
= &_bfd_elf_large_com_section
;
5038 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
5039 /* Common symbol doesn't set BSF_GLOBAL. */
5040 asym
->flags
&= ~BSF_GLOBAL
;
5046 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
5048 return (sym
->st_shndx
== SHN_COMMON
5049 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
5053 elf_x86_64_common_section_index (asection
*sec
)
5055 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
5058 return SHN_X86_64_LCOMMON
;
5062 elf_x86_64_common_section (asection
*sec
)
5064 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
5065 return bfd_com_section_ptr
;
5067 return &_bfd_elf_large_com_section
;
5071 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
5072 const Elf_Internal_Sym
*sym
,
5077 const asection
*oldsec
)
5079 /* A normal common symbol and a large common symbol result in a
5080 normal common symbol. We turn the large common symbol into a
5083 && h
->root
.type
== bfd_link_hash_common
5085 && bfd_is_com_section (*psec
)
5088 if (sym
->st_shndx
== SHN_COMMON
5089 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
5091 h
->root
.u
.c
.p
->section
5092 = bfd_make_section_old_way (oldbfd
, "COMMON");
5093 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
5095 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
5096 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
5097 *psec
= bfd_com_section_ptr
;
5104 elf_x86_64_additional_program_headers (bfd
*abfd
,
5105 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
5110 /* Check to see if we need a large readonly segment. */
5111 s
= bfd_get_section_by_name (abfd
, ".lrodata");
5112 if (s
&& (s
->flags
& SEC_LOAD
))
5115 /* Check to see if we need a large data segment. Since .lbss sections
5116 is placed right after the .bss section, there should be no need for
5117 a large data segment just because of .lbss. */
5118 s
= bfd_get_section_by_name (abfd
, ".ldata");
5119 if (s
&& (s
->flags
& SEC_LOAD
))
5125 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
5128 elf_x86_64_relocs_compatible (const bfd_target
*input
,
5129 const bfd_target
*output
)
5131 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
5132 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
5133 && _bfd_elf_relocs_compatible (input
, output
));
5136 /* Set up x86-64 GNU properties. Return the first relocatable ELF input
5137 with GNU properties if found. Otherwise, return NULL. */
5140 elf_x86_64_link_setup_gnu_properties (struct bfd_link_info
*info
)
5142 struct elf_x86_init_table init_table
;
5143 const struct elf_backend_data
*bed
;
5144 struct elf_x86_link_hash_table
*htab
;
5146 if ((int) R_X86_64_standard
>= (int) R_X86_64_converted_reloc_bit
5147 || (int) R_X86_64_max
<= (int) R_X86_64_converted_reloc_bit
5148 || ((int) (R_X86_64_GNU_VTINHERIT
| R_X86_64_converted_reloc_bit
)
5149 != (int) R_X86_64_GNU_VTINHERIT
)
5150 || ((int) (R_X86_64_GNU_VTENTRY
| R_X86_64_converted_reloc_bit
)
5151 != (int) R_X86_64_GNU_VTENTRY
))
5154 /* This is unused for x86-64. */
5155 init_table
.plt0_pad_byte
= 0x90;
5157 bed
= get_elf_backend_data (info
->output_bfd
);
5158 htab
= elf_x86_hash_table (info
, bed
->target_id
);
5161 if (htab
->params
->bndplt
)
5163 init_table
.lazy_plt
= &elf_x86_64_lazy_bnd_plt
;
5164 init_table
.non_lazy_plt
= &elf_x86_64_non_lazy_bnd_plt
;
5168 init_table
.lazy_plt
= &elf_x86_64_lazy_plt
;
5169 init_table
.non_lazy_plt
= &elf_x86_64_non_lazy_plt
;
5172 if (ABI_64_P (info
->output_bfd
))
5174 init_table
.lazy_ibt_plt
= &elf_x86_64_lazy_ibt_plt
;
5175 init_table
.non_lazy_ibt_plt
= &elf_x86_64_non_lazy_ibt_plt
;
5179 init_table
.lazy_ibt_plt
= &elf_x32_lazy_ibt_plt
;
5180 init_table
.non_lazy_ibt_plt
= &elf_x32_non_lazy_ibt_plt
;
5183 if (ABI_64_P (info
->output_bfd
))
5185 init_table
.r_info
= elf64_r_info
;
5186 init_table
.r_sym
= elf64_r_sym
;
5190 init_table
.r_info
= elf32_r_info
;
5191 init_table
.r_sym
= elf32_r_sym
;
5194 return _bfd_x86_elf_link_setup_gnu_properties (info
, &init_table
);
5197 static const struct bfd_elf_special_section
5198 elf_x86_64_special_sections
[]=
5200 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5201 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
5202 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
5203 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5204 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5205 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
5206 { NULL
, 0, 0, 0, 0 }
5209 #define TARGET_LITTLE_SYM x86_64_elf64_vec
5210 #define TARGET_LITTLE_NAME "elf64-x86-64"
5211 #define ELF_ARCH bfd_arch_i386
5212 #define ELF_TARGET_ID X86_64_ELF_DATA
5213 #define ELF_MACHINE_CODE EM_X86_64
5214 #if DEFAULT_LD_Z_SEPARATE_CODE
5215 # define ELF_MAXPAGESIZE 0x1000
5217 # define ELF_MAXPAGESIZE 0x200000
5219 #define ELF_MINPAGESIZE 0x1000
5220 #define ELF_COMMONPAGESIZE 0x1000
5222 #define elf_backend_can_gc_sections 1
5223 #define elf_backend_can_refcount 1
5224 #define elf_backend_want_got_plt 1
5225 #define elf_backend_plt_readonly 1
5226 #define elf_backend_want_plt_sym 0
5227 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
5228 #define elf_backend_rela_normal 1
5229 #define elf_backend_plt_alignment 4
5230 #define elf_backend_extern_protected_data 1
5231 #define elf_backend_caches_rawsize 1
5232 #define elf_backend_dtrel_excludes_plt 1
5233 #define elf_backend_want_dynrelro 1
5235 #define elf_info_to_howto elf_x86_64_info_to_howto
5237 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
5238 #define bfd_elf64_bfd_reloc_name_lookup \
5239 elf_x86_64_reloc_name_lookup
5241 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
5242 #define elf_backend_check_relocs elf_x86_64_check_relocs
5243 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
5244 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
5245 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
5246 #define elf_backend_output_arch_local_syms elf_x86_64_output_arch_local_syms
5247 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
5248 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
5250 #define elf_backend_write_core_note elf_x86_64_write_core_note
5252 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
5253 #define elf_backend_relocate_section elf_x86_64_relocate_section
5254 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
5255 #define elf_backend_object_p elf64_x86_64_elf_object_p
5256 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
5258 #define elf_backend_section_from_shdr \
5259 elf_x86_64_section_from_shdr
5261 #define elf_backend_section_from_bfd_section \
5262 elf_x86_64_elf_section_from_bfd_section
5263 #define elf_backend_add_symbol_hook \
5264 elf_x86_64_add_symbol_hook
5265 #define elf_backend_symbol_processing \
5266 elf_x86_64_symbol_processing
5267 #define elf_backend_common_section_index \
5268 elf_x86_64_common_section_index
5269 #define elf_backend_common_section \
5270 elf_x86_64_common_section
5271 #define elf_backend_common_definition \
5272 elf_x86_64_common_definition
5273 #define elf_backend_merge_symbol \
5274 elf_x86_64_merge_symbol
5275 #define elf_backend_special_sections \
5276 elf_x86_64_special_sections
5277 #define elf_backend_additional_program_headers \
5278 elf_x86_64_additional_program_headers
5279 #define elf_backend_setup_gnu_properties \
5280 elf_x86_64_link_setup_gnu_properties
5281 #define elf_backend_hide_symbol \
5282 _bfd_x86_elf_hide_symbol
5285 #define elf64_bed elf64_x86_64_bed
5287 #include "elf64-target.h"
5289 /* CloudABI support. */
5291 #undef TARGET_LITTLE_SYM
5292 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
5293 #undef TARGET_LITTLE_NAME
5294 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
5297 #define ELF_OSABI ELFOSABI_CLOUDABI
5300 #define elf64_bed elf64_x86_64_cloudabi_bed
5302 #include "elf64-target.h"
5304 /* FreeBSD support. */
5306 #undef TARGET_LITTLE_SYM
5307 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
5308 #undef TARGET_LITTLE_NAME
5309 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
5312 #define ELF_OSABI ELFOSABI_FREEBSD
5315 #define elf64_bed elf64_x86_64_fbsd_bed
5317 #include "elf64-target.h"
5319 /* Solaris 2 support. */
5321 #undef TARGET_LITTLE_SYM
5322 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
5323 #undef TARGET_LITTLE_NAME
5324 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
5326 #undef ELF_TARGET_OS
5327 #define ELF_TARGET_OS is_solaris
5329 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5330 objects won't be recognized. */
5334 #define elf64_bed elf64_x86_64_sol2_bed
5336 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
5338 #undef elf_backend_static_tls_alignment
5339 #define elf_backend_static_tls_alignment 16
5341 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5343 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5345 #undef elf_backend_want_plt_sym
5346 #define elf_backend_want_plt_sym 1
5348 #undef elf_backend_strtab_flags
5349 #define elf_backend_strtab_flags SHF_STRINGS
5352 elf64_x86_64_copy_solaris_special_section_fields (const bfd
*ibfd ATTRIBUTE_UNUSED
,
5353 bfd
*obfd ATTRIBUTE_UNUSED
,
5354 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
5355 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
5357 /* PR 19938: FIXME: Need to add code for setting the sh_info
5358 and sh_link fields of Solaris specific section types. */
5362 #undef elf_backend_copy_special_section_fields
5363 #define elf_backend_copy_special_section_fields elf64_x86_64_copy_solaris_special_section_fields
5365 #include "elf64-target.h"
5367 /* Restore defaults. */
5369 #undef elf_backend_static_tls_alignment
5370 #undef elf_backend_want_plt_sym
5371 #define elf_backend_want_plt_sym 0
5372 #undef elf_backend_strtab_flags
5373 #undef elf_backend_copy_special_section_fields
5375 /* Intel L1OM support. */
5378 elf64_l1om_elf_object_p (bfd
*abfd
)
5380 /* Set the right machine number for an L1OM elf64 file. */
5381 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
5385 #undef TARGET_LITTLE_SYM
5386 #define TARGET_LITTLE_SYM l1om_elf64_vec
5387 #undef TARGET_LITTLE_NAME
5388 #define TARGET_LITTLE_NAME "elf64-l1om"
5390 #define ELF_ARCH bfd_arch_l1om
5392 #undef ELF_MACHINE_CODE
5393 #define ELF_MACHINE_CODE EM_L1OM
5398 #define elf64_bed elf64_l1om_bed
5400 #undef elf_backend_object_p
5401 #define elf_backend_object_p elf64_l1om_elf_object_p
5403 /* Restore defaults. */
5404 #undef ELF_MAXPAGESIZE
5405 #undef ELF_MINPAGESIZE
5406 #undef ELF_COMMONPAGESIZE
5407 #if DEFAULT_LD_Z_SEPARATE_CODE
5408 # define ELF_MAXPAGESIZE 0x1000
5410 # define ELF_MAXPAGESIZE 0x200000
5412 #define ELF_MINPAGESIZE 0x1000
5413 #define ELF_COMMONPAGESIZE 0x1000
5414 #undef elf_backend_plt_alignment
5415 #define elf_backend_plt_alignment 4
5416 #undef ELF_TARGET_OS
5418 #include "elf64-target.h"
5420 /* FreeBSD L1OM support. */
5422 #undef TARGET_LITTLE_SYM
5423 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
5424 #undef TARGET_LITTLE_NAME
5425 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
5428 #define ELF_OSABI ELFOSABI_FREEBSD
5431 #define elf64_bed elf64_l1om_fbsd_bed
5433 #include "elf64-target.h"
5435 /* Intel K1OM support. */
5438 elf64_k1om_elf_object_p (bfd
*abfd
)
5440 /* Set the right machine number for an K1OM elf64 file. */
5441 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
5445 #undef TARGET_LITTLE_SYM
5446 #define TARGET_LITTLE_SYM k1om_elf64_vec
5447 #undef TARGET_LITTLE_NAME
5448 #define TARGET_LITTLE_NAME "elf64-k1om"
5450 #define ELF_ARCH bfd_arch_k1om
5452 #undef ELF_MACHINE_CODE
5453 #define ELF_MACHINE_CODE EM_K1OM
5458 #define elf64_bed elf64_k1om_bed
5460 #undef elf_backend_object_p
5461 #define elf_backend_object_p elf64_k1om_elf_object_p
5463 #include "elf64-target.h"
5465 /* FreeBSD K1OM support. */
5467 #undef TARGET_LITTLE_SYM
5468 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
5469 #undef TARGET_LITTLE_NAME
5470 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
5473 #define ELF_OSABI ELFOSABI_FREEBSD
5476 #define elf64_bed elf64_k1om_fbsd_bed
5478 #include "elf64-target.h"
5480 /* 32bit x86-64 support. */
5482 #undef TARGET_LITTLE_SYM
5483 #define TARGET_LITTLE_SYM x86_64_elf32_vec
5484 #undef TARGET_LITTLE_NAME
5485 #define TARGET_LITTLE_NAME "elf32-x86-64"
5487 #define elf32_bed elf32_x86_64_bed
5490 #define ELF_ARCH bfd_arch_i386
5492 #undef ELF_MACHINE_CODE
5493 #define ELF_MACHINE_CODE EM_X86_64
5497 #define bfd_elf32_bfd_reloc_type_lookup \
5498 elf_x86_64_reloc_type_lookup
5499 #define bfd_elf32_bfd_reloc_name_lookup \
5500 elf_x86_64_reloc_name_lookup
5501 #define bfd_elf32_get_synthetic_symtab \
5502 elf_x86_64_get_synthetic_symtab
5504 #undef elf_backend_object_p
5505 #define elf_backend_object_p \
5506 elf32_x86_64_elf_object_p
5508 #undef elf_backend_bfd_from_remote_memory
5509 #define elf_backend_bfd_from_remote_memory \
5510 _bfd_elf32_bfd_from_remote_memory
5512 #undef elf_backend_size_info
5513 #define elf_backend_size_info \
5514 _bfd_elf32_size_info
5516 #include "elf32-target.h"