1 /* X86-64 specific support for ELF
2 Copyright (C) 2000-2017 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"
25 #include "libiberty.h"
27 #include "opcode/i386.h"
28 #include "elf/x86-64.h"
35 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
36 #define MINUS_ONE (~ (bfd_vma) 0)
38 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
39 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
40 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
41 since they are the same. */
43 /* The relocation "howto" table. Order of fields:
44 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
45 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
46 static reloc_howto_type x86_64_elf_howto_table
[] =
48 HOWTO(R_X86_64_NONE
, 0, 3, 0, FALSE
, 0, complain_overflow_dont
,
49 bfd_elf_generic_reloc
, "R_X86_64_NONE", FALSE
, 0x00000000, 0x00000000,
51 HOWTO(R_X86_64_64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
52 bfd_elf_generic_reloc
, "R_X86_64_64", FALSE
, MINUS_ONE
, MINUS_ONE
,
54 HOWTO(R_X86_64_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
55 bfd_elf_generic_reloc
, "R_X86_64_PC32", FALSE
, 0xffffffff, 0xffffffff,
57 HOWTO(R_X86_64_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
58 bfd_elf_generic_reloc
, "R_X86_64_GOT32", FALSE
, 0xffffffff, 0xffffffff,
60 HOWTO(R_X86_64_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
61 bfd_elf_generic_reloc
, "R_X86_64_PLT32", FALSE
, 0xffffffff, 0xffffffff,
63 HOWTO(R_X86_64_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
64 bfd_elf_generic_reloc
, "R_X86_64_COPY", FALSE
, 0xffffffff, 0xffffffff,
66 HOWTO(R_X86_64_GLOB_DAT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
67 bfd_elf_generic_reloc
, "R_X86_64_GLOB_DAT", FALSE
, MINUS_ONE
,
69 HOWTO(R_X86_64_JUMP_SLOT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
70 bfd_elf_generic_reloc
, "R_X86_64_JUMP_SLOT", FALSE
, MINUS_ONE
,
72 HOWTO(R_X86_64_RELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
73 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE", FALSE
, MINUS_ONE
,
75 HOWTO(R_X86_64_GOTPCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
76 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL", FALSE
, 0xffffffff,
78 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
79 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
81 HOWTO(R_X86_64_32S
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
82 bfd_elf_generic_reloc
, "R_X86_64_32S", FALSE
, 0xffffffff, 0xffffffff,
84 HOWTO(R_X86_64_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
85 bfd_elf_generic_reloc
, "R_X86_64_16", FALSE
, 0xffff, 0xffff, FALSE
),
86 HOWTO(R_X86_64_PC16
,0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
87 bfd_elf_generic_reloc
, "R_X86_64_PC16", FALSE
, 0xffff, 0xffff, TRUE
),
88 HOWTO(R_X86_64_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
89 bfd_elf_generic_reloc
, "R_X86_64_8", FALSE
, 0xff, 0xff, FALSE
),
90 HOWTO(R_X86_64_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
91 bfd_elf_generic_reloc
, "R_X86_64_PC8", FALSE
, 0xff, 0xff, TRUE
),
92 HOWTO(R_X86_64_DTPMOD64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
93 bfd_elf_generic_reloc
, "R_X86_64_DTPMOD64", FALSE
, MINUS_ONE
,
95 HOWTO(R_X86_64_DTPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
96 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF64", FALSE
, MINUS_ONE
,
98 HOWTO(R_X86_64_TPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
99 bfd_elf_generic_reloc
, "R_X86_64_TPOFF64", FALSE
, MINUS_ONE
,
101 HOWTO(R_X86_64_TLSGD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
102 bfd_elf_generic_reloc
, "R_X86_64_TLSGD", FALSE
, 0xffffffff,
104 HOWTO(R_X86_64_TLSLD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
105 bfd_elf_generic_reloc
, "R_X86_64_TLSLD", FALSE
, 0xffffffff,
107 HOWTO(R_X86_64_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
108 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF32", FALSE
, 0xffffffff,
110 HOWTO(R_X86_64_GOTTPOFF
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
111 bfd_elf_generic_reloc
, "R_X86_64_GOTTPOFF", FALSE
, 0xffffffff,
113 HOWTO(R_X86_64_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
114 bfd_elf_generic_reloc
, "R_X86_64_TPOFF32", FALSE
, 0xffffffff,
116 HOWTO(R_X86_64_PC64
, 0, 4, 64, TRUE
, 0, complain_overflow_bitfield
,
117 bfd_elf_generic_reloc
, "R_X86_64_PC64", FALSE
, MINUS_ONE
, MINUS_ONE
,
119 HOWTO(R_X86_64_GOTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
120 bfd_elf_generic_reloc
, "R_X86_64_GOTOFF64",
121 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
122 HOWTO(R_X86_64_GOTPC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
123 bfd_elf_generic_reloc
, "R_X86_64_GOTPC32",
124 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
125 HOWTO(R_X86_64_GOT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
126 bfd_elf_generic_reloc
, "R_X86_64_GOT64", FALSE
, MINUS_ONE
, MINUS_ONE
,
128 HOWTO(R_X86_64_GOTPCREL64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
129 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL64", FALSE
, MINUS_ONE
,
131 HOWTO(R_X86_64_GOTPC64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
132 bfd_elf_generic_reloc
, "R_X86_64_GOTPC64",
133 FALSE
, MINUS_ONE
, MINUS_ONE
, TRUE
),
134 HOWTO(R_X86_64_GOTPLT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
135 bfd_elf_generic_reloc
, "R_X86_64_GOTPLT64", FALSE
, MINUS_ONE
,
137 HOWTO(R_X86_64_PLTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
138 bfd_elf_generic_reloc
, "R_X86_64_PLTOFF64", FALSE
, MINUS_ONE
,
140 HOWTO(R_X86_64_SIZE32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
141 bfd_elf_generic_reloc
, "R_X86_64_SIZE32", FALSE
, 0xffffffff, 0xffffffff,
143 HOWTO(R_X86_64_SIZE64
, 0, 4, 64, FALSE
, 0, complain_overflow_unsigned
,
144 bfd_elf_generic_reloc
, "R_X86_64_SIZE64", FALSE
, MINUS_ONE
, MINUS_ONE
,
146 HOWTO(R_X86_64_GOTPC32_TLSDESC
, 0, 2, 32, TRUE
, 0,
147 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
148 "R_X86_64_GOTPC32_TLSDESC",
149 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
150 HOWTO(R_X86_64_TLSDESC_CALL
, 0, 0, 0, FALSE
, 0,
151 complain_overflow_dont
, bfd_elf_generic_reloc
,
152 "R_X86_64_TLSDESC_CALL",
154 HOWTO(R_X86_64_TLSDESC
, 0, 4, 64, FALSE
, 0,
155 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
157 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
158 HOWTO(R_X86_64_IRELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
159 bfd_elf_generic_reloc
, "R_X86_64_IRELATIVE", FALSE
, MINUS_ONE
,
161 HOWTO(R_X86_64_RELATIVE64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
162 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE64", FALSE
, MINUS_ONE
,
164 HOWTO(R_X86_64_PC32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
165 bfd_elf_generic_reloc
, "R_X86_64_PC32_BND", FALSE
, 0xffffffff, 0xffffffff,
167 HOWTO(R_X86_64_PLT32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
168 bfd_elf_generic_reloc
, "R_X86_64_PLT32_BND", FALSE
, 0xffffffff, 0xffffffff,
170 HOWTO(R_X86_64_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
171 bfd_elf_generic_reloc
, "R_X86_64_GOTPCRELX", FALSE
, 0xffffffff,
173 HOWTO(R_X86_64_REX_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
174 bfd_elf_generic_reloc
, "R_X86_64_REX_GOTPCRELX", FALSE
, 0xffffffff,
177 /* We have a gap in the reloc numbers here.
178 R_X86_64_standard counts the number up to this point, and
179 R_X86_64_vt_offset is the value to subtract from a reloc type of
180 R_X86_64_GNU_VT* to form an index into this table. */
181 #define R_X86_64_standard (R_X86_64_REX_GOTPCRELX + 1)
182 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
184 /* GNU extension to record C++ vtable hierarchy. */
185 HOWTO (R_X86_64_GNU_VTINHERIT
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
186 NULL
, "R_X86_64_GNU_VTINHERIT", FALSE
, 0, 0, FALSE
),
188 /* GNU extension to record C++ vtable member usage. */
189 HOWTO (R_X86_64_GNU_VTENTRY
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
190 _bfd_elf_rel_vtable_reloc_fn
, "R_X86_64_GNU_VTENTRY", FALSE
, 0, 0,
193 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
194 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
195 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
199 #define IS_X86_64_PCREL_TYPE(TYPE) \
200 ( ((TYPE) == R_X86_64_PC8) \
201 || ((TYPE) == R_X86_64_PC16) \
202 || ((TYPE) == R_X86_64_PC32) \
203 || ((TYPE) == R_X86_64_PC32_BND) \
204 || ((TYPE) == R_X86_64_PC64))
206 /* Map BFD relocs to the x86_64 elf relocs. */
209 bfd_reloc_code_real_type bfd_reloc_val
;
210 unsigned char elf_reloc_val
;
213 static const struct elf_reloc_map x86_64_reloc_map
[] =
215 { BFD_RELOC_NONE
, R_X86_64_NONE
, },
216 { BFD_RELOC_64
, R_X86_64_64
, },
217 { BFD_RELOC_32_PCREL
, R_X86_64_PC32
, },
218 { BFD_RELOC_X86_64_GOT32
, R_X86_64_GOT32
,},
219 { BFD_RELOC_X86_64_PLT32
, R_X86_64_PLT32
,},
220 { BFD_RELOC_X86_64_COPY
, R_X86_64_COPY
, },
221 { BFD_RELOC_X86_64_GLOB_DAT
, R_X86_64_GLOB_DAT
, },
222 { BFD_RELOC_X86_64_JUMP_SLOT
, R_X86_64_JUMP_SLOT
, },
223 { BFD_RELOC_X86_64_RELATIVE
, R_X86_64_RELATIVE
, },
224 { BFD_RELOC_X86_64_GOTPCREL
, R_X86_64_GOTPCREL
, },
225 { BFD_RELOC_32
, R_X86_64_32
, },
226 { BFD_RELOC_X86_64_32S
, R_X86_64_32S
, },
227 { BFD_RELOC_16
, R_X86_64_16
, },
228 { BFD_RELOC_16_PCREL
, R_X86_64_PC16
, },
229 { BFD_RELOC_8
, R_X86_64_8
, },
230 { BFD_RELOC_8_PCREL
, R_X86_64_PC8
, },
231 { BFD_RELOC_X86_64_DTPMOD64
, R_X86_64_DTPMOD64
, },
232 { BFD_RELOC_X86_64_DTPOFF64
, R_X86_64_DTPOFF64
, },
233 { BFD_RELOC_X86_64_TPOFF64
, R_X86_64_TPOFF64
, },
234 { BFD_RELOC_X86_64_TLSGD
, R_X86_64_TLSGD
, },
235 { BFD_RELOC_X86_64_TLSLD
, R_X86_64_TLSLD
, },
236 { BFD_RELOC_X86_64_DTPOFF32
, R_X86_64_DTPOFF32
, },
237 { BFD_RELOC_X86_64_GOTTPOFF
, R_X86_64_GOTTPOFF
, },
238 { BFD_RELOC_X86_64_TPOFF32
, R_X86_64_TPOFF32
, },
239 { BFD_RELOC_64_PCREL
, R_X86_64_PC64
, },
240 { BFD_RELOC_X86_64_GOTOFF64
, R_X86_64_GOTOFF64
, },
241 { BFD_RELOC_X86_64_GOTPC32
, R_X86_64_GOTPC32
, },
242 { BFD_RELOC_X86_64_GOT64
, R_X86_64_GOT64
, },
243 { BFD_RELOC_X86_64_GOTPCREL64
,R_X86_64_GOTPCREL64
, },
244 { BFD_RELOC_X86_64_GOTPC64
, R_X86_64_GOTPC64
, },
245 { BFD_RELOC_X86_64_GOTPLT64
, R_X86_64_GOTPLT64
, },
246 { BFD_RELOC_X86_64_PLTOFF64
, R_X86_64_PLTOFF64
, },
247 { BFD_RELOC_SIZE32
, R_X86_64_SIZE32
, },
248 { BFD_RELOC_SIZE64
, R_X86_64_SIZE64
, },
249 { BFD_RELOC_X86_64_GOTPC32_TLSDESC
, R_X86_64_GOTPC32_TLSDESC
, },
250 { BFD_RELOC_X86_64_TLSDESC_CALL
, R_X86_64_TLSDESC_CALL
, },
251 { BFD_RELOC_X86_64_TLSDESC
, R_X86_64_TLSDESC
, },
252 { BFD_RELOC_X86_64_IRELATIVE
, R_X86_64_IRELATIVE
, },
253 { BFD_RELOC_X86_64_PC32_BND
, R_X86_64_PC32_BND
, },
254 { BFD_RELOC_X86_64_PLT32_BND
, R_X86_64_PLT32_BND
, },
255 { BFD_RELOC_X86_64_GOTPCRELX
, R_X86_64_GOTPCRELX
, },
256 { BFD_RELOC_X86_64_REX_GOTPCRELX
, R_X86_64_REX_GOTPCRELX
, },
257 { BFD_RELOC_VTABLE_INHERIT
, R_X86_64_GNU_VTINHERIT
, },
258 { BFD_RELOC_VTABLE_ENTRY
, R_X86_64_GNU_VTENTRY
, },
261 static reloc_howto_type
*
262 elf_x86_64_rtype_to_howto (bfd
*abfd
, unsigned r_type
)
266 if (r_type
== (unsigned int) R_X86_64_32
)
271 i
= ARRAY_SIZE (x86_64_elf_howto_table
) - 1;
273 else if (r_type
< (unsigned int) R_X86_64_GNU_VTINHERIT
274 || r_type
>= (unsigned int) R_X86_64_max
)
276 if (r_type
>= (unsigned int) R_X86_64_standard
)
278 /* xgettext:c-format */
279 _bfd_error_handler (_("%B: invalid relocation type %d"),
281 r_type
= R_X86_64_NONE
;
286 i
= r_type
- (unsigned int) R_X86_64_vt_offset
;
287 BFD_ASSERT (x86_64_elf_howto_table
[i
].type
== r_type
);
288 return &x86_64_elf_howto_table
[i
];
291 /* Given a BFD reloc type, return a HOWTO structure. */
292 static reloc_howto_type
*
293 elf_x86_64_reloc_type_lookup (bfd
*abfd
,
294 bfd_reloc_code_real_type code
)
298 for (i
= 0; i
< sizeof (x86_64_reloc_map
) / sizeof (struct elf_reloc_map
);
301 if (x86_64_reloc_map
[i
].bfd_reloc_val
== code
)
302 return elf_x86_64_rtype_to_howto (abfd
,
303 x86_64_reloc_map
[i
].elf_reloc_val
);
308 static reloc_howto_type
*
309 elf_x86_64_reloc_name_lookup (bfd
*abfd
,
314 if (!ABI_64_P (abfd
) && strcasecmp (r_name
, "R_X86_64_32") == 0)
316 /* Get x32 R_X86_64_32. */
317 reloc_howto_type
*reloc
318 = &x86_64_elf_howto_table
[ARRAY_SIZE (x86_64_elf_howto_table
) - 1];
319 BFD_ASSERT (reloc
->type
== (unsigned int) R_X86_64_32
);
323 for (i
= 0; i
< ARRAY_SIZE (x86_64_elf_howto_table
); i
++)
324 if (x86_64_elf_howto_table
[i
].name
!= NULL
325 && strcasecmp (x86_64_elf_howto_table
[i
].name
, r_name
) == 0)
326 return &x86_64_elf_howto_table
[i
];
331 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
334 elf_x86_64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
335 Elf_Internal_Rela
*dst
)
339 r_type
= ELF32_R_TYPE (dst
->r_info
);
340 cache_ptr
->howto
= elf_x86_64_rtype_to_howto (abfd
, r_type
);
341 BFD_ASSERT (r_type
== cache_ptr
->howto
->type
);
344 /* Support for core dump NOTE sections. */
346 elf_x86_64_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
351 switch (note
->descsz
)
356 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
358 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
361 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
369 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
371 elf_tdata (abfd
)->core
->signal
372 = bfd_get_16 (abfd
, note
->descdata
+ 12);
375 elf_tdata (abfd
)->core
->lwpid
376 = bfd_get_32 (abfd
, note
->descdata
+ 32);
385 /* Make a ".reg/999" section. */
386 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
387 size
, note
->descpos
+ offset
);
391 elf_x86_64_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
393 switch (note
->descsz
)
398 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
399 elf_tdata (abfd
)->core
->pid
400 = bfd_get_32 (abfd
, note
->descdata
+ 12);
401 elf_tdata (abfd
)->core
->program
402 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
403 elf_tdata (abfd
)->core
->command
404 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
407 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
408 elf_tdata (abfd
)->core
->pid
409 = bfd_get_32 (abfd
, note
->descdata
+ 24);
410 elf_tdata (abfd
)->core
->program
411 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
412 elf_tdata (abfd
)->core
->command
413 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
416 /* Note that for some reason, a spurious space is tacked
417 onto the end of the args in some (at least one anyway)
418 implementations, so strip it off if it exists. */
421 char *command
= elf_tdata (abfd
)->core
->command
;
422 int n
= strlen (command
);
424 if (0 < n
&& command
[n
- 1] == ' ')
425 command
[n
- 1] = '\0';
433 elf_x86_64_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
,
436 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
438 const char *fname
, *psargs
;
449 va_start (ap
, note_type
);
450 fname
= va_arg (ap
, const char *);
451 psargs
= va_arg (ap
, const char *);
454 if (bed
->s
->elfclass
== ELFCLASS32
)
457 memset (&data
, 0, sizeof (data
));
458 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
459 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
460 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
461 &data
, sizeof (data
));
466 memset (&data
, 0, sizeof (data
));
467 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
468 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
469 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
470 &data
, sizeof (data
));
475 va_start (ap
, note_type
);
476 pid
= va_arg (ap
, long);
477 cursig
= va_arg (ap
, int);
478 gregs
= va_arg (ap
, const void *);
481 if (bed
->s
->elfclass
== ELFCLASS32
)
483 if (bed
->elf_machine_code
== EM_X86_64
)
485 prstatusx32_t prstat
;
486 memset (&prstat
, 0, sizeof (prstat
));
488 prstat
.pr_cursig
= cursig
;
489 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
490 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
491 &prstat
, sizeof (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
));
507 memset (&prstat
, 0, sizeof (prstat
));
509 prstat
.pr_cursig
= cursig
;
510 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
511 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
512 &prstat
, sizeof (prstat
));
519 /* Functions for the x86-64 ELF linker. */
521 /* The size in bytes of an entry in the global offset table. */
523 #define GOT_ENTRY_SIZE 8
525 /* The size in bytes of an entry in the lazy procedure linkage table. */
527 #define LAZY_PLT_ENTRY_SIZE 16
529 /* The size in bytes of an entry in the non-lazy procedure linkage
532 #define NON_LAZY_PLT_ENTRY_SIZE 8
534 /* The first entry in a lazy procedure linkage table looks like this.
535 See the SVR4 ABI i386 supplement and the x86-64 ABI to see how this
538 static const bfd_byte elf_x86_64_lazy_plt0_entry
[LAZY_PLT_ENTRY_SIZE
] =
540 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
541 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
542 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
545 /* Subsequent entries in a lazy procedure linkage table look like this. */
547 static const bfd_byte elf_x86_64_lazy_plt_entry
[LAZY_PLT_ENTRY_SIZE
] =
549 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
550 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
551 0x68, /* pushq immediate */
552 0, 0, 0, 0, /* replaced with index into relocation table. */
553 0xe9, /* jmp relative */
554 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
557 /* The first entry in a lazy procedure linkage table with BND prefix
560 static const bfd_byte elf_x86_64_lazy_bnd_plt0_entry
[LAZY_PLT_ENTRY_SIZE
] =
562 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
563 0xf2, 0xff, 0x25, 16, 0, 0, 0, /* bnd jmpq *GOT+16(%rip) */
564 0x0f, 0x1f, 0 /* nopl (%rax) */
567 /* Subsequent entries for branches with BND prefx in a lazy procedure
568 linkage table look like this. */
570 static const bfd_byte elf_x86_64_lazy_bnd_plt_entry
[LAZY_PLT_ENTRY_SIZE
] =
572 0x68, 0, 0, 0, 0, /* pushq immediate */
573 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
574 0x0f, 0x1f, 0x44, 0, 0 /* nopl 0(%rax,%rax,1) */
577 /* The first entry in the IBT-enabled lazy procedure linkage table is the
578 the same as the lazy PLT with BND prefix so that bound registers are
579 preserved when control is passed to dynamic linker. Subsequent
580 entries for a IBT-enabled lazy procedure linkage table look like
583 static const bfd_byte elf_x86_64_lazy_ibt_plt_entry
[LAZY_PLT_ENTRY_SIZE
] =
585 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */
586 0x68, 0, 0, 0, 0, /* pushq immediate */
587 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
591 /* The first entry in the x32 IBT-enabled lazy procedure linkage table
592 is the same as the normal lazy PLT. Subsequent entries for an
593 x32 IBT-enabled lazy procedure linkage table look like this. */
595 static const bfd_byte elf_x32_lazy_ibt_plt_entry
[LAZY_PLT_ENTRY_SIZE
] =
597 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */
598 0x68, 0, 0, 0, 0, /* pushq immediate */
599 0xe9, 0, 0, 0, 0, /* jmpq relative */
600 0x66, 0x90 /* xchg %ax,%ax */
603 /* Entries in the non-lazey procedure linkage table look like this. */
605 static const bfd_byte elf_x86_64_non_lazy_plt_entry
[NON_LAZY_PLT_ENTRY_SIZE
] =
607 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
608 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
609 0x66, 0x90 /* xchg %ax,%ax */
612 /* Entries for branches with BND prefix in the non-lazey procedure
613 linkage table look like this. */
615 static const bfd_byte elf_x86_64_non_lazy_bnd_plt_entry
[NON_LAZY_PLT_ENTRY_SIZE
] =
617 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
618 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
622 /* Entries for branches with IBT-enabled in the non-lazey procedure
623 linkage table look like this. They have the same size as the lazy
626 static const bfd_byte elf_x86_64_non_lazy_ibt_plt_entry
[LAZY_PLT_ENTRY_SIZE
] =
628 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */
629 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
630 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
631 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nopl 0x0(%rax,%rax,1) */
634 /* Entries for branches with IBT-enabled in the x32 non-lazey procedure
635 linkage table look like this. They have the same size as the lazy
638 static const bfd_byte elf_x32_non_lazy_ibt_plt_entry
[LAZY_PLT_ENTRY_SIZE
] =
640 0xf3, 0x0f, 0x1e, 0xfa, /* endbr64 */
641 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
642 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
643 0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nopw 0x0(%rax,%rax,1) */
646 /* .eh_frame covering the lazy .plt section. */
648 static const bfd_byte elf_x86_64_eh_frame_lazy_plt
[] =
650 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
651 0, 0, 0, 0, /* CIE ID */
653 'z', 'R', 0, /* Augmentation string */
654 1, /* Code alignment factor */
655 0x78, /* Data alignment factor */
656 16, /* Return address column */
657 1, /* Augmentation size */
658 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
659 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
660 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
661 DW_CFA_nop
, DW_CFA_nop
,
663 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
664 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
665 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
666 0, 0, 0, 0, /* .plt size goes here */
667 0, /* Augmentation size */
668 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
669 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
670 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
671 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
672 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
673 11, /* Block length */
674 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
675 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
676 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
677 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
678 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
681 /* .eh_frame covering the lazy BND .plt section. */
683 static const bfd_byte elf_x86_64_eh_frame_lazy_bnd_plt
[] =
685 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
686 0, 0, 0, 0, /* CIE ID */
688 'z', 'R', 0, /* Augmentation string */
689 1, /* Code alignment factor */
690 0x78, /* Data alignment factor */
691 16, /* Return address column */
692 1, /* Augmentation size */
693 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
694 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
695 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
696 DW_CFA_nop
, DW_CFA_nop
,
698 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
699 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
700 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
701 0, 0, 0, 0, /* .plt size goes here */
702 0, /* Augmentation size */
703 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
704 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
705 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
706 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
707 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
708 11, /* Block length */
709 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
710 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
711 DW_OP_lit15
, DW_OP_and
, DW_OP_lit5
, DW_OP_ge
,
712 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
713 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
716 /* .eh_frame covering the lazy .plt section with IBT-enabled. */
718 static const bfd_byte elf_x86_64_eh_frame_lazy_ibt_plt
[] =
720 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
721 0, 0, 0, 0, /* CIE ID */
723 'z', 'R', 0, /* Augmentation string */
724 1, /* Code alignment factor */
725 0x78, /* Data alignment factor */
726 16, /* Return address column */
727 1, /* Augmentation size */
728 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
729 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
730 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
731 DW_CFA_nop
, DW_CFA_nop
,
733 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
734 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
735 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
736 0, 0, 0, 0, /* .plt size goes here */
737 0, /* Augmentation size */
738 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
739 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
740 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
741 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
742 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
743 11, /* Block length */
744 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
745 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
746 DW_OP_lit15
, DW_OP_and
, DW_OP_lit10
, DW_OP_ge
,
747 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
748 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
751 /* .eh_frame covering the x32 lazy .plt section with IBT-enabled. */
753 static const bfd_byte elf_x32_eh_frame_lazy_ibt_plt
[] =
755 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
756 0, 0, 0, 0, /* CIE ID */
758 'z', 'R', 0, /* Augmentation string */
759 1, /* Code alignment factor */
760 0x78, /* Data alignment factor */
761 16, /* Return address column */
762 1, /* Augmentation size */
763 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
764 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
765 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
766 DW_CFA_nop
, DW_CFA_nop
,
768 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
769 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
770 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
771 0, 0, 0, 0, /* .plt size goes here */
772 0, /* Augmentation size */
773 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
774 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
775 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
776 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
777 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
778 11, /* Block length */
779 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
780 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
781 DW_OP_lit15
, DW_OP_and
, DW_OP_lit9
, DW_OP_ge
,
782 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
783 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
786 /* .eh_frame covering the non-lazy .plt section. */
788 static const bfd_byte elf_x86_64_eh_frame_non_lazy_plt
[] =
790 #define PLT_GOT_FDE_LENGTH 20
791 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
792 0, 0, 0, 0, /* CIE ID */
794 'z', 'R', 0, /* Augmentation string */
795 1, /* Code alignment factor */
796 0x78, /* Data alignment factor */
797 16, /* Return address column */
798 1, /* Augmentation size */
799 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
800 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
801 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
802 DW_CFA_nop
, DW_CFA_nop
,
804 PLT_GOT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
805 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
806 0, 0, 0, 0, /* the start of non-lazy .plt goes here */
807 0, 0, 0, 0, /* non-lazy .plt size goes here */
808 0, /* Augmentation size */
809 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
,
810 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
813 /* Architecture-specific backend data for x86-64. */
815 struct elf_x86_64_backend_data
825 #define get_elf_x86_64_arch_data(bed) \
826 ((const struct elf_x86_64_backend_data *) (bed)->arch_data)
828 #define get_elf_x86_64_backend_data(abfd) \
829 get_elf_x86_64_arch_data (get_elf_backend_data (abfd))
831 /* These are the standard parameters. */
832 static const struct elf_x86_lazy_plt_layout elf_x86_64_lazy_plt
=
834 elf_x86_64_lazy_plt0_entry
, /* plt0_entry */
835 LAZY_PLT_ENTRY_SIZE
, /* plt0_entry_size */
836 elf_x86_64_lazy_plt_entry
, /* plt_entry */
837 LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
838 2, /* plt0_got1_offset */
839 8, /* plt0_got2_offset */
840 12, /* plt0_got2_insn_end */
841 2, /* plt_got_offset */
842 7, /* plt_reloc_offset */
843 12, /* plt_plt_offset */
844 6, /* plt_got_insn_size */
845 LAZY_PLT_ENTRY_SIZE
, /* plt_plt_insn_end */
846 6, /* plt_lazy_offset */
847 elf_x86_64_lazy_plt0_entry
, /* pic_plt0_entry */
848 elf_x86_64_lazy_plt_entry
, /* pic_plt_entry */
849 elf_x86_64_eh_frame_lazy_plt
, /* eh_frame_plt */
850 sizeof (elf_x86_64_eh_frame_lazy_plt
) /* eh_frame_plt_size */
853 static const struct elf_x86_non_lazy_plt_layout elf_x86_64_non_lazy_plt
=
855 elf_x86_64_non_lazy_plt_entry
, /* plt_entry */
856 elf_x86_64_non_lazy_plt_entry
, /* pic_plt_entry */
857 NON_LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
858 2, /* plt_got_offset */
859 6, /* plt_got_insn_size */
860 elf_x86_64_eh_frame_non_lazy_plt
, /* eh_frame_plt */
861 sizeof (elf_x86_64_eh_frame_non_lazy_plt
) /* eh_frame_plt_size */
864 static const struct elf_x86_lazy_plt_layout elf_x86_64_lazy_bnd_plt
=
866 elf_x86_64_lazy_bnd_plt0_entry
, /* plt0_entry */
867 LAZY_PLT_ENTRY_SIZE
, /* plt0_entry_size */
868 elf_x86_64_lazy_bnd_plt_entry
, /* plt_entry */
869 LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
870 2, /* plt0_got1_offset */
871 1+8, /* plt0_got2_offset */
872 1+12, /* plt0_got2_insn_end */
873 1+2, /* plt_got_offset */
874 1, /* plt_reloc_offset */
875 7, /* plt_plt_offset */
876 1+6, /* plt_got_insn_size */
877 11, /* plt_plt_insn_end */
878 0, /* plt_lazy_offset */
879 elf_x86_64_lazy_bnd_plt0_entry
, /* pic_plt0_entry */
880 elf_x86_64_lazy_bnd_plt_entry
, /* pic_plt_entry */
881 elf_x86_64_eh_frame_lazy_bnd_plt
, /* eh_frame_plt */
882 sizeof (elf_x86_64_eh_frame_lazy_bnd_plt
) /* eh_frame_plt_size */
885 static const struct elf_x86_non_lazy_plt_layout elf_x86_64_non_lazy_bnd_plt
=
887 elf_x86_64_non_lazy_bnd_plt_entry
, /* plt_entry */
888 elf_x86_64_non_lazy_bnd_plt_entry
, /* pic_plt_entry */
889 NON_LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
890 1+2, /* plt_got_offset */
891 1+6, /* plt_got_insn_size */
892 elf_x86_64_eh_frame_non_lazy_plt
, /* eh_frame_plt */
893 sizeof (elf_x86_64_eh_frame_non_lazy_plt
) /* eh_frame_plt_size */
896 static const struct elf_x86_lazy_plt_layout elf_x86_64_lazy_ibt_plt
=
898 elf_x86_64_lazy_bnd_plt0_entry
, /* plt0_entry */
899 LAZY_PLT_ENTRY_SIZE
, /* plt0_entry_size */
900 elf_x86_64_lazy_ibt_plt_entry
, /* plt_entry */
901 LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
902 2, /* plt0_got1_offset */
903 1+8, /* plt0_got2_offset */
904 1+12, /* plt0_got2_insn_end */
905 4+1+2, /* plt_got_offset */
906 4+1, /* plt_reloc_offset */
907 4+1+6, /* plt_plt_offset */
908 4+1+6, /* plt_got_insn_size */
909 4+1+5+5, /* plt_plt_insn_end */
910 0, /* plt_lazy_offset */
911 elf_x86_64_lazy_bnd_plt0_entry
, /* pic_plt0_entry */
912 elf_x86_64_lazy_ibt_plt_entry
, /* pic_plt_entry */
913 elf_x86_64_eh_frame_lazy_ibt_plt
, /* eh_frame_plt */
914 sizeof (elf_x86_64_eh_frame_lazy_ibt_plt
) /* eh_frame_plt_size */
917 static const struct elf_x86_lazy_plt_layout elf_x32_lazy_ibt_plt
=
919 elf_x86_64_lazy_plt0_entry
, /* plt0_entry */
920 LAZY_PLT_ENTRY_SIZE
, /* plt0_entry_size */
921 elf_x32_lazy_ibt_plt_entry
, /* plt_entry */
922 LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
923 2, /* plt0_got1_offset */
924 8, /* plt0_got2_offset */
925 12, /* plt0_got2_insn_end */
926 4+2, /* plt_got_offset */
927 4+1, /* plt_reloc_offset */
928 4+6, /* plt_plt_offset */
929 4+6, /* plt_got_insn_size */
930 4+5+5, /* plt_plt_insn_end */
931 0, /* plt_lazy_offset */
932 elf_x86_64_lazy_plt0_entry
, /* pic_plt0_entry */
933 elf_x32_lazy_ibt_plt_entry
, /* pic_plt_entry */
934 elf_x32_eh_frame_lazy_ibt_plt
, /* eh_frame_plt */
935 sizeof (elf_x32_eh_frame_lazy_ibt_plt
) /* eh_frame_plt_size */
938 static const struct elf_x86_non_lazy_plt_layout elf_x86_64_non_lazy_ibt_plt
=
940 elf_x86_64_non_lazy_ibt_plt_entry
, /* plt_entry */
941 elf_x86_64_non_lazy_ibt_plt_entry
, /* pic_plt_entry */
942 LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
943 4+1+2, /* plt_got_offset */
944 4+1+6, /* plt_got_insn_size */
945 elf_x86_64_eh_frame_non_lazy_plt
, /* eh_frame_plt */
946 sizeof (elf_x86_64_eh_frame_non_lazy_plt
) /* eh_frame_plt_size */
949 static const struct elf_x86_non_lazy_plt_layout elf_x32_non_lazy_ibt_plt
=
951 elf_x32_non_lazy_ibt_plt_entry
, /* plt_entry */
952 elf_x32_non_lazy_ibt_plt_entry
, /* pic_plt_entry */
953 LAZY_PLT_ENTRY_SIZE
, /* plt_entry_size */
954 4+2, /* plt_got_offset */
955 4+6, /* plt_got_insn_size */
956 elf_x86_64_eh_frame_non_lazy_plt
, /* eh_frame_plt */
957 sizeof (elf_x86_64_eh_frame_non_lazy_plt
) /* eh_frame_plt_size */
960 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed
=
965 #define elf_backend_arch_data &elf_x86_64_arch_bed
968 elf64_x86_64_elf_object_p (bfd
*abfd
)
970 /* Set the right machine number for an x86-64 elf64 file. */
971 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
976 elf32_x86_64_elf_object_p (bfd
*abfd
)
978 /* Set the right machine number for an x86-64 elf32 file. */
979 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
983 /* Return TRUE if the TLS access code sequence support transition
987 elf_x86_64_check_tls_transition (bfd
*abfd
,
988 struct bfd_link_info
*info
,
991 Elf_Internal_Shdr
*symtab_hdr
,
992 struct elf_link_hash_entry
**sym_hashes
,
994 const Elf_Internal_Rela
*rel
,
995 const Elf_Internal_Rela
*relend
)
998 unsigned long r_symndx
;
999 bfd_boolean largepic
= FALSE
;
1000 struct elf_link_hash_entry
*h
;
1002 struct elf_x86_link_hash_table
*htab
;
1004 bfd_boolean indirect_call
;
1006 htab
= elf_x86_hash_table (info
, X86_64_ELF_DATA
);
1007 offset
= rel
->r_offset
;
1010 case R_X86_64_TLSGD
:
1011 case R_X86_64_TLSLD
:
1012 if ((rel
+ 1) >= relend
)
1015 if (r_type
== R_X86_64_TLSGD
)
1017 /* Check transition from GD access model. For 64bit, only
1018 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1019 .word 0x6666; rex64; call __tls_get_addr@PLT
1021 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1023 call *__tls_get_addr@GOTPCREL(%rip)
1024 which may be converted to
1025 addr32 call __tls_get_addr
1026 can transit to different access model. For 32bit, only
1027 leaq foo@tlsgd(%rip), %rdi
1028 .word 0x6666; rex64; call __tls_get_addr@PLT
1030 leaq foo@tlsgd(%rip), %rdi
1032 call *__tls_get_addr@GOTPCREL(%rip)
1033 which may be converted to
1034 addr32 call __tls_get_addr
1035 can transit to different access model. For largepic,
1037 leaq foo@tlsgd(%rip), %rdi
1038 movabsq $__tls_get_addr@pltoff, %rax
1042 leaq foo@tlsgd(%rip), %rdi
1043 movabsq $__tls_get_addr@pltoff, %rax
1047 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1049 if ((offset
+ 12) > sec
->size
)
1052 call
= contents
+ offset
+ 4;
1054 || !((call
[1] == 0x48
1062 && call
[3] == 0xe8)))
1064 if (!ABI_64_P (abfd
)
1065 || (offset
+ 19) > sec
->size
1067 || memcmp (call
- 7, leaq
+ 1, 3) != 0
1068 || memcmp (call
, "\x48\xb8", 2) != 0
1072 || !((call
[10] == 0x48 && call
[12] == 0xd8)
1073 || (call
[10] == 0x4c && call
[12] == 0xf8)))
1077 else if (ABI_64_P (abfd
))
1080 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1086 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1089 indirect_call
= call
[2] == 0xff;
1093 /* Check transition from LD access model. Only
1094 leaq foo@tlsld(%rip), %rdi;
1095 call __tls_get_addr@PLT
1097 leaq foo@tlsld(%rip), %rdi;
1098 call *__tls_get_addr@GOTPCREL(%rip)
1099 which may be converted to
1100 addr32 call __tls_get_addr
1101 can transit to different access model. For largepic
1103 leaq foo@tlsld(%rip), %rdi
1104 movabsq $__tls_get_addr@pltoff, %rax
1108 leaq foo@tlsld(%rip), %rdi
1109 movabsq $__tls_get_addr@pltoff, %rax
1113 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1115 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1118 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0)
1121 call
= contents
+ offset
+ 4;
1122 if (!(call
[0] == 0xe8
1123 || (call
[0] == 0xff && call
[1] == 0x15)
1124 || (call
[0] == 0x67 && call
[1] == 0xe8)))
1126 if (!ABI_64_P (abfd
)
1127 || (offset
+ 19) > sec
->size
1128 || memcmp (call
, "\x48\xb8", 2) != 0
1132 || !((call
[10] == 0x48 && call
[12] == 0xd8)
1133 || (call
[10] == 0x4c && call
[12] == 0xf8)))
1137 indirect_call
= call
[0] == 0xff;
1140 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1141 if (r_symndx
< symtab_hdr
->sh_info
)
1144 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1146 || !((struct elf_x86_link_hash_entry
*) h
)->tls_get_addr
)
1149 return ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLTOFF64
;
1150 else if (indirect_call
)
1151 return ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_GOTPCRELX
;
1153 return (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1154 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
);
1156 case R_X86_64_GOTTPOFF
:
1157 /* Check transition from IE access model:
1158 mov foo@gottpoff(%rip), %reg
1159 add foo@gottpoff(%rip), %reg
1162 /* Check REX prefix first. */
1163 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1165 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1166 if (val
!= 0x48 && val
!= 0x4c)
1168 /* X32 may have 0x44 REX prefix or no REX prefix. */
1169 if (ABI_64_P (abfd
))
1175 /* X32 may not have any REX prefix. */
1176 if (ABI_64_P (abfd
))
1178 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1182 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1183 if (val
!= 0x8b && val
!= 0x03)
1186 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1187 return (val
& 0xc7) == 5;
1189 case R_X86_64_GOTPC32_TLSDESC
:
1190 /* Check transition from GDesc access model:
1191 leaq x@tlsdesc(%rip), %rax
1193 Make sure it's a leaq adding rip to a 32-bit offset
1194 into any register, although it's probably almost always
1197 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1200 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1201 if ((val
& 0xfb) != 0x48)
1204 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1207 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1208 return (val
& 0xc7) == 0x05;
1210 case R_X86_64_TLSDESC_CALL
:
1211 /* Check transition from GDesc access model:
1212 call *x@tlsdesc(%rax)
1214 if (offset
+ 2 <= sec
->size
)
1216 /* Make sure that it's a call *x@tlsdesc(%rax). */
1217 call
= contents
+ offset
;
1218 return call
[0] == 0xff && call
[1] == 0x10;
1228 /* Return TRUE if the TLS access transition is OK or no transition
1229 will be performed. Update R_TYPE if there is a transition. */
1232 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1233 asection
*sec
, bfd_byte
*contents
,
1234 Elf_Internal_Shdr
*symtab_hdr
,
1235 struct elf_link_hash_entry
**sym_hashes
,
1236 unsigned int *r_type
, int tls_type
,
1237 const Elf_Internal_Rela
*rel
,
1238 const Elf_Internal_Rela
*relend
,
1239 struct elf_link_hash_entry
*h
,
1240 unsigned long r_symndx
,
1241 bfd_boolean from_relocate_section
)
1243 unsigned int from_type
= *r_type
;
1244 unsigned int to_type
= from_type
;
1245 bfd_boolean check
= TRUE
;
1247 /* Skip TLS transition for functions. */
1249 && (h
->type
== STT_FUNC
1250 || h
->type
== STT_GNU_IFUNC
))
1255 case R_X86_64_TLSGD
:
1256 case R_X86_64_GOTPC32_TLSDESC
:
1257 case R_X86_64_TLSDESC_CALL
:
1258 case R_X86_64_GOTTPOFF
:
1259 if (bfd_link_executable (info
))
1262 to_type
= R_X86_64_TPOFF32
;
1264 to_type
= R_X86_64_GOTTPOFF
;
1267 /* When we are called from elf_x86_64_relocate_section, there may
1268 be additional transitions based on TLS_TYPE. */
1269 if (from_relocate_section
)
1271 unsigned int new_to_type
= to_type
;
1273 if (bfd_link_executable (info
)
1276 && tls_type
== GOT_TLS_IE
)
1277 new_to_type
= R_X86_64_TPOFF32
;
1279 if (to_type
== R_X86_64_TLSGD
1280 || to_type
== R_X86_64_GOTPC32_TLSDESC
1281 || to_type
== R_X86_64_TLSDESC_CALL
)
1283 if (tls_type
== GOT_TLS_IE
)
1284 new_to_type
= R_X86_64_GOTTPOFF
;
1287 /* We checked the transition before when we were called from
1288 elf_x86_64_check_relocs. We only want to check the new
1289 transition which hasn't been checked before. */
1290 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1291 to_type
= new_to_type
;
1296 case R_X86_64_TLSLD
:
1297 if (bfd_link_executable (info
))
1298 to_type
= R_X86_64_TPOFF32
;
1305 /* Return TRUE if there is no transition. */
1306 if (from_type
== to_type
)
1309 /* Check if the transition can be performed. */
1311 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1312 symtab_hdr
, sym_hashes
,
1313 from_type
, rel
, relend
))
1315 reloc_howto_type
*from
, *to
;
1318 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1319 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1322 name
= h
->root
.root
.string
;
1325 struct elf_x86_link_hash_table
*htab
;
1327 htab
= elf_x86_hash_table (info
, X86_64_ELF_DATA
);
1332 Elf_Internal_Sym
*isym
;
1334 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1336 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1341 /* xgettext:c-format */
1342 (_("%B: TLS transition from %s to %s against `%s' at %#Lx "
1343 "in section `%A' failed"),
1344 abfd
, from
->name
, to
->name
, name
, rel
->r_offset
, sec
);
1345 bfd_set_error (bfd_error_bad_value
);
1353 /* Rename some of the generic section flags to better document how they
1355 #define need_convert_load sec_flg0
1356 #define check_relocs_failed sec_flg1
1359 elf_x86_64_need_pic (struct bfd_link_info
*info
,
1360 bfd
*input_bfd
, asection
*sec
,
1361 struct elf_link_hash_entry
*h
,
1362 Elf_Internal_Shdr
*symtab_hdr
,
1363 Elf_Internal_Sym
*isym
,
1364 reloc_howto_type
*howto
)
1367 const char *und
= "";
1368 const char *pic
= "";
1374 name
= h
->root
.root
.string
;
1375 switch (ELF_ST_VISIBILITY (h
->other
))
1378 v
= _("hidden symbol ");
1381 v
= _("internal symbol ");
1384 v
= _("protected symbol ");
1387 if (((struct elf_x86_link_hash_entry
*) h
)->def_protected
)
1388 v
= _("protected symbol ");
1391 pic
= _("; recompile with -fPIC");
1395 if (!h
->def_regular
&& !h
->def_dynamic
)
1396 und
= _("undefined ");
1400 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, isym
, NULL
);
1401 pic
= _("; recompile with -fPIC");
1404 if (bfd_link_dll (info
))
1405 object
= _("a shared object");
1406 else if (bfd_link_pie (info
))
1407 object
= _("a PIE object");
1409 object
= _("a PDE object");
1411 /* xgettext:c-format */
1412 _bfd_error_handler (_("%B: relocation %s against %s%s`%s' can "
1413 "not be used when making %s%s"),
1414 input_bfd
, howto
->name
, und
, v
, name
,
1416 bfd_set_error (bfd_error_bad_value
);
1417 sec
->check_relocs_failed
= 1;
1421 /* With the local symbol, foo, we convert
1422 mov foo@GOTPCREL(%rip), %reg
1426 call/jmp *foo@GOTPCREL(%rip)
1428 nop call foo/jmp foo nop
1429 When PIC is false, convert
1430 test %reg, foo@GOTPCREL(%rip)
1434 binop foo@GOTPCREL(%rip), %reg
1437 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1441 elf_x86_64_convert_load_reloc (bfd
*abfd
, asection
*sec
,
1443 Elf_Internal_Rela
*irel
,
1444 struct elf_link_hash_entry
*h
,
1445 bfd_boolean
*converted
,
1446 struct bfd_link_info
*link_info
)
1448 struct elf_x86_link_hash_table
*htab
;
1450 bfd_boolean require_reloc_pc32
;
1452 bfd_boolean to_reloc_pc32
;
1455 bfd_signed_vma raddend
;
1456 unsigned int opcode
;
1458 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
1459 unsigned int r_symndx
;
1461 bfd_vma roff
= irel
->r_offset
;
1463 if (roff
< (r_type
== R_X86_64_REX_GOTPCRELX
? 3 : 2))
1466 raddend
= irel
->r_addend
;
1467 /* Addend for 32-bit PC-relative relocation must be -4. */
1471 htab
= elf_x86_hash_table (link_info
, X86_64_ELF_DATA
);
1472 is_pic
= bfd_link_pic (link_info
);
1474 relocx
= (r_type
== R_X86_64_GOTPCRELX
1475 || r_type
== R_X86_64_REX_GOTPCRELX
);
1477 /* TRUE if we can convert only to R_X86_64_PC32. Enable it for
1480 = link_info
->disable_target_specific_optimizations
> 1;
1482 r_symndx
= htab
->r_sym (irel
->r_info
);
1484 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
1486 /* Convert mov to lea since it has been done for a while. */
1489 /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
1490 for call, jmp or one of adc, add, and, cmp, or, sbb, sub,
1491 test, xor instructions. */
1496 /* We convert only to R_X86_64_PC32:
1498 2. R_X86_64_GOTPCREL since we can't modify REX byte.
1499 3. require_reloc_pc32 is true.
1502 to_reloc_pc32
= (opcode
== 0xff
1504 || require_reloc_pc32
1507 /* Get the symbol referred to by the reloc. */
1510 Elf_Internal_Sym
*isym
1511 = bfd_sym_from_r_symndx (&htab
->sym_cache
, abfd
, r_symndx
);
1513 /* Skip relocation against undefined symbols. */
1514 if (isym
->st_shndx
== SHN_UNDEF
)
1517 symtype
= ELF_ST_TYPE (isym
->st_info
);
1519 if (isym
->st_shndx
== SHN_ABS
)
1520 tsec
= bfd_abs_section_ptr
;
1521 else if (isym
->st_shndx
== SHN_COMMON
)
1522 tsec
= bfd_com_section_ptr
;
1523 else if (isym
->st_shndx
== SHN_X86_64_LCOMMON
)
1524 tsec
= &_bfd_elf_large_com_section
;
1526 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1528 toff
= isym
->st_value
;
1532 /* Undefined weak symbol is only bound locally in executable
1533 and its reference is resolved as 0 without relocation
1534 overflow. We can only perform this optimization for
1535 GOTPCRELX relocations since we need to modify REX byte.
1536 It is OK convert mov with R_X86_64_GOTPCREL to
1538 if ((relocx
|| opcode
== 0x8b)
1539 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
,
1542 elf_x86_hash_entry (h
)))
1546 /* Skip for branch instructions since R_X86_64_PC32
1548 if (require_reloc_pc32
)
1553 /* For non-branch instructions, we can convert to
1554 R_X86_64_32/R_X86_64_32S since we know if there
1556 to_reloc_pc32
= FALSE
;
1559 /* Since we don't know the current PC when PIC is true,
1560 we can't convert to R_X86_64_PC32. */
1561 if (to_reloc_pc32
&& is_pic
)
1566 /* Avoid optimizing GOTPCREL relocations againt _DYNAMIC since
1567 ld.so may use its link-time address. */
1568 else if (h
->start_stop
1570 || h
->root
.type
== bfd_link_hash_defined
1571 || h
->root
.type
== bfd_link_hash_defweak
)
1572 && h
!= htab
->elf
.hdynamic
1573 && SYMBOL_REFERENCES_LOCAL (link_info
, h
)))
1575 /* bfd_link_hash_new or bfd_link_hash_undefined is
1576 set by an assignment in a linker script in
1577 bfd_elf_record_link_assignment. start_stop is set
1578 on __start_SECNAME/__stop_SECNAME which mark section
1582 && (h
->root
.type
== bfd_link_hash_new
1583 || h
->root
.type
== bfd_link_hash_undefined
1584 || ((h
->root
.type
== bfd_link_hash_defined
1585 || h
->root
.type
== bfd_link_hash_defweak
)
1586 && h
->root
.u
.def
.section
== bfd_und_section_ptr
))))
1588 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */
1589 if (require_reloc_pc32
)
1593 tsec
= h
->root
.u
.def
.section
;
1594 toff
= h
->root
.u
.def
.value
;
1601 /* Don't convert GOTPCREL relocation against large section. */
1602 if (elf_section_data (tsec
) != NULL
1603 && (elf_section_flags (tsec
) & SHF_X86_64_LARGE
) != 0)
1606 /* We can only estimate relocation overflow for R_X86_64_PC32. */
1610 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
1612 /* At this stage in linking, no SEC_MERGE symbol has been
1613 adjusted, so all references to such symbols need to be
1614 passed through _bfd_merged_section_offset. (Later, in
1615 relocate_section, all SEC_MERGE symbols *except* for
1616 section symbols have been adjusted.)
1618 gas may reduce relocations against symbols in SEC_MERGE
1619 sections to a relocation against the section symbol when
1620 the original addend was zero. When the reloc is against
1621 a section symbol we should include the addend in the
1622 offset passed to _bfd_merged_section_offset, since the
1623 location of interest is the original symbol. On the
1624 other hand, an access to "sym+addend" where "sym" is not
1625 a section symbol should not include the addend; Such an
1626 access is presumed to be an offset from "sym"; The
1627 location of interest is just "sym". */
1628 if (symtype
== STT_SECTION
)
1631 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
1632 elf_section_data (tsec
)->sec_info
,
1635 if (symtype
!= STT_SECTION
)
1641 /* Don't convert if R_X86_64_PC32 relocation overflows. */
1642 if (tsec
->output_section
== sec
->output_section
)
1644 if ((toff
- roff
+ 0x80000000) > 0xffffffff)
1649 bfd_signed_vma distance
;
1651 /* At this point, we don't know the load addresses of TSEC
1652 section nor SEC section. We estimate the distrance between
1653 SEC and TSEC. We store the estimated distances in the
1654 compressed_size field of the output section, which is only
1655 used to decompress the compressed input section. */
1656 if (sec
->output_section
->compressed_size
== 0)
1659 bfd_size_type size
= 0;
1660 for (asect
= link_info
->output_bfd
->sections
;
1662 asect
= asect
->next
)
1663 /* Skip debug sections since compressed_size is used to
1664 compress debug sections. */
1665 if ((asect
->flags
& SEC_DEBUGGING
) == 0)
1668 for (i
= asect
->map_head
.s
;
1672 size
= align_power (size
, i
->alignment_power
);
1675 asect
->compressed_size
= size
;
1679 /* Don't convert GOTPCREL relocations if TSEC isn't placed
1681 distance
= (tsec
->output_section
->compressed_size
1682 - sec
->output_section
->compressed_size
);
1686 /* Take PT_GNU_RELRO segment into account by adding
1688 if ((toff
+ distance
+ get_elf_backend_data (abfd
)->maxpagesize
1689 - roff
+ 0x80000000) > 0xffffffff)
1696 /* We have "call/jmp *foo@GOTPCREL(%rip)". */
1701 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
1703 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
1706 /* Convert to "jmp foo nop". */
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
);
1716 struct elf_x86_link_hash_entry
*eh
1717 = (struct elf_x86_link_hash_entry
*) h
;
1719 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
1722 /* To support TLS optimization, always use addr32 prefix for
1723 "call *__tls_get_addr@GOTPCREL(%rip)". */
1724 if (eh
&& eh
->tls_get_addr
)
1727 nop_offset
= irel
->r_offset
- 2;
1731 nop
= link_info
->call_nop_byte
;
1732 if (link_info
->call_nop_as_suffix
)
1734 nop_offset
= irel
->r_offset
+ 3;
1735 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
1736 irel
->r_offset
-= 1;
1737 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
1740 nop_offset
= irel
->r_offset
- 2;
1743 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
1744 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
1745 r_type
= R_X86_64_PC32
;
1750 unsigned int rex_mask
= REX_R
;
1752 if (r_type
== R_X86_64_REX_GOTPCRELX
)
1753 rex
= bfd_get_8 (abfd
, contents
+ roff
- 3);
1761 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
1762 "lea foo(%rip), %reg". */
1764 r_type
= R_X86_64_PC32
;
1768 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
1769 "mov $foo, %reg". */
1771 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
1772 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
1773 if ((rex
& REX_W
) != 0
1774 && ABI_64_P (link_info
->output_bfd
))
1776 /* Keep the REX_W bit in REX byte for LP64. */
1777 r_type
= R_X86_64_32S
;
1778 goto rewrite_modrm_rex
;
1782 /* If the REX_W bit in REX byte isn't needed,
1783 use R_X86_64_32 and clear the W bit to avoid
1784 sign-extend imm32 to imm64. */
1785 r_type
= R_X86_64_32
;
1786 /* Clear the W bit in REX byte. */
1788 goto rewrite_modrm_rex
;
1794 /* R_X86_64_PC32 isn't supported. */
1798 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
1801 /* Convert "test %reg, foo@GOTPCREL(%rip)" to
1802 "test $foo, %reg". */
1803 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
1808 /* Convert "binop foo@GOTPCREL(%rip), %reg" to
1809 "binop $foo, %reg". */
1810 modrm
= 0xc0 | (modrm
& 0x38) >> 3 | (opcode
& 0x3c);
1814 /* Use R_X86_64_32 with 32-bit operand to avoid relocation
1815 overflow when sign-extending imm32 to imm64. */
1816 r_type
= (rex
& REX_W
) != 0 ? R_X86_64_32S
: R_X86_64_32
;
1819 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
1823 /* Move the R bit to the B bit in REX byte. */
1824 rex
= (rex
& ~rex_mask
) | (rex
& REX_R
) >> 2;
1825 bfd_put_8 (abfd
, rex
, contents
+ roff
- 3);
1828 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */
1832 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
1835 irel
->r_info
= htab
->r_info (r_symndx
, r_type
);
1842 /* Look through the relocs for a section during the first phase, and
1843 calculate needed space in the global offset table, procedure
1844 linkage table, and dynamic reloc sections. */
1847 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1849 const Elf_Internal_Rela
*relocs
)
1851 struct elf_x86_link_hash_table
*htab
;
1852 Elf_Internal_Shdr
*symtab_hdr
;
1853 struct elf_link_hash_entry
**sym_hashes
;
1854 const Elf_Internal_Rela
*rel
;
1855 const Elf_Internal_Rela
*rel_end
;
1859 if (bfd_link_relocatable (info
))
1862 /* Don't do anything special with non-loaded, non-alloced sections.
1863 In particular, any relocs in such sections should not affect GOT
1864 and PLT reference counting (ie. we don't allow them to create GOT
1865 or PLT entries), there's no possibility or desire to optimize TLS
1866 relocs, and there's not much point in propagating relocs to shared
1867 libs that the dynamic linker won't relocate. */
1868 if ((sec
->flags
& SEC_ALLOC
) == 0)
1871 htab
= elf_x86_hash_table (info
, X86_64_ELF_DATA
);
1874 sec
->check_relocs_failed
= 1;
1878 BFD_ASSERT (is_x86_elf (abfd
, htab
));
1880 /* Get the section contents. */
1881 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1882 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1883 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1885 sec
->check_relocs_failed
= 1;
1889 symtab_hdr
= &elf_symtab_hdr (abfd
);
1890 sym_hashes
= elf_sym_hashes (abfd
);
1894 rel_end
= relocs
+ sec
->reloc_count
;
1895 for (rel
= relocs
; rel
< rel_end
; rel
++)
1897 unsigned int r_type
;
1898 unsigned int r_symndx
;
1899 struct elf_link_hash_entry
*h
;
1900 struct elf_x86_link_hash_entry
*eh
;
1901 Elf_Internal_Sym
*isym
;
1903 bfd_boolean size_reloc
;
1905 r_symndx
= htab
->r_sym (rel
->r_info
);
1906 r_type
= ELF32_R_TYPE (rel
->r_info
);
1908 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1910 /* xgettext:c-format */
1911 _bfd_error_handler (_("%B: bad symbol index: %d"),
1916 if (r_symndx
< symtab_hdr
->sh_info
)
1918 /* A local symbol. */
1919 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1924 /* Check relocation against local STT_GNU_IFUNC symbol. */
1925 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
1927 h
= _bfd_elf_x86_get_local_sym_hash (htab
, abfd
, rel
,
1932 /* Fake a STT_GNU_IFUNC symbol. */
1933 h
->root
.root
.string
= bfd_elf_sym_name (abfd
, symtab_hdr
,
1935 h
->type
= STT_GNU_IFUNC
;
1938 h
->forced_local
= 1;
1939 h
->root
.type
= bfd_link_hash_defined
;
1947 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1948 while (h
->root
.type
== bfd_link_hash_indirect
1949 || h
->root
.type
== bfd_link_hash_warning
)
1950 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1953 /* Check invalid x32 relocations. */
1954 if (!ABI_64_P (abfd
))
1960 case R_X86_64_DTPOFF64
:
1961 case R_X86_64_TPOFF64
:
1963 case R_X86_64_GOTOFF64
:
1964 case R_X86_64_GOT64
:
1965 case R_X86_64_GOTPCREL64
:
1966 case R_X86_64_GOTPC64
:
1967 case R_X86_64_GOTPLT64
:
1968 case R_X86_64_PLTOFF64
:
1971 name
= h
->root
.root
.string
;
1973 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
1976 /* xgettext:c-format */
1977 (_("%B: relocation %s against symbol `%s' isn't "
1978 "supported in x32 mode"), abfd
,
1979 x86_64_elf_howto_table
[r_type
].name
, name
);
1980 bfd_set_error (bfd_error_bad_value
);
1988 /* It is referenced by a non-shared object. */
1990 h
->root
.non_ir_ref_regular
= 1;
1992 if (h
->type
== STT_GNU_IFUNC
)
1993 elf_tdata (info
->output_bfd
)->has_gnu_symbols
1994 |= elf_gnu_symbol_ifunc
;
1997 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, contents
,
1998 symtab_hdr
, sym_hashes
,
1999 &r_type
, GOT_UNKNOWN
,
2000 rel
, rel_end
, h
, r_symndx
, FALSE
))
2003 eh
= (struct elf_x86_link_hash_entry
*) h
;
2006 case R_X86_64_TLSLD
:
2007 htab
->tls_ld_or_ldm_got
.refcount
+= 1;
2010 case R_X86_64_TPOFF32
:
2011 if (!bfd_link_executable (info
) && ABI_64_P (abfd
))
2012 return elf_x86_64_need_pic (info
, abfd
, sec
, h
, symtab_hdr
, isym
,
2013 &x86_64_elf_howto_table
[r_type
]);
2015 eh
->has_got_reloc
= 1;
2018 case R_X86_64_GOTTPOFF
:
2019 if (!bfd_link_executable (info
))
2020 info
->flags
|= DF_STATIC_TLS
;
2023 case R_X86_64_GOT32
:
2024 case R_X86_64_GOTPCREL
:
2025 case R_X86_64_GOTPCRELX
:
2026 case R_X86_64_REX_GOTPCRELX
:
2027 case R_X86_64_TLSGD
:
2028 case R_X86_64_GOT64
:
2029 case R_X86_64_GOTPCREL64
:
2030 case R_X86_64_GOTPLT64
:
2031 case R_X86_64_GOTPC32_TLSDESC
:
2032 case R_X86_64_TLSDESC_CALL
:
2033 /* This symbol requires a global offset table entry. */
2035 int tls_type
, old_tls_type
;
2039 default: tls_type
= GOT_NORMAL
; break;
2040 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
2041 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
2042 case R_X86_64_GOTPC32_TLSDESC
:
2043 case R_X86_64_TLSDESC_CALL
:
2044 tls_type
= GOT_TLS_GDESC
; break;
2049 h
->got
.refcount
+= 1;
2050 old_tls_type
= eh
->tls_type
;
2054 bfd_signed_vma
*local_got_refcounts
;
2056 /* This is a global offset table entry for a local symbol. */
2057 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2058 if (local_got_refcounts
== NULL
)
2062 size
= symtab_hdr
->sh_info
;
2063 size
*= sizeof (bfd_signed_vma
)
2064 + sizeof (bfd_vma
) + sizeof (char);
2065 local_got_refcounts
= ((bfd_signed_vma
*)
2066 bfd_zalloc (abfd
, size
));
2067 if (local_got_refcounts
== NULL
)
2069 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2070 elf_x86_local_tlsdesc_gotent (abfd
)
2071 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
2072 elf_x86_local_got_tls_type (abfd
)
2073 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
2075 local_got_refcounts
[r_symndx
] += 1;
2077 = elf_x86_local_got_tls_type (abfd
) [r_symndx
];
2080 /* If a TLS symbol is accessed using IE at least once,
2081 there is no point to use dynamic model for it. */
2082 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
2083 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
2084 || tls_type
!= GOT_TLS_IE
))
2086 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
2087 tls_type
= old_tls_type
;
2088 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
2089 && GOT_TLS_GD_ANY_P (tls_type
))
2090 tls_type
|= old_tls_type
;
2094 name
= h
->root
.root
.string
;
2096 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
2099 /* xgettext:c-format */
2100 (_("%B: '%s' accessed both as normal and"
2101 " thread local symbol"),
2103 bfd_set_error (bfd_error_bad_value
);
2108 if (old_tls_type
!= tls_type
)
2111 eh
->tls_type
= tls_type
;
2113 elf_x86_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
2118 case R_X86_64_GOTOFF64
:
2119 case R_X86_64_GOTPC32
:
2120 case R_X86_64_GOTPC64
:
2123 eh
->has_got_reloc
= 1;
2126 case R_X86_64_PLT32
:
2127 case R_X86_64_PLT32_BND
:
2128 /* This symbol requires a procedure linkage table entry. We
2129 actually build the entry in adjust_dynamic_symbol,
2130 because this might be a case of linking PIC code which is
2131 never referenced by a dynamic object, in which case we
2132 don't need to generate a procedure linkage table entry
2135 /* If this is a local symbol, we resolve it directly without
2136 creating a procedure linkage table entry. */
2140 eh
->has_got_reloc
= 1;
2142 h
->plt
.refcount
+= 1;
2145 case R_X86_64_PLTOFF64
:
2146 /* This tries to form the 'address' of a function relative
2147 to GOT. For global symbols we need a PLT entry. */
2151 h
->plt
.refcount
+= 1;
2155 case R_X86_64_SIZE32
:
2156 case R_X86_64_SIZE64
:
2161 if (!ABI_64_P (abfd
))
2167 /* Check relocation overflow as these relocs may lead to
2168 run-time relocation overflow. Don't error out for
2169 sections we don't care about, such as debug sections or
2170 when relocation overflow check is disabled. */
2171 if (!info
->no_reloc_overflow_check
2172 && (bfd_link_pic (info
)
2173 || (bfd_link_executable (info
)
2177 && (sec
->flags
& SEC_READONLY
) == 0)))
2178 return elf_x86_64_need_pic (info
, abfd
, sec
, h
, symtab_hdr
, isym
,
2179 &x86_64_elf_howto_table
[r_type
]);
2185 case R_X86_64_PC32_BND
:
2189 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2190 eh
->has_non_got_reloc
= 1;
2191 /* We are called after all symbols have been resolved. Only
2192 relocation against STT_GNU_IFUNC symbol must go through
2195 && (bfd_link_executable (info
)
2196 || h
->type
== STT_GNU_IFUNC
))
2198 /* If this reloc is in a read-only section, we might
2199 need a copy reloc. We can't check reliably at this
2200 stage whether the section is read-only, as input
2201 sections have not yet been mapped to output sections.
2202 Tentatively set the flag for now, and correct in
2203 adjust_dynamic_symbol. */
2206 /* We may need a .plt entry if the symbol is a function
2207 defined in a shared lib or is a STT_GNU_IFUNC function
2208 referenced from the code or read-only section. */
2210 || (sec
->flags
& (SEC_CODE
| SEC_READONLY
)) != 0)
2211 h
->plt
.refcount
+= 1;
2213 if (r_type
== R_X86_64_PC32
)
2215 /* Since something like ".long foo - ." may be used
2216 as pointer, make sure that PLT is used if foo is
2217 a function defined in a shared library. */
2218 if ((sec
->flags
& SEC_CODE
) == 0)
2219 h
->pointer_equality_needed
= 1;
2221 else if (r_type
!= R_X86_64_PC32_BND
2222 && r_type
!= R_X86_64_PC64
)
2224 h
->pointer_equality_needed
= 1;
2225 /* At run-time, R_X86_64_64 can be resolved for both
2226 x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2227 can only be resolved for x32. */
2228 if ((sec
->flags
& SEC_READONLY
) == 0
2229 && (r_type
== R_X86_64_64
2230 || (!ABI_64_P (abfd
)
2231 && (r_type
== R_X86_64_32
2232 || r_type
== R_X86_64_32S
))))
2233 eh
->func_pointer_refcount
+= 1;
2239 /* If we are creating a shared library, and this is a reloc
2240 against a global symbol, or a non PC relative reloc
2241 against a local symbol, then we need to copy the reloc
2242 into the shared library. However, if we are linking with
2243 -Bsymbolic, we do not need to copy a reloc against a
2244 global symbol which is defined in an object we are
2245 including in the link (i.e., DEF_REGULAR is set). At
2246 this point we have not seen all the input files, so it is
2247 possible that DEF_REGULAR is not set now but will be set
2248 later (it is never cleared). In case of a weak definition,
2249 DEF_REGULAR may be cleared later by a strong definition in
2250 a shared library. We account for that possibility below by
2251 storing information in the relocs_copied field of the hash
2252 table entry. A similar situation occurs when creating
2253 shared libraries and symbol visibility changes render the
2256 If on the other hand, we are creating an executable, we
2257 may need to keep relocations for symbols satisfied by a
2258 dynamic library if we manage to avoid copy relocs for the
2261 Generate dynamic pointer relocation against STT_GNU_IFUNC
2262 symbol in the non-code section. */
2263 if ((bfd_link_pic (info
)
2264 && (! IS_X86_64_PCREL_TYPE (r_type
)
2266 && (! (bfd_link_pie (info
)
2267 || SYMBOLIC_BIND (info
, h
))
2268 || h
->root
.type
== bfd_link_hash_defweak
2269 || !h
->def_regular
))))
2271 && h
->type
== STT_GNU_IFUNC
2272 && r_type
== htab
->pointer_r_type
2273 && (sec
->flags
& SEC_CODE
) == 0)
2274 || (ELIMINATE_COPY_RELOCS
2275 && !bfd_link_pic (info
)
2277 && (h
->root
.type
== bfd_link_hash_defweak
2278 || !h
->def_regular
)))
2280 struct elf_dyn_relocs
*p
;
2281 struct elf_dyn_relocs
**head
;
2283 /* We must copy these reloc types into the output file.
2284 Create a reloc section in dynobj and make room for
2288 sreloc
= _bfd_elf_make_dynamic_reloc_section
2289 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
2290 abfd
, /*rela?*/ TRUE
);
2296 /* If this is a global symbol, we count the number of
2297 relocations we need for this symbol. */
2299 head
= &eh
->dyn_relocs
;
2302 /* Track dynamic relocs needed for local syms too.
2303 We really need local syms available to do this
2308 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2313 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2317 /* Beware of type punned pointers vs strict aliasing
2319 vpp
= &(elf_section_data (s
)->local_dynrel
);
2320 head
= (struct elf_dyn_relocs
**)vpp
;
2324 if (p
== NULL
|| p
->sec
!= sec
)
2326 bfd_size_type amt
= sizeof *p
;
2328 p
= ((struct elf_dyn_relocs
*)
2329 bfd_alloc (htab
->elf
.dynobj
, amt
));
2340 /* Count size relocation as PC-relative relocation. */
2341 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
2346 /* This relocation describes the C++ object vtable hierarchy.
2347 Reconstruct it for later use during GC. */
2348 case R_X86_64_GNU_VTINHERIT
:
2349 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2353 /* This relocation describes which C++ vtable entries are actually
2354 used. Record for later use during GC. */
2355 case R_X86_64_GNU_VTENTRY
:
2356 BFD_ASSERT (h
!= NULL
);
2358 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2366 if ((r_type
== R_X86_64_GOTPCREL
2367 || r_type
== R_X86_64_GOTPCRELX
2368 || r_type
== R_X86_64_REX_GOTPCRELX
)
2369 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2370 sec
->need_convert_load
= 1;
2373 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2375 if (!info
->keep_memory
)
2379 /* Cache the section contents for elf_link_input_bfd. */
2380 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2387 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2389 sec
->check_relocs_failed
= 1;
2393 /* Convert load via the GOT slot to load immediate. */
2396 elf_x86_64_convert_load (bfd
*abfd
, asection
*sec
,
2397 struct bfd_link_info
*link_info
)
2399 Elf_Internal_Shdr
*symtab_hdr
;
2400 Elf_Internal_Rela
*internal_relocs
;
2401 Elf_Internal_Rela
*irel
, *irelend
;
2403 struct elf_x86_link_hash_table
*htab
;
2404 bfd_boolean changed
;
2405 bfd_signed_vma
*local_got_refcounts
;
2407 /* Don't even try to convert non-ELF outputs. */
2408 if (!is_elf_hash_table (link_info
->hash
))
2411 /* Nothing to do if there is no need or no output. */
2412 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
2413 || sec
->need_convert_load
== 0
2414 || bfd_is_abs_section (sec
->output_section
))
2417 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2419 /* Load the relocations for this section. */
2420 internal_relocs
= (_bfd_elf_link_read_relocs
2421 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
2422 link_info
->keep_memory
));
2423 if (internal_relocs
== NULL
)
2427 htab
= elf_x86_hash_table (link_info
, X86_64_ELF_DATA
);
2428 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2430 /* Get the section contents. */
2431 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2432 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2435 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2439 irelend
= internal_relocs
+ sec
->reloc_count
;
2440 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2442 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
2443 unsigned int r_symndx
;
2444 struct elf_link_hash_entry
*h
;
2445 bfd_boolean converted
;
2447 if (r_type
!= R_X86_64_GOTPCRELX
2448 && r_type
!= R_X86_64_REX_GOTPCRELX
2449 && r_type
!= R_X86_64_GOTPCREL
)
2452 r_symndx
= htab
->r_sym (irel
->r_info
);
2453 if (r_symndx
< symtab_hdr
->sh_info
)
2454 h
= _bfd_elf_x86_get_local_sym_hash (htab
, sec
->owner
,
2455 (const Elf_Internal_Rela
*) irel
,
2459 h
= elf_sym_hashes (abfd
)[r_symndx
- symtab_hdr
->sh_info
];
2460 while (h
->root
.type
== bfd_link_hash_indirect
2461 || h
->root
.type
== bfd_link_hash_warning
)
2462 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2465 /* STT_GNU_IFUNC must keep GOTPCREL relocations. */
2466 if (h
!= NULL
&& h
->type
== STT_GNU_IFUNC
)
2470 if (!elf_x86_64_convert_load_reloc (abfd
, sec
, contents
, irel
, h
,
2471 &converted
, link_info
))
2476 changed
= converted
;
2479 if (h
->got
.refcount
> 0)
2480 h
->got
.refcount
-= 1;
2484 if (local_got_refcounts
!= NULL
2485 && local_got_refcounts
[r_symndx
] > 0)
2486 local_got_refcounts
[r_symndx
] -= 1;
2491 if (contents
!= NULL
2492 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2494 if (!changed
&& !link_info
->keep_memory
)
2498 /* Cache the section contents for elf_link_input_bfd. */
2499 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2503 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
2506 free (internal_relocs
);
2508 elf_section_data (sec
)->relocs
= internal_relocs
;
2514 if (contents
!= NULL
2515 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2517 if (internal_relocs
!= NULL
2518 && elf_section_data (sec
)->relocs
!= internal_relocs
)
2519 free (internal_relocs
);
2523 /* Set the sizes of the dynamic sections. */
2526 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
2527 struct bfd_link_info
*info
)
2529 struct elf_x86_link_hash_table
*htab
;
2534 const struct elf_backend_data
*bed
;
2536 htab
= elf_x86_hash_table (info
, X86_64_ELF_DATA
);
2539 bed
= get_elf_backend_data (output_bfd
);
2541 dynobj
= htab
->elf
.dynobj
;
2545 /* Set up .got offsets for local syms, and space for local dynamic
2547 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2549 bfd_signed_vma
*local_got
;
2550 bfd_signed_vma
*end_local_got
;
2551 char *local_tls_type
;
2552 bfd_vma
*local_tlsdesc_gotent
;
2553 bfd_size_type locsymcount
;
2554 Elf_Internal_Shdr
*symtab_hdr
;
2557 if (! is_x86_elf (ibfd
, htab
))
2560 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2562 struct elf_dyn_relocs
*p
;
2564 if (!elf_x86_64_convert_load (ibfd
, s
, info
))
2567 for (p
= (struct elf_dyn_relocs
*)
2568 (elf_section_data (s
)->local_dynrel
);
2572 if (!bfd_is_abs_section (p
->sec
)
2573 && bfd_is_abs_section (p
->sec
->output_section
))
2575 /* Input section has been discarded, either because
2576 it is a copy of a linkonce section or due to
2577 linker script /DISCARD/, so we'll be discarding
2580 else if (p
->count
!= 0)
2582 srel
= elf_section_data (p
->sec
)->sreloc
;
2583 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
2584 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
2585 && (info
->flags
& DF_TEXTREL
) == 0)
2587 info
->flags
|= DF_TEXTREL
;
2588 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
2589 || info
->error_textrel
)
2590 /* xgettext:c-format */
2591 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
2592 p
->sec
->owner
, p
->sec
);
2598 local_got
= elf_local_got_refcounts (ibfd
);
2602 symtab_hdr
= &elf_symtab_hdr (ibfd
);
2603 locsymcount
= symtab_hdr
->sh_info
;
2604 end_local_got
= local_got
+ locsymcount
;
2605 local_tls_type
= elf_x86_local_got_tls_type (ibfd
);
2606 local_tlsdesc_gotent
= elf_x86_local_tlsdesc_gotent (ibfd
);
2608 srel
= htab
->elf
.srelgot
;
2609 for (; local_got
< end_local_got
;
2610 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
2612 *local_tlsdesc_gotent
= (bfd_vma
) -1;
2615 if (GOT_TLS_GDESC_P (*local_tls_type
))
2617 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
2618 - elf_x86_compute_jump_table_size (htab
);
2619 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
2620 *local_got
= (bfd_vma
) -2;
2622 if (! GOT_TLS_GDESC_P (*local_tls_type
)
2623 || GOT_TLS_GD_P (*local_tls_type
))
2625 *local_got
= s
->size
;
2626 s
->size
+= GOT_ENTRY_SIZE
;
2627 if (GOT_TLS_GD_P (*local_tls_type
))
2628 s
->size
+= GOT_ENTRY_SIZE
;
2630 if (bfd_link_pic (info
)
2631 || GOT_TLS_GD_ANY_P (*local_tls_type
)
2632 || *local_tls_type
== GOT_TLS_IE
)
2634 if (GOT_TLS_GDESC_P (*local_tls_type
))
2636 htab
->elf
.srelplt
->size
2637 += bed
->s
->sizeof_rela
;
2638 htab
->tlsdesc_plt
= (bfd_vma
) -1;
2640 if (! GOT_TLS_GDESC_P (*local_tls_type
)
2641 || GOT_TLS_GD_P (*local_tls_type
))
2642 srel
->size
+= bed
->s
->sizeof_rela
;
2646 *local_got
= (bfd_vma
) -1;
2650 if (htab
->tls_ld_or_ldm_got
.refcount
> 0)
2652 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
2654 htab
->tls_ld_or_ldm_got
.offset
= htab
->elf
.sgot
->size
;
2655 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
2656 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
2659 htab
->tls_ld_or_ldm_got
.offset
= -1;
2661 /* Allocate global sym .plt and .got entries, and space for global
2662 sym dynamic relocs. */
2663 elf_link_hash_traverse (&htab
->elf
, _bfd_x86_elf_allocate_dynrelocs
,
2666 /* Allocate .plt and .got entries, and space for local symbols. */
2667 htab_traverse (htab
->loc_hash_table
,
2668 _bfd_x86_elf_allocate_local_dynrelocs
,
2671 /* For every jump slot reserved in the sgotplt, reloc_count is
2672 incremented. However, when we reserve space for TLS descriptors,
2673 it's not incremented, so in order to compute the space reserved
2674 for them, it suffices to multiply the reloc count by the jump
2677 PR ld/13302: We start next_irelative_index at the end of .rela.plt
2678 so that R_X86_64_IRELATIVE entries come last. */
2679 if (htab
->elf
.srelplt
)
2681 htab
->sgotplt_jump_table_size
2682 = elf_x86_compute_jump_table_size (htab
);
2683 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
2685 else if (htab
->elf
.irelplt
)
2686 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
2688 if (htab
->tlsdesc_plt
)
2690 /* If we're not using lazy TLS relocations, don't generate the
2691 PLT and GOT entries they require. */
2692 if ((info
->flags
& DF_BIND_NOW
))
2693 htab
->tlsdesc_plt
= 0;
2696 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
2697 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
2698 /* Reserve room for the initial entry.
2699 FIXME: we could probably do away with it in this case. */
2700 if (htab
->elf
.splt
->size
== 0)
2701 htab
->elf
.splt
->size
= htab
->plt
.plt_entry_size
;
2702 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
2703 htab
->elf
.splt
->size
+= htab
->plt
.plt_entry_size
;
2707 if (htab
->elf
.sgotplt
)
2709 /* Don't allocate .got.plt section if there are no GOT nor PLT
2710 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
2711 if ((htab
->elf
.hgot
== NULL
2712 || !htab
->elf
.hgot
->ref_regular_nonweak
)
2713 && (htab
->elf
.sgotplt
->size
2714 == get_elf_backend_data (output_bfd
)->got_header_size
)
2715 && (htab
->elf
.splt
== NULL
2716 || htab
->elf
.splt
->size
== 0)
2717 && (htab
->elf
.sgot
== NULL
2718 || htab
->elf
.sgot
->size
== 0)
2719 && (htab
->elf
.iplt
== NULL
2720 || htab
->elf
.iplt
->size
== 0)
2721 && (htab
->elf
.igotplt
== NULL
2722 || htab
->elf
.igotplt
->size
== 0))
2723 htab
->elf
.sgotplt
->size
= 0;
2726 if (_bfd_elf_eh_frame_present (info
))
2728 if (htab
->plt_eh_frame
!= NULL
2729 && htab
->elf
.splt
!= NULL
2730 && htab
->elf
.splt
->size
!= 0
2731 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
))
2732 htab
->plt_eh_frame
->size
= htab
->plt
.eh_frame_plt_size
;
2734 if (htab
->plt_got_eh_frame
!= NULL
2735 && htab
->plt_got
!= NULL
2736 && htab
->plt_got
->size
!= 0
2737 && !bfd_is_abs_section (htab
->plt_got
->output_section
))
2738 htab
->plt_got_eh_frame
->size
2739 = htab
->non_lazy_plt
->eh_frame_plt_size
;
2741 /* Unwind info for the second PLT and .plt.got sections are
2743 if (htab
->plt_second_eh_frame
!= NULL
2744 && htab
->plt_second
!= NULL
2745 && htab
->plt_second
->size
!= 0
2746 && !bfd_is_abs_section (htab
->plt_second
->output_section
))
2747 htab
->plt_second_eh_frame
->size
2748 = htab
->non_lazy_plt
->eh_frame_plt_size
;
2751 /* We now have determined the sizes of the various dynamic sections.
2752 Allocate memory for them. */
2754 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2756 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2759 if (s
== htab
->elf
.splt
2760 || s
== htab
->elf
.sgot
2761 || s
== htab
->elf
.sgotplt
2762 || s
== htab
->elf
.iplt
2763 || s
== htab
->elf
.igotplt
2764 || s
== htab
->plt_second
2765 || s
== htab
->plt_got
2766 || s
== htab
->plt_eh_frame
2767 || s
== htab
->plt_got_eh_frame
2768 || s
== htab
->plt_second_eh_frame
2769 || s
== htab
->elf
.sdynbss
2770 || s
== htab
->elf
.sdynrelro
)
2772 /* Strip this section if we don't need it; see the
2775 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
2777 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
2780 /* We use the reloc_count field as a counter if we need
2781 to copy relocs into the output file. */
2782 if (s
!= htab
->elf
.srelplt
)
2787 /* It's not one of our sections, so don't allocate space. */
2793 /* If we don't need this section, strip it from the
2794 output file. This is mostly to handle .rela.bss and
2795 .rela.plt. We must create both sections in
2796 create_dynamic_sections, because they must be created
2797 before the linker maps input sections to output
2798 sections. The linker does that before
2799 adjust_dynamic_symbol is called, and it is that
2800 function which decides whether anything needs to go
2801 into these sections. */
2803 s
->flags
|= SEC_EXCLUDE
;
2807 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2810 /* Allocate memory for the section contents. We use bfd_zalloc
2811 here in case unused entries are not reclaimed before the
2812 section's contents are written out. This should not happen,
2813 but this way if it does, we get a R_X86_64_NONE reloc instead
2815 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
2816 if (s
->contents
== NULL
)
2820 if (htab
->plt_eh_frame
!= NULL
2821 && htab
->plt_eh_frame
->contents
!= NULL
)
2823 memcpy (htab
->plt_eh_frame
->contents
,
2824 htab
->plt
.eh_frame_plt
, htab
->plt_eh_frame
->size
);
2825 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
2826 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
2829 if (htab
->plt_got_eh_frame
!= NULL
2830 && htab
->plt_got_eh_frame
->contents
!= NULL
)
2832 memcpy (htab
->plt_got_eh_frame
->contents
,
2833 htab
->non_lazy_plt
->eh_frame_plt
,
2834 htab
->plt_got_eh_frame
->size
);
2835 bfd_put_32 (dynobj
, htab
->plt_got
->size
,
2836 (htab
->plt_got_eh_frame
->contents
2837 + PLT_FDE_LEN_OFFSET
));
2840 if (htab
->plt_second_eh_frame
!= NULL
2841 && htab
->plt_second_eh_frame
->contents
!= NULL
)
2843 memcpy (htab
->plt_second_eh_frame
->contents
,
2844 htab
->non_lazy_plt
->eh_frame_plt
,
2845 htab
->plt_second_eh_frame
->size
);
2846 bfd_put_32 (dynobj
, htab
->plt_second
->size
,
2847 (htab
->plt_second_eh_frame
->contents
2848 + PLT_FDE_LEN_OFFSET
));
2851 if (htab
->elf
.dynamic_sections_created
)
2853 /* Add some entries to the .dynamic section. We fill in the
2854 values later, in elf_x86_64_finish_dynamic_sections, but we
2855 must add the entries now so that we get the correct size for
2856 the .dynamic section. The DT_DEBUG entry is filled in by the
2857 dynamic linker and used by the debugger. */
2858 #define add_dynamic_entry(TAG, VAL) \
2859 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2861 if (bfd_link_executable (info
))
2863 if (!add_dynamic_entry (DT_DEBUG
, 0))
2867 if (htab
->elf
.splt
->size
!= 0)
2869 /* DT_PLTGOT is used by prelink even if there is no PLT
2871 if (!add_dynamic_entry (DT_PLTGOT
, 0))
2875 if (htab
->elf
.srelplt
->size
!= 0)
2877 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
2878 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
2879 || !add_dynamic_entry (DT_JMPREL
, 0))
2883 if (htab
->tlsdesc_plt
2884 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
2885 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
2890 if (!add_dynamic_entry (DT_RELA
, 0)
2891 || !add_dynamic_entry (DT_RELASZ
, 0)
2892 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
2895 /* If any dynamic relocs apply to a read-only section,
2896 then we need a DT_TEXTREL entry. */
2897 if ((info
->flags
& DF_TEXTREL
) == 0)
2898 elf_link_hash_traverse (&htab
->elf
,
2899 _bfd_x86_elf_readonly_dynrelocs
,
2902 if ((info
->flags
& DF_TEXTREL
) != 0)
2904 if (htab
->readonly_dynrelocs_against_ifunc
)
2906 info
->callbacks
->einfo
2907 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
2908 bfd_set_error (bfd_error_bad_value
);
2912 if (!add_dynamic_entry (DT_TEXTREL
, 0))
2917 #undef add_dynamic_entry
2922 /* Return the relocation value for @tpoff relocation
2923 if STT_TLS virtual address is ADDRESS. */
2926 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
2928 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2929 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
2930 bfd_vma static_tls_size
;
2932 /* If tls_segment is NULL, we should have signalled an error already. */
2933 if (htab
->tls_sec
== NULL
)
2936 /* Consider special static TLS alignment requirements. */
2937 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
2938 return address
- static_tls_size
- htab
->tls_sec
->vma
;
2941 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
2945 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
2947 /* Opcode Instruction
2950 0x0f 0x8x conditional jump */
2952 && (contents
[offset
- 1] == 0xe8
2953 || contents
[offset
- 1] == 0xe9))
2955 && contents
[offset
- 2] == 0x0f
2956 && (contents
[offset
- 1] & 0xf0) == 0x80));
2959 /* Relocate an x86_64 ELF section. */
2962 elf_x86_64_relocate_section (bfd
*output_bfd
,
2963 struct bfd_link_info
*info
,
2965 asection
*input_section
,
2967 Elf_Internal_Rela
*relocs
,
2968 Elf_Internal_Sym
*local_syms
,
2969 asection
**local_sections
)
2971 struct elf_x86_link_hash_table
*htab
;
2972 Elf_Internal_Shdr
*symtab_hdr
;
2973 struct elf_link_hash_entry
**sym_hashes
;
2974 bfd_vma
*local_got_offsets
;
2975 bfd_vma
*local_tlsdesc_gotents
;
2976 Elf_Internal_Rela
*rel
;
2977 Elf_Internal_Rela
*wrel
;
2978 Elf_Internal_Rela
*relend
;
2979 unsigned int plt_entry_size
;
2981 /* Skip if check_relocs failed. */
2982 if (input_section
->check_relocs_failed
)
2985 htab
= elf_x86_hash_table (info
, X86_64_ELF_DATA
);
2989 BFD_ASSERT (is_x86_elf (input_bfd
, htab
));
2991 plt_entry_size
= htab
->plt
.plt_entry_size
;
2992 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
2993 sym_hashes
= elf_sym_hashes (input_bfd
);
2994 local_got_offsets
= elf_local_got_offsets (input_bfd
);
2995 local_tlsdesc_gotents
= elf_x86_local_tlsdesc_gotent (input_bfd
);
2997 _bfd_x86_elf_set_tls_module_base (info
);
2999 rel
= wrel
= relocs
;
3000 relend
= relocs
+ input_section
->reloc_count
;
3001 for (; rel
< relend
; wrel
++, rel
++)
3003 unsigned int r_type
;
3004 reloc_howto_type
*howto
;
3005 unsigned long r_symndx
;
3006 struct elf_link_hash_entry
*h
;
3007 struct elf_x86_link_hash_entry
*eh
;
3008 Elf_Internal_Sym
*sym
;
3010 bfd_vma off
, offplt
, plt_offset
;
3012 bfd_boolean unresolved_reloc
;
3013 bfd_reloc_status_type r
;
3015 asection
*base_got
, *resolved_plt
;
3017 bfd_boolean resolved_to_zero
;
3018 bfd_boolean relative_reloc
;
3020 r_type
= ELF32_R_TYPE (rel
->r_info
);
3021 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
3022 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
3029 if (r_type
>= (int) R_X86_64_standard
)
3030 return _bfd_unrecognized_reloc (input_bfd
, input_section
, r_type
);
3032 if (r_type
!= (int) R_X86_64_32
3033 || ABI_64_P (output_bfd
))
3034 howto
= x86_64_elf_howto_table
+ r_type
;
3036 howto
= (x86_64_elf_howto_table
3037 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
3038 r_symndx
= htab
->r_sym (rel
->r_info
);
3042 unresolved_reloc
= FALSE
;
3043 if (r_symndx
< symtab_hdr
->sh_info
)
3045 sym
= local_syms
+ r_symndx
;
3046 sec
= local_sections
[r_symndx
];
3048 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
3050 st_size
= sym
->st_size
;
3052 /* Relocate against local STT_GNU_IFUNC symbol. */
3053 if (!bfd_link_relocatable (info
)
3054 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
3056 h
= _bfd_elf_x86_get_local_sym_hash (htab
, input_bfd
,
3061 /* Set STT_GNU_IFUNC symbol value. */
3062 h
->root
.u
.def
.value
= sym
->st_value
;
3063 h
->root
.u
.def
.section
= sec
;
3068 bfd_boolean warned ATTRIBUTE_UNUSED
;
3069 bfd_boolean ignored ATTRIBUTE_UNUSED
;
3071 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3072 r_symndx
, symtab_hdr
, sym_hashes
,
3074 unresolved_reloc
, warned
, ignored
);
3078 if (sec
!= NULL
&& discarded_section (sec
))
3080 _bfd_clear_contents (howto
, input_bfd
, input_section
,
3081 contents
+ rel
->r_offset
);
3082 wrel
->r_offset
= rel
->r_offset
;
3086 /* For ld -r, remove relocations in debug sections against
3087 sections defined in discarded sections. Not done for
3088 eh_frame editing code expects to be present. */
3089 if (bfd_link_relocatable (info
)
3090 && (input_section
->flags
& SEC_DEBUGGING
))
3096 if (bfd_link_relocatable (info
))
3103 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
3105 if (r_type
== R_X86_64_64
)
3107 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
3108 zero-extend it to 64bit if addend is zero. */
3109 r_type
= R_X86_64_32
;
3110 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
3112 else if (r_type
== R_X86_64_SIZE64
)
3114 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
3115 zero-extend it to 64bit if addend is zero. */
3116 r_type
= R_X86_64_SIZE32
;
3117 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
3121 eh
= (struct elf_x86_link_hash_entry
*) h
;
3123 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3124 it here if it is defined in a non-shared object. */
3126 && h
->type
== STT_GNU_IFUNC
3132 if ((input_section
->flags
& SEC_ALLOC
) == 0)
3134 /* Dynamic relocs are not propagated for SEC_DEBUGGING
3135 sections because such sections are not SEC_ALLOC and
3136 thus ld.so will not process them. */
3137 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
3147 case R_X86_64_GOTPCREL
:
3148 case R_X86_64_GOTPCRELX
:
3149 case R_X86_64_REX_GOTPCRELX
:
3150 case R_X86_64_GOTPCREL64
:
3151 base_got
= htab
->elf
.sgot
;
3152 off
= h
->got
.offset
;
3154 if (base_got
== NULL
)
3157 if (off
== (bfd_vma
) -1)
3159 /* We can't use h->got.offset here to save state, or
3160 even just remember the offset, as finish_dynamic_symbol
3161 would use that as offset into .got. */
3163 if (h
->plt
.offset
== (bfd_vma
) -1)
3166 if (htab
->elf
.splt
!= NULL
)
3168 plt_index
= (h
->plt
.offset
/ plt_entry_size
3169 - htab
->plt
.has_plt0
);
3170 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
3171 base_got
= htab
->elf
.sgotplt
;
3175 plt_index
= h
->plt
.offset
/ plt_entry_size
;
3176 off
= plt_index
* GOT_ENTRY_SIZE
;
3177 base_got
= htab
->elf
.igotplt
;
3180 if (h
->dynindx
== -1
3184 /* This references the local defitionion. We must
3185 initialize this entry in the global offset table.
3186 Since the offset must always be a multiple of 8,
3187 we use the least significant bit to record
3188 whether we have initialized it already.
3190 When doing a dynamic link, we create a .rela.got
3191 relocation entry to initialize the value. This
3192 is done in the finish_dynamic_symbol routine. */
3197 bfd_put_64 (output_bfd
, relocation
,
3198 base_got
->contents
+ off
);
3199 /* Note that this is harmless for the GOTPLT64
3200 case, as -1 | 1 still is -1. */
3206 relocation
= (base_got
->output_section
->vma
3207 + base_got
->output_offset
+ off
);
3212 if (h
->plt
.offset
== (bfd_vma
) -1)
3214 /* Handle static pointers of STT_GNU_IFUNC symbols. */
3215 if (r_type
== htab
->pointer_r_type
3216 && (input_section
->flags
& SEC_CODE
) == 0)
3217 goto do_ifunc_pointer
;
3218 goto bad_ifunc_reloc
;
3221 /* STT_GNU_IFUNC symbol must go through PLT. */
3222 if (htab
->elf
.splt
!= NULL
)
3224 if (htab
->plt_second
!= NULL
)
3226 resolved_plt
= htab
->plt_second
;
3227 plt_offset
= eh
->plt_second
.offset
;
3231 resolved_plt
= htab
->elf
.splt
;
3232 plt_offset
= h
->plt
.offset
;
3237 resolved_plt
= htab
->elf
.iplt
;
3238 plt_offset
= h
->plt
.offset
;
3241 relocation
= (resolved_plt
->output_section
->vma
3242 + resolved_plt
->output_offset
+ plt_offset
);
3248 if (h
->root
.root
.string
)
3249 name
= h
->root
.root
.string
;
3251 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3254 /* xgettext:c-format */
3255 (_("%B: relocation %s against STT_GNU_IFUNC "
3256 "symbol `%s' isn't supported"), input_bfd
,
3258 bfd_set_error (bfd_error_bad_value
);
3262 if (bfd_link_pic (info
))
3267 if (ABI_64_P (output_bfd
))
3272 if (rel
->r_addend
!= 0)
3274 if (h
->root
.root
.string
)
3275 name
= h
->root
.root
.string
;
3277 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
3280 /* xgettext:c-format */
3281 (_("%B: relocation %s against STT_GNU_IFUNC "
3282 "symbol `%s' has non-zero addend: %Ld"),
3283 input_bfd
, howto
->name
, name
, rel
->r_addend
);
3284 bfd_set_error (bfd_error_bad_value
);
3288 /* Generate dynamic relcoation only when there is a
3289 non-GOT reference in a shared object or there is no
3291 if ((bfd_link_pic (info
) && h
->non_got_ref
)
3292 || h
->plt
.offset
== (bfd_vma
) -1)
3294 Elf_Internal_Rela outrel
;
3297 /* Need a dynamic relocation to get the real function
3299 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
3303 if (outrel
.r_offset
== (bfd_vma
) -1
3304 || outrel
.r_offset
== (bfd_vma
) -2)
3307 outrel
.r_offset
+= (input_section
->output_section
->vma
3308 + input_section
->output_offset
);
3310 if (h
->dynindx
== -1
3312 || bfd_link_executable (info
))
3314 info
->callbacks
->minfo (_("Local IFUNC function `%s' in %B\n"),
3315 h
->root
.root
.string
,
3316 h
->root
.u
.def
.section
->owner
);
3318 /* This symbol is resolved locally. */
3319 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
3320 outrel
.r_addend
= (h
->root
.u
.def
.value
3321 + h
->root
.u
.def
.section
->output_section
->vma
3322 + h
->root
.u
.def
.section
->output_offset
);
3326 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
3327 outrel
.r_addend
= 0;
3330 /* Dynamic relocations are stored in
3331 1. .rela.ifunc section in PIC object.
3332 2. .rela.got section in dynamic executable.
3333 3. .rela.iplt section in static executable. */
3334 if (bfd_link_pic (info
))
3335 sreloc
= htab
->elf
.irelifunc
;
3336 else if (htab
->elf
.splt
!= NULL
)
3337 sreloc
= htab
->elf
.srelgot
;
3339 sreloc
= htab
->elf
.irelplt
;
3340 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3342 /* If this reloc is against an external symbol, we
3343 do not want to fiddle with the addend. Otherwise,
3344 we need to include the symbol value so that it
3345 becomes an addend for the dynamic reloc. For an
3346 internal symbol, we have updated addend. */
3351 case R_X86_64_PC32_BND
:
3353 case R_X86_64_PLT32
:
3354 case R_X86_64_PLT32_BND
:
3359 resolved_to_zero
= (eh
!= NULL
3360 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
3365 /* When generating a shared object, the relocations handled here are
3366 copied into the output file to be resolved at run time. */
3369 case R_X86_64_GOT32
:
3370 case R_X86_64_GOT64
:
3371 /* Relocation is to the entry for this symbol in the global
3373 case R_X86_64_GOTPCREL
:
3374 case R_X86_64_GOTPCRELX
:
3375 case R_X86_64_REX_GOTPCRELX
:
3376 case R_X86_64_GOTPCREL64
:
3377 /* Use global offset table entry as symbol value. */
3378 case R_X86_64_GOTPLT64
:
3379 /* This is obsolete and treated the same as GOT64. */
3380 base_got
= htab
->elf
.sgot
;
3382 if (htab
->elf
.sgot
== NULL
)
3385 relative_reloc
= FALSE
;
3390 off
= h
->got
.offset
;
3392 && h
->plt
.offset
!= (bfd_vma
)-1
3393 && off
== (bfd_vma
)-1)
3395 /* We can't use h->got.offset here to save
3396 state, or even just remember the offset, as
3397 finish_dynamic_symbol would use that as offset into
3399 bfd_vma plt_index
= (h
->plt
.offset
/ plt_entry_size
3400 - htab
->plt
.has_plt0
);
3401 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
3402 base_got
= htab
->elf
.sgotplt
;
3405 dyn
= htab
->elf
.dynamic_sections_created
;
3407 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
3408 || (bfd_link_pic (info
)
3409 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3410 || (ELF_ST_VISIBILITY (h
->other
)
3411 && h
->root
.type
== bfd_link_hash_undefweak
))
3413 /* This is actually a static link, or it is a -Bsymbolic
3414 link and the symbol is defined locally, or the symbol
3415 was forced to be local because of a version file. We
3416 must initialize this entry in the global offset table.
3417 Since the offset must always be a multiple of 8, we
3418 use the least significant bit to record whether we
3419 have initialized it already.
3421 When doing a dynamic link, we create a .rela.got
3422 relocation entry to initialize the value. This is
3423 done in the finish_dynamic_symbol routine. */
3428 bfd_put_64 (output_bfd
, relocation
,
3429 base_got
->contents
+ off
);
3430 /* Note that this is harmless for the GOTPLT64 case,
3431 as -1 | 1 still is -1. */
3434 if (h
->dynindx
== -1
3436 && h
->root
.type
!= bfd_link_hash_undefweak
3437 && bfd_link_pic (info
))
3439 /* If this symbol isn't dynamic in PIC,
3440 generate R_X86_64_RELATIVE here. */
3441 eh
->no_finish_dynamic_symbol
= 1;
3442 relative_reloc
= TRUE
;
3447 unresolved_reloc
= FALSE
;
3451 if (local_got_offsets
== NULL
)
3454 off
= local_got_offsets
[r_symndx
];
3456 /* The offset must always be a multiple of 8. We use
3457 the least significant bit to record whether we have
3458 already generated the necessary reloc. */
3463 bfd_put_64 (output_bfd
, relocation
,
3464 base_got
->contents
+ off
);
3465 local_got_offsets
[r_symndx
] |= 1;
3467 if (bfd_link_pic (info
))
3468 relative_reloc
= TRUE
;
3475 Elf_Internal_Rela outrel
;
3477 /* We need to generate a R_X86_64_RELATIVE reloc
3478 for the dynamic linker. */
3479 s
= htab
->elf
.srelgot
;
3483 outrel
.r_offset
= (base_got
->output_section
->vma
3484 + base_got
->output_offset
3486 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
3487 outrel
.r_addend
= relocation
;
3488 elf_append_rela (output_bfd
, s
, &outrel
);
3491 if (off
>= (bfd_vma
) -2)
3494 relocation
= base_got
->output_section
->vma
3495 + base_got
->output_offset
+ off
;
3496 if (r_type
!= R_X86_64_GOTPCREL
3497 && r_type
!= R_X86_64_GOTPCRELX
3498 && r_type
!= R_X86_64_REX_GOTPCRELX
3499 && r_type
!= R_X86_64_GOTPCREL64
)
3500 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3501 - htab
->elf
.sgotplt
->output_offset
;
3505 case R_X86_64_GOTOFF64
:
3506 /* Relocation is relative to the start of the global offset
3509 /* Check to make sure it isn't a protected function or data
3510 symbol for shared library since it may not be local when
3511 used as function address or with copy relocation. We also
3512 need to make sure that a symbol is referenced locally. */
3513 if (bfd_link_pic (info
) && h
)
3515 if (!h
->def_regular
)
3519 switch (ELF_ST_VISIBILITY (h
->other
))
3522 v
= _("hidden symbol");
3525 v
= _("internal symbol");
3528 v
= _("protected symbol");
3536 /* xgettext:c-format */
3537 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s"
3538 " `%s' can not be used when making a shared object"),
3539 input_bfd
, v
, h
->root
.root
.string
);
3540 bfd_set_error (bfd_error_bad_value
);
3543 else if (!bfd_link_executable (info
)
3544 && !SYMBOL_REFERENCES_LOCAL (info
, h
)
3545 && (h
->type
== STT_FUNC
3546 || h
->type
== STT_OBJECT
)
3547 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
3550 /* xgettext:c-format */
3551 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s"
3552 " `%s' can not be used when making a shared object"),
3554 h
->type
== STT_FUNC
? "function" : "data",
3555 h
->root
.root
.string
);
3556 bfd_set_error (bfd_error_bad_value
);
3561 /* Note that sgot is not involved in this
3562 calculation. We always want the start of .got.plt. If we
3563 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3564 permitted by the ABI, we might have to change this
3566 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3567 + htab
->elf
.sgotplt
->output_offset
;
3570 case R_X86_64_GOTPC32
:
3571 case R_X86_64_GOTPC64
:
3572 /* Use global offset table as symbol value. */
3573 relocation
= htab
->elf
.sgotplt
->output_section
->vma
3574 + htab
->elf
.sgotplt
->output_offset
;
3575 unresolved_reloc
= FALSE
;
3578 case R_X86_64_PLTOFF64
:
3579 /* Relocation is PLT entry relative to GOT. For local
3580 symbols it's the symbol itself relative to GOT. */
3582 /* See PLT32 handling. */
3583 && (h
->plt
.offset
!= (bfd_vma
) -1
3584 || eh
->plt_got
.offset
!= (bfd_vma
) -1)
3585 && htab
->elf
.splt
!= NULL
)
3587 if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
3589 /* Use the GOT PLT. */
3590 resolved_plt
= htab
->plt_got
;
3591 plt_offset
= eh
->plt_got
.offset
;
3593 else if (htab
->plt_second
!= NULL
)
3595 resolved_plt
= htab
->plt_second
;
3596 plt_offset
= eh
->plt_second
.offset
;
3600 resolved_plt
= htab
->elf
.splt
;
3601 plt_offset
= h
->plt
.offset
;
3604 relocation
= (resolved_plt
->output_section
->vma
3605 + resolved_plt
->output_offset
3607 unresolved_reloc
= FALSE
;
3610 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
3611 + htab
->elf
.sgotplt
->output_offset
;
3614 case R_X86_64_PLT32
:
3615 case R_X86_64_PLT32_BND
:
3616 /* Relocation is to the entry for this symbol in the
3617 procedure linkage table. */
3619 /* Resolve a PLT32 reloc against a local symbol directly,
3620 without using the procedure linkage table. */
3624 if ((h
->plt
.offset
== (bfd_vma
) -1
3625 && eh
->plt_got
.offset
== (bfd_vma
) -1)
3626 || htab
->elf
.splt
== NULL
)
3628 /* We didn't make a PLT entry for this symbol. This
3629 happens when statically linking PIC code, or when
3630 using -Bsymbolic. */
3634 if (h
->plt
.offset
!= (bfd_vma
) -1)
3636 if (htab
->plt_second
!= NULL
)
3638 resolved_plt
= htab
->plt_second
;
3639 plt_offset
= eh
->plt_second
.offset
;
3643 resolved_plt
= htab
->elf
.splt
;
3644 plt_offset
= h
->plt
.offset
;
3649 /* Use the GOT PLT. */
3650 resolved_plt
= htab
->plt_got
;
3651 plt_offset
= eh
->plt_got
.offset
;
3654 relocation
= (resolved_plt
->output_section
->vma
3655 + resolved_plt
->output_offset
3657 unresolved_reloc
= FALSE
;
3660 case R_X86_64_SIZE32
:
3661 case R_X86_64_SIZE64
:
3662 /* Set to symbol size. */
3663 relocation
= st_size
;
3669 case R_X86_64_PC32_BND
:
3670 /* Don't complain about -fPIC if the symbol is undefined when
3671 building executable unless it is unresolved weak symbol or
3672 -z nocopyreloc is used. */
3673 if ((input_section
->flags
& SEC_ALLOC
) != 0
3674 && (input_section
->flags
& SEC_READONLY
) != 0
3676 && ((bfd_link_executable (info
)
3677 && ((h
->root
.type
== bfd_link_hash_undefweak
3678 && !resolved_to_zero
)
3679 || ((info
->nocopyreloc
3680 || (eh
->def_protected
3681 && elf_has_no_copy_on_protected (h
->root
.u
.def
.section
->owner
)))
3683 && !(h
->root
.u
.def
.section
->flags
& SEC_CODE
))))
3684 || bfd_link_dll (info
)))
3686 bfd_boolean fail
= FALSE
;
3688 = ((r_type
== R_X86_64_PC32
3689 || r_type
== R_X86_64_PC32_BND
)
3690 && is_32bit_relative_branch (contents
, rel
->r_offset
));
3692 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
3694 /* Symbol is referenced locally. Make sure it is
3695 defined locally or for a branch. */
3696 fail
= (!(h
->def_regular
|| ELF_COMMON_DEF_P (h
))
3699 else if (!(bfd_link_pie (info
)
3700 && (h
->needs_copy
|| eh
->needs_copy
)))
3702 /* Symbol doesn't need copy reloc and isn't referenced
3703 locally. We only allow branch to symbol with
3704 non-default visibility. */
3706 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
3710 return elf_x86_64_need_pic (info
, input_bfd
, input_section
,
3711 h
, NULL
, NULL
, howto
);
3720 /* FIXME: The ABI says the linker should make sure the value is
3721 the same when it's zeroextended to 64 bit. */
3724 if ((input_section
->flags
& SEC_ALLOC
) == 0)
3727 /* Don't copy a pc-relative relocation into the output file
3728 if the symbol needs copy reloc or the symbol is undefined
3729 when building executable. Copy dynamic function pointer
3730 relocations. Don't generate dynamic relocations against
3731 resolved undefined weak symbols in PIE. */
3732 if ((bfd_link_pic (info
)
3733 && !(bfd_link_pie (info
)
3737 || h
->root
.type
== bfd_link_hash_undefined
)
3738 && (IS_X86_64_PCREL_TYPE (r_type
)
3739 || r_type
== R_X86_64_SIZE32
3740 || r_type
== R_X86_64_SIZE64
))
3742 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3743 && !resolved_to_zero
)
3744 || h
->root
.type
!= bfd_link_hash_undefweak
))
3745 && ((! IS_X86_64_PCREL_TYPE (r_type
)
3746 && r_type
!= R_X86_64_SIZE32
3747 && r_type
!= R_X86_64_SIZE64
)
3748 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
3749 || (ELIMINATE_COPY_RELOCS
3750 && !bfd_link_pic (info
)
3754 || eh
->func_pointer_refcount
> 0
3755 || (h
->root
.type
== bfd_link_hash_undefweak
3756 && !resolved_to_zero
))
3757 && ((h
->def_dynamic
&& !h
->def_regular
)
3758 /* Undefined weak symbol is bound locally when
3760 || h
->root
.type
== bfd_link_hash_undefined
)))
3762 Elf_Internal_Rela outrel
;
3763 bfd_boolean skip
, relocate
;
3766 /* When generating a shared object, these relocations
3767 are copied into the output file to be resolved at run
3773 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3775 if (outrel
.r_offset
== (bfd_vma
) -1)
3777 else if (outrel
.r_offset
== (bfd_vma
) -2)
3778 skip
= TRUE
, relocate
= TRUE
;
3780 outrel
.r_offset
+= (input_section
->output_section
->vma
3781 + input_section
->output_offset
);
3784 memset (&outrel
, 0, sizeof outrel
);
3786 /* h->dynindx may be -1 if this symbol was marked to
3790 && (IS_X86_64_PCREL_TYPE (r_type
)
3791 || !(bfd_link_executable (info
)
3792 || SYMBOLIC_BIND (info
, h
))
3793 || ! h
->def_regular
))
3795 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
3796 outrel
.r_addend
= rel
->r_addend
;
3800 /* This symbol is local, or marked to become local.
3801 When relocation overflow check is disabled, we
3802 convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */
3803 if (r_type
== htab
->pointer_r_type
3804 || (r_type
== R_X86_64_32
3805 && info
->no_reloc_overflow_check
))
3808 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
3809 outrel
.r_addend
= relocation
+ rel
->r_addend
;
3811 else if (r_type
== R_X86_64_64
3812 && !ABI_64_P (output_bfd
))
3815 outrel
.r_info
= htab
->r_info (0,
3816 R_X86_64_RELATIVE64
);
3817 outrel
.r_addend
= relocation
+ rel
->r_addend
;
3818 /* Check addend overflow. */
3819 if ((outrel
.r_addend
& 0x80000000)
3820 != (rel
->r_addend
& 0x80000000))
3823 int addend
= rel
->r_addend
;
3824 if (h
&& h
->root
.root
.string
)
3825 name
= h
->root
.root
.string
;
3827 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
3830 /* xgettext:c-format */
3831 (_("%B: addend %s%#x in relocation %s against "
3832 "symbol `%s' at %#Lx in section `%A' is "
3834 input_bfd
, addend
< 0 ? "-" : "", addend
,
3835 howto
->name
, name
, rel
->r_offset
, input_section
);
3836 bfd_set_error (bfd_error_bad_value
);
3844 if (bfd_is_abs_section (sec
))
3846 else if (sec
== NULL
|| sec
->owner
== NULL
)
3848 bfd_set_error (bfd_error_bad_value
);
3855 /* We are turning this relocation into one
3856 against a section symbol. It would be
3857 proper to subtract the symbol's value,
3858 osec->vma, from the emitted reloc addend,
3859 but ld.so expects buggy relocs. */
3860 osec
= sec
->output_section
;
3861 sindx
= elf_section_data (osec
)->dynindx
;
3864 asection
*oi
= htab
->elf
.text_index_section
;
3865 sindx
= elf_section_data (oi
)->dynindx
;
3867 BFD_ASSERT (sindx
!= 0);
3870 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
3871 outrel
.r_addend
= relocation
+ rel
->r_addend
;
3875 sreloc
= elf_section_data (input_section
)->sreloc
;
3877 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
3879 r
= bfd_reloc_notsupported
;
3880 goto check_relocation_error
;
3883 elf_append_rela (output_bfd
, sreloc
, &outrel
);
3885 /* If this reloc is against an external symbol, we do
3886 not want to fiddle with the addend. Otherwise, we
3887 need to include the symbol value so that it becomes
3888 an addend for the dynamic reloc. */
3895 case R_X86_64_TLSGD
:
3896 case R_X86_64_GOTPC32_TLSDESC
:
3897 case R_X86_64_TLSDESC_CALL
:
3898 case R_X86_64_GOTTPOFF
:
3899 tls_type
= GOT_UNKNOWN
;
3900 if (h
== NULL
&& local_got_offsets
)
3901 tls_type
= elf_x86_local_got_tls_type (input_bfd
) [r_symndx
];
3903 tls_type
= elf_x86_hash_entry (h
)->tls_type
;
3905 if (! elf_x86_64_tls_transition (info
, input_bfd
,
3906 input_section
, contents
,
3907 symtab_hdr
, sym_hashes
,
3908 &r_type
, tls_type
, rel
,
3909 relend
, h
, r_symndx
, TRUE
))
3912 if (r_type
== R_X86_64_TPOFF32
)
3914 bfd_vma roff
= rel
->r_offset
;
3916 BFD_ASSERT (! unresolved_reloc
);
3918 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
3920 /* GD->LE transition. For 64bit, change
3921 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3922 .word 0x6666; rex64; call __tls_get_addr@PLT
3924 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3926 call *__tls_get_addr@GOTPCREL(%rip)
3927 which may be converted to
3928 addr32 call __tls_get_addr
3931 leaq foo@tpoff(%rax), %rax
3933 leaq foo@tlsgd(%rip), %rdi
3934 .word 0x6666; rex64; call __tls_get_addr@PLT
3936 leaq foo@tlsgd(%rip), %rdi
3938 call *__tls_get_addr@GOTPCREL(%rip)
3939 which may be converted to
3940 addr32 call __tls_get_addr
3943 leaq foo@tpoff(%rax), %rax
3944 For largepic, change:
3945 leaq foo@tlsgd(%rip), %rdi
3946 movabsq $__tls_get_addr@pltoff, %rax
3951 leaq foo@tpoff(%rax), %rax
3952 nopw 0x0(%rax,%rax,1) */
3954 if (ABI_64_P (output_bfd
))
3956 if (contents
[roff
+ 5] == 0xb8)
3958 memcpy (contents
+ roff
- 3,
3959 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
3960 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
3964 memcpy (contents
+ roff
- 4,
3965 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3969 memcpy (contents
+ roff
- 3,
3970 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3972 bfd_put_32 (output_bfd
,
3973 elf_x86_64_tpoff (info
, relocation
),
3974 contents
+ roff
+ 8 + largepic
);
3975 /* Skip R_X86_64_PC32, R_X86_64_PLT32,
3976 R_X86_64_GOTPCRELX and R_X86_64_PLTOFF64. */
3981 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
3983 /* GDesc -> LE transition.
3984 It's originally something like:
3985 leaq x@tlsdesc(%rip), %rax
3988 movl $x@tpoff, %rax. */
3990 unsigned int val
, type
;
3992 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
3993 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
3994 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
3995 contents
+ roff
- 3);
3996 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
3997 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
3998 contents
+ roff
- 1);
3999 bfd_put_32 (output_bfd
,
4000 elf_x86_64_tpoff (info
, relocation
),
4004 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
4006 /* GDesc -> LE transition.
4011 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4012 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4015 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
4017 /* IE->LE transition:
4018 For 64bit, originally it can be one of:
4019 movq foo@gottpoff(%rip), %reg
4020 addq foo@gottpoff(%rip), %reg
4023 leaq foo(%reg), %reg
4025 For 32bit, originally it can be one of:
4026 movq foo@gottpoff(%rip), %reg
4027 addl foo@gottpoff(%rip), %reg
4030 leal foo(%reg), %reg
4033 unsigned int val
, type
, reg
;
4036 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
4039 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
4040 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
4046 bfd_put_8 (output_bfd
, 0x49,
4047 contents
+ roff
- 3);
4048 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4049 bfd_put_8 (output_bfd
, 0x41,
4050 contents
+ roff
- 3);
4051 bfd_put_8 (output_bfd
, 0xc7,
4052 contents
+ roff
- 2);
4053 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4054 contents
+ roff
- 1);
4058 /* addq/addl -> addq/addl - addressing with %rsp/%r12
4061 bfd_put_8 (output_bfd
, 0x49,
4062 contents
+ roff
- 3);
4063 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4064 bfd_put_8 (output_bfd
, 0x41,
4065 contents
+ roff
- 3);
4066 bfd_put_8 (output_bfd
, 0x81,
4067 contents
+ roff
- 2);
4068 bfd_put_8 (output_bfd
, 0xc0 | reg
,
4069 contents
+ roff
- 1);
4073 /* addq/addl -> leaq/leal */
4075 bfd_put_8 (output_bfd
, 0x4d,
4076 contents
+ roff
- 3);
4077 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
4078 bfd_put_8 (output_bfd
, 0x45,
4079 contents
+ roff
- 3);
4080 bfd_put_8 (output_bfd
, 0x8d,
4081 contents
+ roff
- 2);
4082 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
4083 contents
+ roff
- 1);
4085 bfd_put_32 (output_bfd
,
4086 elf_x86_64_tpoff (info
, relocation
),
4094 if (htab
->elf
.sgot
== NULL
)
4099 off
= h
->got
.offset
;
4100 offplt
= elf_x86_hash_entry (h
)->tlsdesc_got
;
4104 if (local_got_offsets
== NULL
)
4107 off
= local_got_offsets
[r_symndx
];
4108 offplt
= local_tlsdesc_gotents
[r_symndx
];
4115 Elf_Internal_Rela outrel
;
4119 if (htab
->elf
.srelgot
== NULL
)
4122 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
4124 if (GOT_TLS_GDESC_P (tls_type
))
4126 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
4127 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
4128 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
4129 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
4130 + htab
->elf
.sgotplt
->output_offset
4132 + htab
->sgotplt_jump_table_size
);
4133 sreloc
= htab
->elf
.srelplt
;
4135 outrel
.r_addend
= relocation
- _bfd_x86_elf_dtpoff_base (info
);
4137 outrel
.r_addend
= 0;
4138 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4141 sreloc
= htab
->elf
.srelgot
;
4143 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4144 + htab
->elf
.sgot
->output_offset
+ off
);
4146 if (GOT_TLS_GD_P (tls_type
))
4147 dr_type
= R_X86_64_DTPMOD64
;
4148 else if (GOT_TLS_GDESC_P (tls_type
))
4151 dr_type
= R_X86_64_TPOFF64
;
4153 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
4154 outrel
.r_addend
= 0;
4155 if ((dr_type
== R_X86_64_TPOFF64
4156 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
4157 outrel
.r_addend
= relocation
- _bfd_x86_elf_dtpoff_base (info
);
4158 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
4160 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4162 if (GOT_TLS_GD_P (tls_type
))
4166 BFD_ASSERT (! unresolved_reloc
);
4167 bfd_put_64 (output_bfd
,
4168 relocation
- _bfd_x86_elf_dtpoff_base (info
),
4169 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4173 bfd_put_64 (output_bfd
, 0,
4174 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4175 outrel
.r_info
= htab
->r_info (indx
,
4177 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
4178 elf_append_rela (output_bfd
, sreloc
,
4187 local_got_offsets
[r_symndx
] |= 1;
4190 if (off
>= (bfd_vma
) -2
4191 && ! GOT_TLS_GDESC_P (tls_type
))
4193 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
4195 if (r_type
== R_X86_64_GOTPC32_TLSDESC
4196 || r_type
== R_X86_64_TLSDESC_CALL
)
4197 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4198 + htab
->elf
.sgotplt
->output_offset
4199 + offplt
+ htab
->sgotplt_jump_table_size
;
4201 relocation
= htab
->elf
.sgot
->output_section
->vma
4202 + htab
->elf
.sgot
->output_offset
+ off
;
4203 unresolved_reloc
= FALSE
;
4207 bfd_vma roff
= rel
->r_offset
;
4209 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
4211 /* GD->IE transition. For 64bit, change
4212 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4213 .word 0x6666; rex64; call __tls_get_addr@PLT
4215 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4217 call *__tls_get_addr@GOTPCREL(%rip
4218 which may be converted to
4219 addr32 call __tls_get_addr
4222 addq foo@gottpoff(%rip), %rax
4224 leaq foo@tlsgd(%rip), %rdi
4225 .word 0x6666; rex64; call __tls_get_addr@PLT
4227 leaq foo@tlsgd(%rip), %rdi
4229 call *__tls_get_addr@GOTPCREL(%rip)
4230 which may be converted to
4231 addr32 call __tls_get_addr
4234 addq foo@gottpoff(%rip), %rax
4235 For largepic, change:
4236 leaq foo@tlsgd(%rip), %rdi
4237 movabsq $__tls_get_addr@pltoff, %rax
4242 addq foo@gottpoff(%rax), %rax
4243 nopw 0x0(%rax,%rax,1) */
4245 if (ABI_64_P (output_bfd
))
4247 if (contents
[roff
+ 5] == 0xb8)
4249 memcpy (contents
+ roff
- 3,
4250 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
4251 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
4255 memcpy (contents
+ roff
- 4,
4256 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4260 memcpy (contents
+ roff
- 3,
4261 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4264 relocation
= (htab
->elf
.sgot
->output_section
->vma
4265 + htab
->elf
.sgot
->output_offset
+ off
4268 - input_section
->output_section
->vma
4269 - input_section
->output_offset
4271 bfd_put_32 (output_bfd
, relocation
,
4272 contents
+ roff
+ 8 + largepic
);
4273 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
4278 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
4280 /* GDesc -> IE transition.
4281 It's originally something like:
4282 leaq x@tlsdesc(%rip), %rax
4285 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
4287 /* Now modify the instruction as appropriate. To
4288 turn a leaq into a movq in the form we use it, it
4289 suffices to change the second byte from 0x8d to
4291 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
4293 bfd_put_32 (output_bfd
,
4294 htab
->elf
.sgot
->output_section
->vma
4295 + htab
->elf
.sgot
->output_offset
+ off
4297 - input_section
->output_section
->vma
4298 - input_section
->output_offset
4303 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
4305 /* GDesc -> IE transition.
4312 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
4313 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
4321 case R_X86_64_TLSLD
:
4322 if (! elf_x86_64_tls_transition (info
, input_bfd
,
4323 input_section
, contents
,
4324 symtab_hdr
, sym_hashes
,
4325 &r_type
, GOT_UNKNOWN
, rel
,
4326 relend
, h
, r_symndx
, TRUE
))
4329 if (r_type
!= R_X86_64_TLSLD
)
4331 /* LD->LE transition:
4332 leaq foo@tlsld(%rip), %rdi
4333 call __tls_get_addr@PLT
4334 For 64bit, we change it into:
4335 .word 0x6666; .byte 0x66; movq %fs:0, %rax
4336 For 32bit, we change it into:
4337 nopl 0x0(%rax); movl %fs:0, %eax
4339 leaq foo@tlsld(%rip), %rdi;
4340 call *__tls_get_addr@GOTPCREL(%rip)
4341 which may be converted to
4342 addr32 call __tls_get_addr
4343 For 64bit, we change it into:
4344 .word 0x6666; .word 0x6666; movq %fs:0, %rax
4345 For 32bit, we change it into:
4346 nopw 0x0(%rax); movl %fs:0, %eax
4347 For largepic, change:
4348 leaq foo@tlsgd(%rip), %rdi
4349 movabsq $__tls_get_addr@pltoff, %rax
4353 data16 data16 data16 nopw %cs:0x0(%rax,%rax,1)
4356 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
4357 if (ABI_64_P (output_bfd
))
4359 if (contents
[rel
->r_offset
+ 5] == 0xb8)
4360 memcpy (contents
+ rel
->r_offset
- 3,
4361 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
4362 "\x64\x48\x8b\x04\x25\0\0\0", 22);
4363 else if (contents
[rel
->r_offset
+ 4] == 0xff
4364 || contents
[rel
->r_offset
+ 4] == 0x67)
4365 memcpy (contents
+ rel
->r_offset
- 3,
4366 "\x66\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0",
4369 memcpy (contents
+ rel
->r_offset
- 3,
4370 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
4374 if (contents
[rel
->r_offset
+ 4] == 0xff)
4375 memcpy (contents
+ rel
->r_offset
- 3,
4376 "\x66\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0",
4379 memcpy (contents
+ rel
->r_offset
- 3,
4380 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
4382 /* Skip R_X86_64_PC32, R_X86_64_PLT32, R_X86_64_GOTPCRELX
4383 and R_X86_64_PLTOFF64. */
4389 if (htab
->elf
.sgot
== NULL
)
4392 off
= htab
->tls_ld_or_ldm_got
.offset
;
4397 Elf_Internal_Rela outrel
;
4399 if (htab
->elf
.srelgot
== NULL
)
4402 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4403 + htab
->elf
.sgot
->output_offset
+ off
);
4405 bfd_put_64 (output_bfd
, 0,
4406 htab
->elf
.sgot
->contents
+ off
);
4407 bfd_put_64 (output_bfd
, 0,
4408 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
4409 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
4410 outrel
.r_addend
= 0;
4411 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
4413 htab
->tls_ld_or_ldm_got
.offset
|= 1;
4415 relocation
= htab
->elf
.sgot
->output_section
->vma
4416 + htab
->elf
.sgot
->output_offset
+ off
;
4417 unresolved_reloc
= FALSE
;
4420 case R_X86_64_DTPOFF32
:
4421 if (!bfd_link_executable (info
)
4422 || (input_section
->flags
& SEC_CODE
) == 0)
4423 relocation
-= _bfd_x86_elf_dtpoff_base (info
);
4425 relocation
= elf_x86_64_tpoff (info
, relocation
);
4428 case R_X86_64_TPOFF32
:
4429 case R_X86_64_TPOFF64
:
4430 BFD_ASSERT (bfd_link_executable (info
));
4431 relocation
= elf_x86_64_tpoff (info
, relocation
);
4434 case R_X86_64_DTPOFF64
:
4435 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
4436 relocation
-= _bfd_x86_elf_dtpoff_base (info
);
4443 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4444 because such sections are not SEC_ALLOC and thus ld.so will
4445 not process them. */
4446 if (unresolved_reloc
4447 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
4449 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4450 rel
->r_offset
) != (bfd_vma
) -1)
4455 sec
= h
->root
.u
.def
.section
;
4456 if ((info
->nocopyreloc
4457 || (eh
->def_protected
4458 && elf_has_no_copy_on_protected (h
->root
.u
.def
.section
->owner
)))
4459 && !(h
->root
.u
.def
.section
->flags
& SEC_CODE
))
4460 return elf_x86_64_need_pic (info
, input_bfd
, input_section
,
4461 h
, NULL
, NULL
, howto
);
4466 /* xgettext:c-format */
4467 (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
4472 h
->root
.root
.string
);
4478 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4479 contents
, rel
->r_offset
,
4480 relocation
, rel
->r_addend
);
4482 check_relocation_error
:
4483 if (r
!= bfd_reloc_ok
)
4488 name
= h
->root
.root
.string
;
4491 name
= bfd_elf_string_from_elf_section (input_bfd
,
4492 symtab_hdr
->sh_link
,
4497 name
= bfd_section_name (input_bfd
, sec
);
4500 if (r
== bfd_reloc_overflow
)
4501 (*info
->callbacks
->reloc_overflow
)
4502 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
4503 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
4507 /* xgettext:c-format */
4508 (_("%B(%A+%#Lx): reloc against `%s': error %d"),
4509 input_bfd
, input_section
,
4510 rel
->r_offset
, name
, (int) r
);
4521 Elf_Internal_Shdr
*rel_hdr
;
4522 size_t deleted
= rel
- wrel
;
4524 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
4525 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
4526 if (rel_hdr
->sh_size
== 0)
4528 /* It is too late to remove an empty reloc section. Leave
4530 ??? What is wrong with an empty section??? */
4531 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
4534 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
4535 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
4536 input_section
->reloc_count
-= deleted
;
4542 /* Finish up dynamic symbol handling. We set the contents of various
4543 dynamic sections here. */
4546 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
4547 struct bfd_link_info
*info
,
4548 struct elf_link_hash_entry
*h
,
4549 Elf_Internal_Sym
*sym
)
4551 struct elf_x86_link_hash_table
*htab
;
4552 bfd_boolean use_plt_second
;
4553 struct elf_x86_link_hash_entry
*eh
;
4554 bfd_boolean local_undefweak
;
4556 htab
= elf_x86_hash_table (info
, X86_64_ELF_DATA
);
4560 /* Use the second PLT section only if there is .plt section. */
4561 use_plt_second
= htab
->elf
.splt
!= NULL
&& htab
->plt_second
!= NULL
;
4563 eh
= (struct elf_x86_link_hash_entry
*) h
;
4564 if (eh
->no_finish_dynamic_symbol
)
4567 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
4568 resolved undefined weak symbols in executable so that their
4569 references have value 0 at run-time. */
4570 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
4575 if (h
->plt
.offset
!= (bfd_vma
) -1)
4578 bfd_vma got_offset
, plt_offset
;
4579 Elf_Internal_Rela rela
;
4581 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
4582 const struct elf_backend_data
*bed
;
4583 bfd_vma plt_got_pcrel_offset
;
4585 /* When building a static executable, use .iplt, .igot.plt and
4586 .rela.iplt sections for STT_GNU_IFUNC symbols. */
4587 if (htab
->elf
.splt
!= NULL
)
4589 plt
= htab
->elf
.splt
;
4590 gotplt
= htab
->elf
.sgotplt
;
4591 relplt
= htab
->elf
.srelplt
;
4595 plt
= htab
->elf
.iplt
;
4596 gotplt
= htab
->elf
.igotplt
;
4597 relplt
= htab
->elf
.irelplt
;
4600 /* This symbol has an entry in the procedure linkage table. Set
4602 if ((h
->dynindx
== -1
4604 && !((h
->forced_local
|| bfd_link_executable (info
))
4606 && h
->type
== STT_GNU_IFUNC
))
4612 /* Get the index in the procedure linkage table which
4613 corresponds to this symbol. This is the index of this symbol
4614 in all the symbols for which we are making plt entries. The
4615 first entry in the procedure linkage table is reserved.
4617 Get the offset into the .got table of the entry that
4618 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
4619 bytes. The first three are reserved for the dynamic linker.
4621 For static executables, we don't reserve anything. */
4623 if (plt
== htab
->elf
.splt
)
4625 got_offset
= (h
->plt
.offset
/ htab
->plt
.plt_entry_size
4626 - htab
->plt
.has_plt0
);
4627 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
4631 got_offset
= h
->plt
.offset
/ htab
->plt
.plt_entry_size
;
4632 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
4635 /* Fill in the entry in the procedure linkage table. */
4636 memcpy (plt
->contents
+ h
->plt
.offset
, htab
->plt
.plt_entry
,
4637 htab
->plt
.plt_entry_size
);
4640 memcpy (htab
->plt_second
->contents
+ eh
->plt_second
.offset
,
4641 htab
->non_lazy_plt
->plt_entry
,
4642 htab
->non_lazy_plt
->plt_entry_size
);
4644 resolved_plt
= htab
->plt_second
;
4645 plt_offset
= eh
->plt_second
.offset
;
4650 plt_offset
= h
->plt
.offset
;
4653 /* Insert the relocation positions of the plt section. */
4655 /* Put offset the PC-relative instruction referring to the GOT entry,
4656 subtracting the size of that instruction. */
4657 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
4658 + gotplt
->output_offset
4660 - resolved_plt
->output_section
->vma
4661 - resolved_plt
->output_offset
4663 - htab
->plt
.plt_got_insn_size
);
4665 /* Check PC-relative offset overflow in PLT entry. */
4666 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
4667 /* xgettext:c-format */
4668 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
4669 output_bfd
, h
->root
.root
.string
);
4671 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
4672 (resolved_plt
->contents
+ plt_offset
4673 + htab
->plt
.plt_got_offset
));
4675 /* Fill in the entry in the global offset table, initially this
4676 points to the second part of the PLT entry. Leave the entry
4677 as zero for undefined weak symbol in PIE. No PLT relocation
4678 against undefined weak symbol in PIE. */
4679 if (!local_undefweak
)
4681 if (htab
->plt
.has_plt0
)
4682 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
4683 + plt
->output_offset
4685 + htab
->lazy_plt
->plt_lazy_offset
),
4686 gotplt
->contents
+ got_offset
);
4688 /* Fill in the entry in the .rela.plt section. */
4689 rela
.r_offset
= (gotplt
->output_section
->vma
4690 + gotplt
->output_offset
4692 if (h
->dynindx
== -1
4693 || ((bfd_link_executable (info
)
4694 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
4696 && h
->type
== STT_GNU_IFUNC
))
4698 info
->callbacks
->minfo (_("Local IFUNC function `%s' in %B\n"),
4699 h
->root
.root
.string
,
4700 h
->root
.u
.def
.section
->owner
);
4702 /* If an STT_GNU_IFUNC symbol is locally defined, generate
4703 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
4704 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4705 rela
.r_addend
= (h
->root
.u
.def
.value
4706 + h
->root
.u
.def
.section
->output_section
->vma
4707 + h
->root
.u
.def
.section
->output_offset
);
4708 /* R_X86_64_IRELATIVE comes last. */
4709 plt_index
= htab
->next_irelative_index
--;
4713 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
4715 plt_index
= htab
->next_jump_slot_index
++;
4718 /* Don't fill the second and third slots in PLT entry for
4719 static executables nor without PLT0. */
4720 if (plt
== htab
->elf
.splt
&& htab
->plt
.has_plt0
)
4723 = h
->plt
.offset
+ htab
->lazy_plt
->plt_plt_insn_end
;
4725 /* Put relocation index. */
4726 bfd_put_32 (output_bfd
, plt_index
,
4727 (plt
->contents
+ h
->plt
.offset
4728 + htab
->lazy_plt
->plt_reloc_offset
));
4730 /* Put offset for jmp .PLT0 and check for overflow. We don't
4731 check relocation index for overflow since branch displacement
4732 will overflow first. */
4733 if (plt0_offset
> 0x80000000)
4734 /* xgettext:c-format */
4735 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
4736 output_bfd
, h
->root
.root
.string
);
4737 bfd_put_32 (output_bfd
, - plt0_offset
,
4738 (plt
->contents
+ h
->plt
.offset
4739 + htab
->lazy_plt
->plt_plt_offset
));
4742 bed
= get_elf_backend_data (output_bfd
);
4743 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
4744 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
4747 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
4749 bfd_vma got_offset
, plt_offset
;
4750 asection
*plt
, *got
;
4751 bfd_boolean got_after_plt
;
4752 int32_t got_pcrel_offset
;
4754 /* Set the entry in the GOT procedure linkage table. */
4755 plt
= htab
->plt_got
;
4756 got
= htab
->elf
.sgot
;
4757 got_offset
= h
->got
.offset
;
4759 if (got_offset
== (bfd_vma
) -1
4760 || (h
->type
== STT_GNU_IFUNC
&& h
->def_regular
)
4765 /* Use the non-lazy PLT entry template for the GOT PLT since they
4766 are the identical. */
4767 /* Fill in the entry in the GOT procedure linkage table. */
4768 plt_offset
= eh
->plt_got
.offset
;
4769 memcpy (plt
->contents
+ plt_offset
,
4770 htab
->non_lazy_plt
->plt_entry
,
4771 htab
->non_lazy_plt
->plt_entry_size
);
4773 /* Put offset the PC-relative instruction referring to the GOT
4774 entry, subtracting the size of that instruction. */
4775 got_pcrel_offset
= (got
->output_section
->vma
4776 + got
->output_offset
4778 - plt
->output_section
->vma
4779 - plt
->output_offset
4781 - htab
->non_lazy_plt
->plt_got_insn_size
);
4783 /* Check PC-relative offset overflow in GOT PLT entry. */
4784 got_after_plt
= got
->output_section
->vma
> plt
->output_section
->vma
;
4785 if ((got_after_plt
&& got_pcrel_offset
< 0)
4786 || (!got_after_plt
&& got_pcrel_offset
> 0))
4787 /* xgettext:c-format */
4788 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
4789 output_bfd
, h
->root
.root
.string
);
4791 bfd_put_32 (output_bfd
, got_pcrel_offset
,
4792 (plt
->contents
+ plt_offset
4793 + htab
->non_lazy_plt
->plt_got_offset
));
4796 if (!local_undefweak
4798 && (h
->plt
.offset
!= (bfd_vma
) -1
4799 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
4801 /* Mark the symbol as undefined, rather than as defined in
4802 the .plt section. Leave the value if there were any
4803 relocations where pointer equality matters (this is a clue
4804 for the dynamic linker, to make function pointer
4805 comparisons work between an application and shared
4806 library), otherwise set it to zero. If a function is only
4807 called from a binary, there is no need to slow down
4808 shared libraries because of that. */
4809 sym
->st_shndx
= SHN_UNDEF
;
4810 if (!h
->pointer_equality_needed
)
4814 /* Don't generate dynamic GOT relocation against undefined weak
4815 symbol in executable. */
4816 if (h
->got
.offset
!= (bfd_vma
) -1
4817 && ! GOT_TLS_GD_ANY_P (elf_x86_hash_entry (h
)->tls_type
)
4818 && elf_x86_hash_entry (h
)->tls_type
!= GOT_TLS_IE
4819 && !local_undefweak
)
4821 Elf_Internal_Rela rela
;
4822 asection
*relgot
= htab
->elf
.srelgot
;
4824 /* This symbol has an entry in the global offset table. Set it
4826 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
4829 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
4830 + htab
->elf
.sgot
->output_offset
4831 + (h
->got
.offset
&~ (bfd_vma
) 1));
4833 /* If this is a static link, or it is a -Bsymbolic link and the
4834 symbol is defined locally or was forced to be local because
4835 of a version file, we just want to emit a RELATIVE reloc.
4836 The entry in the global offset table will already have been
4837 initialized in the relocate_section function. */
4839 && h
->type
== STT_GNU_IFUNC
)
4841 if (h
->plt
.offset
== (bfd_vma
) -1)
4843 /* STT_GNU_IFUNC is referenced without PLT. */
4844 if (htab
->elf
.splt
== NULL
)
4846 /* use .rel[a].iplt section to store .got relocations
4847 in static executable. */
4848 relgot
= htab
->elf
.irelplt
;
4850 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
4852 info
->callbacks
->minfo (_("Local IFUNC function `%s' in %B\n"),
4854 h
->root
.root
.string
,
4855 h
->root
.u
.def
.section
->owner
);
4857 rela
.r_info
= htab
->r_info (0,
4858 R_X86_64_IRELATIVE
);
4859 rela
.r_addend
= (h
->root
.u
.def
.value
4860 + h
->root
.u
.def
.section
->output_section
->vma
4861 + h
->root
.u
.def
.section
->output_offset
);
4866 else if (bfd_link_pic (info
))
4868 /* Generate R_X86_64_GLOB_DAT. */
4876 if (!h
->pointer_equality_needed
)
4879 /* For non-shared object, we can't use .got.plt, which
4880 contains the real function addres if we need pointer
4881 equality. We load the GOT entry with the PLT entry. */
4882 if (htab
->plt_second
!= NULL
)
4884 plt
= htab
->plt_second
;
4885 plt_offset
= eh
->plt_second
.offset
;
4889 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
4890 plt_offset
= h
->plt
.offset
;
4892 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
4893 + plt
->output_offset
4895 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
4899 else if (bfd_link_pic (info
)
4900 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4902 if (!(h
->def_regular
|| ELF_COMMON_DEF_P (h
)))
4904 BFD_ASSERT((h
->got
.offset
& 1) != 0);
4905 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4906 rela
.r_addend
= (h
->root
.u
.def
.value
4907 + h
->root
.u
.def
.section
->output_section
->vma
4908 + h
->root
.u
.def
.section
->output_offset
);
4912 BFD_ASSERT((h
->got
.offset
& 1) == 0);
4914 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
4915 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
4916 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
4920 elf_append_rela (output_bfd
, relgot
, &rela
);
4925 Elf_Internal_Rela rela
;
4928 /* This symbol needs a copy reloc. Set it up. */
4930 if (h
->dynindx
== -1
4931 || (h
->root
.type
!= bfd_link_hash_defined
4932 && h
->root
.type
!= bfd_link_hash_defweak
)
4933 || htab
->elf
.srelbss
== NULL
4934 || htab
->elf
.sreldynrelro
== NULL
)
4937 rela
.r_offset
= (h
->root
.u
.def
.value
4938 + h
->root
.u
.def
.section
->output_section
->vma
4939 + h
->root
.u
.def
.section
->output_offset
);
4940 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
4942 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
4943 s
= htab
->elf
.sreldynrelro
;
4945 s
= htab
->elf
.srelbss
;
4946 elf_append_rela (output_bfd
, s
, &rela
);
4952 /* Finish up local dynamic symbol handling. We set the contents of
4953 various dynamic sections here. */
4956 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
4958 struct elf_link_hash_entry
*h
4959 = (struct elf_link_hash_entry
*) *slot
;
4960 struct bfd_link_info
*info
4961 = (struct bfd_link_info
*) inf
;
4963 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
4967 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
4968 here since undefined weak symbol may not be dynamic and may not be
4969 called for elf_x86_64_finish_dynamic_symbol. */
4972 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
4975 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
4976 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
4978 if (h
->root
.type
!= bfd_link_hash_undefweak
4979 || h
->dynindx
!= -1)
4982 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
4986 /* Used to decide how to sort relocs in an optimal manner for the
4987 dynamic linker, before writing them out. */
4989 static enum elf_reloc_type_class
4990 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info
,
4991 const asection
*rel_sec ATTRIBUTE_UNUSED
,
4992 const Elf_Internal_Rela
*rela
)
4994 bfd
*abfd
= info
->output_bfd
;
4995 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4996 struct elf_x86_link_hash_table
*htab
4997 = elf_x86_hash_table (info
, X86_64_ELF_DATA
);
4999 if (htab
->elf
.dynsym
!= NULL
5000 && htab
->elf
.dynsym
->contents
!= NULL
)
5002 /* Check relocation against STT_GNU_IFUNC symbol if there are
5004 unsigned long r_symndx
= htab
->r_sym (rela
->r_info
);
5005 if (r_symndx
!= STN_UNDEF
)
5007 Elf_Internal_Sym sym
;
5008 if (!bed
->s
->swap_symbol_in (abfd
,
5009 (htab
->elf
.dynsym
->contents
5010 + r_symndx
* bed
->s
->sizeof_sym
),
5014 if (ELF_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
5015 return reloc_class_ifunc
;
5019 switch ((int) ELF32_R_TYPE (rela
->r_info
))
5021 case R_X86_64_IRELATIVE
:
5022 return reloc_class_ifunc
;
5023 case R_X86_64_RELATIVE
:
5024 case R_X86_64_RELATIVE64
:
5025 return reloc_class_relative
;
5026 case R_X86_64_JUMP_SLOT
:
5027 return reloc_class_plt
;
5029 return reloc_class_copy
;
5031 return reloc_class_normal
;
5035 /* Finish up the dynamic sections. */
5038 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
5039 struct bfd_link_info
*info
)
5041 struct elf_x86_link_hash_table
*htab
;
5045 htab
= elf_x86_hash_table (info
, X86_64_ELF_DATA
);
5049 dynobj
= htab
->elf
.dynobj
;
5050 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
5052 if (htab
->elf
.dynamic_sections_created
)
5054 bfd_byte
*dyncon
, *dynconend
;
5055 const struct elf_backend_data
*bed
;
5056 bfd_size_type sizeof_dyn
;
5058 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
5061 bed
= get_elf_backend_data (dynobj
);
5062 sizeof_dyn
= bed
->s
->sizeof_dyn
;
5063 dyncon
= sdyn
->contents
;
5064 dynconend
= sdyn
->contents
+ sdyn
->size
;
5065 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
5067 Elf_Internal_Dyn dyn
;
5070 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
5078 s
= htab
->elf
.sgotplt
;
5079 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
5083 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
5087 s
= htab
->elf
.srelplt
->output_section
;
5088 dyn
.d_un
.d_val
= s
->size
;
5091 case DT_TLSDESC_PLT
:
5093 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5094 + htab
->tlsdesc_plt
;
5097 case DT_TLSDESC_GOT
:
5099 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
5100 + htab
->tlsdesc_got
;
5104 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
5107 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
5109 elf_section_data (htab
->elf
.splt
->output_section
)
5110 ->this_hdr
.sh_entsize
= htab
->plt
.plt_entry_size
;
5112 if (htab
->plt
.has_plt0
)
5114 /* Fill in the special first entry in the procedure linkage
5116 memcpy (htab
->elf
.splt
->contents
,
5117 htab
->lazy_plt
->plt0_entry
,
5118 htab
->lazy_plt
->plt0_entry_size
);
5119 /* Add offset for pushq GOT+8(%rip), since the instruction
5120 uses 6 bytes subtract this value. */
5121 bfd_put_32 (output_bfd
,
5122 (htab
->elf
.sgotplt
->output_section
->vma
5123 + htab
->elf
.sgotplt
->output_offset
5125 - htab
->elf
.splt
->output_section
->vma
5126 - htab
->elf
.splt
->output_offset
5128 (htab
->elf
.splt
->contents
5129 + htab
->lazy_plt
->plt0_got1_offset
));
5130 /* Add offset for the PC-relative instruction accessing
5131 GOT+16, subtracting the offset to the end of that
5133 bfd_put_32 (output_bfd
,
5134 (htab
->elf
.sgotplt
->output_section
->vma
5135 + htab
->elf
.sgotplt
->output_offset
5137 - htab
->elf
.splt
->output_section
->vma
5138 - htab
->elf
.splt
->output_offset
5139 - htab
->lazy_plt
->plt0_got2_insn_end
),
5140 (htab
->elf
.splt
->contents
5141 + htab
->lazy_plt
->plt0_got2_offset
));
5143 if (htab
->tlsdesc_plt
)
5145 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5146 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
5148 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
5149 htab
->lazy_plt
->plt0_entry
,
5150 htab
->lazy_plt
->plt0_entry_size
);
5152 /* Add offset for pushq GOT+8(%rip), since the
5153 instruction uses 6 bytes subtract this value. */
5154 bfd_put_32 (output_bfd
,
5155 (htab
->elf
.sgotplt
->output_section
->vma
5156 + htab
->elf
.sgotplt
->output_offset
5158 - htab
->elf
.splt
->output_section
->vma
5159 - htab
->elf
.splt
->output_offset
5162 (htab
->elf
.splt
->contents
5164 + htab
->lazy_plt
->plt0_got1_offset
));
5165 /* Add offset for the PC-relative instruction accessing
5166 GOT+TDG, where TDG stands for htab->tlsdesc_got,
5167 subtracting the offset to the end of that
5169 bfd_put_32 (output_bfd
,
5170 (htab
->elf
.sgot
->output_section
->vma
5171 + htab
->elf
.sgot
->output_offset
5173 - htab
->elf
.splt
->output_section
->vma
5174 - htab
->elf
.splt
->output_offset
5176 - htab
->lazy_plt
->plt0_got2_insn_end
),
5177 (htab
->elf
.splt
->contents
5179 + htab
->lazy_plt
->plt0_got2_offset
));
5184 if (htab
->plt_got
!= NULL
&& htab
->plt_got
->size
> 0)
5185 elf_section_data (htab
->plt_got
->output_section
)
5186 ->this_hdr
.sh_entsize
= htab
->non_lazy_plt
->plt_entry_size
;
5188 if (htab
->plt_second
!= NULL
&& htab
->plt_second
->size
> 0)
5189 elf_section_data (htab
->plt_second
->output_section
)
5190 ->this_hdr
.sh_entsize
= htab
->non_lazy_plt
->plt_entry_size
;
5193 /* GOT is always created in setup_gnu_properties. But it may not be
5195 if (htab
->elf
.sgotplt
&& htab
->elf
.sgotplt
->size
> 0)
5197 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
5200 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
5204 /* Set the first entry in the global offset table to the address of
5205 the dynamic section. */
5207 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
5209 bfd_put_64 (output_bfd
,
5210 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
5211 htab
->elf
.sgotplt
->contents
);
5212 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
5213 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5214 htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
5215 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
5216 htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
5218 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
5222 /* Adjust .eh_frame for .plt section. */
5223 if (htab
->plt_eh_frame
!= NULL
5224 && htab
->plt_eh_frame
->contents
!= NULL
)
5226 if (htab
->elf
.splt
!= NULL
5227 && htab
->elf
.splt
->size
!= 0
5228 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
5229 && htab
->elf
.splt
->output_section
!= NULL
5230 && htab
->plt_eh_frame
->output_section
!= NULL
)
5232 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
5233 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
5234 + htab
->plt_eh_frame
->output_offset
5235 + PLT_FDE_START_OFFSET
;
5236 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
5237 htab
->plt_eh_frame
->contents
5238 + PLT_FDE_START_OFFSET
);
5240 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
5242 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
5244 htab
->plt_eh_frame
->contents
))
5249 /* Adjust .eh_frame for .plt.got section. */
5250 if (htab
->plt_got_eh_frame
!= NULL
5251 && htab
->plt_got_eh_frame
->contents
!= NULL
)
5253 if (htab
->plt_got
!= NULL
5254 && htab
->plt_got
->size
!= 0
5255 && (htab
->plt_got
->flags
& SEC_EXCLUDE
) == 0
5256 && htab
->plt_got
->output_section
!= NULL
5257 && htab
->plt_got_eh_frame
->output_section
!= NULL
)
5259 bfd_vma plt_start
= htab
->plt_got
->output_section
->vma
;
5260 bfd_vma eh_frame_start
= htab
->plt_got_eh_frame
->output_section
->vma
5261 + htab
->plt_got_eh_frame
->output_offset
5262 + PLT_FDE_START_OFFSET
;
5263 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
5264 htab
->plt_got_eh_frame
->contents
5265 + PLT_FDE_START_OFFSET
);
5267 if (htab
->plt_got_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
5269 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
5270 htab
->plt_got_eh_frame
,
5271 htab
->plt_got_eh_frame
->contents
))
5276 /* Adjust .eh_frame for the second PLT section. */
5277 if (htab
->plt_second_eh_frame
!= NULL
5278 && htab
->plt_second_eh_frame
->contents
!= NULL
)
5280 if (htab
->plt_second
!= NULL
5281 && htab
->plt_second
->size
!= 0
5282 && (htab
->plt_second
->flags
& SEC_EXCLUDE
) == 0
5283 && htab
->plt_second
->output_section
!= NULL
5284 && htab
->plt_second_eh_frame
->output_section
!= NULL
)
5286 bfd_vma plt_start
= htab
->plt_second
->output_section
->vma
;
5287 bfd_vma eh_frame_start
5288 = (htab
->plt_second_eh_frame
->output_section
->vma
5289 + htab
->plt_second_eh_frame
->output_offset
5290 + PLT_FDE_START_OFFSET
);
5291 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
5292 htab
->plt_second_eh_frame
->contents
5293 + PLT_FDE_START_OFFSET
);
5295 if (htab
->plt_second_eh_frame
->sec_info_type
5296 == SEC_INFO_TYPE_EH_FRAME
)
5298 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
5299 htab
->plt_second_eh_frame
,
5300 htab
->plt_second_eh_frame
->contents
))
5305 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
5306 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
5309 /* Fill PLT entries for undefined weak symbols in PIE. */
5310 if (bfd_link_pie (info
))
5311 bfd_hash_traverse (&info
->hash
->table
,
5312 elf_x86_64_pie_finish_undefweak_symbol
,
5318 /* Fill PLT/GOT entries and allocate dynamic relocations for local
5319 STT_GNU_IFUNC symbols, which aren't in the ELF linker hash table.
5320 It has to be done before elf_link_sort_relocs is called so that
5321 dynamic relocations are properly sorted. */
5324 elf_x86_64_output_arch_local_syms
5325 (bfd
*output_bfd ATTRIBUTE_UNUSED
,
5326 struct bfd_link_info
*info
,
5327 void *flaginfo ATTRIBUTE_UNUSED
,
5328 int (*func
) (void *, const char *,
5331 struct elf_link_hash_entry
*) ATTRIBUTE_UNUSED
)
5333 struct elf_x86_link_hash_table
*htab
5334 = elf_x86_hash_table (info
, X86_64_ELF_DATA
);
5338 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
5339 htab_traverse (htab
->loc_hash_table
,
5340 elf_x86_64_finish_local_dynamic_symbol
,
5346 /* Forward declaration. */
5347 static const struct elf_x86_lazy_plt_layout elf_x86_64_nacl_plt
;
5349 /* Similar to _bfd_elf_get_synthetic_symtab. Support PLTs with all
5350 dynamic relocations. */
5353 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
5354 long symcount ATTRIBUTE_UNUSED
,
5355 asymbol
**syms ATTRIBUTE_UNUSED
,
5362 bfd_byte
*plt_contents
;
5364 const struct elf_x86_lazy_plt_layout
*lazy_plt
;
5365 const struct elf_x86_non_lazy_plt_layout
*non_lazy_plt
;
5366 const struct elf_x86_lazy_plt_layout
*lazy_bnd_plt
;
5367 const struct elf_x86_non_lazy_plt_layout
*non_lazy_bnd_plt
;
5368 const struct elf_x86_lazy_plt_layout
*lazy_ibt_plt
;
5369 const struct elf_x86_non_lazy_plt_layout
*non_lazy_ibt_plt
;
5371 enum elf_x86_plt_type plt_type
;
5372 struct elf_x86_plt plts
[] =
5374 { ".plt", NULL
, NULL
, plt_unknown
, 0, 0, 0, 0 },
5375 { ".plt.got", NULL
, NULL
, plt_non_lazy
, 0, 0, 0, 0 },
5376 { ".plt.sec", NULL
, NULL
, plt_second
, 0, 0, 0, 0 },
5377 { ".plt.bnd", NULL
, NULL
, plt_second
, 0, 0, 0, 0 },
5378 { NULL
, NULL
, NULL
, plt_non_lazy
, 0, 0, 0, 0 }
5383 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
5386 if (dynsymcount
<= 0)
5389 relsize
= bfd_get_dynamic_reloc_upper_bound (abfd
);
5393 if (get_elf_x86_64_backend_data (abfd
)->os
== is_normal
)
5395 lazy_plt
= &elf_x86_64_lazy_plt
;
5396 non_lazy_plt
= &elf_x86_64_non_lazy_plt
;
5397 lazy_bnd_plt
= &elf_x86_64_lazy_bnd_plt
;
5398 non_lazy_bnd_plt
= &elf_x86_64_non_lazy_bnd_plt
;
5399 if (ABI_64_P (abfd
))
5401 lazy_ibt_plt
= &elf_x86_64_lazy_ibt_plt
;
5402 non_lazy_ibt_plt
= &elf_x86_64_non_lazy_ibt_plt
;
5406 lazy_ibt_plt
= &elf_x32_lazy_ibt_plt
;
5407 non_lazy_ibt_plt
= &elf_x32_non_lazy_ibt_plt
;
5412 lazy_plt
= &elf_x86_64_nacl_plt
;
5413 non_lazy_plt
= NULL
;
5414 lazy_bnd_plt
= NULL
;
5415 non_lazy_bnd_plt
= NULL
;
5416 lazy_ibt_plt
= NULL
;
5417 non_lazy_ibt_plt
= NULL
;
5421 for (j
= 0; plts
[j
].name
!= NULL
; j
++)
5423 plt
= bfd_get_section_by_name (abfd
, plts
[j
].name
);
5424 if (plt
== NULL
|| plt
->size
== 0)
5427 /* Get the PLT section contents. */
5428 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
5429 if (plt_contents
== NULL
)
5431 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
5432 plt_contents
, 0, plt
->size
))
5434 free (plt_contents
);
5438 /* Check what kind of PLT it is. */
5439 plt_type
= plt_unknown
;
5440 if (plts
[j
].type
== plt_unknown
5441 && (plt
->size
>= (lazy_plt
->plt_entry_size
5442 + lazy_plt
->plt_entry_size
)))
5444 /* Match lazy PLT first. Need to check the first two
5446 if ((memcmp (plt_contents
, lazy_plt
->plt0_entry
,
5447 lazy_plt
->plt0_got1_offset
) == 0)
5448 && (memcmp (plt_contents
+ 6, lazy_plt
->plt0_entry
+ 6,
5450 plt_type
= plt_lazy
;
5451 else if (lazy_bnd_plt
!= NULL
5452 && (memcmp (plt_contents
, lazy_bnd_plt
->plt0_entry
,
5453 lazy_bnd_plt
->plt0_got1_offset
) == 0)
5454 && (memcmp (plt_contents
+ 6,
5455 lazy_bnd_plt
->plt0_entry
+ 6, 3) == 0))
5457 plt_type
= plt_lazy
| plt_second
;
5458 /* The fist entry in the lazy IBT PLT is the same as the
5460 if ((memcmp (plt_contents
+ lazy_ibt_plt
->plt_entry_size
,
5461 lazy_ibt_plt
->plt_entry
,
5462 lazy_ibt_plt
->plt_got_offset
) == 0))
5463 lazy_plt
= lazy_ibt_plt
;
5465 lazy_plt
= lazy_bnd_plt
;
5469 if (non_lazy_plt
!= NULL
5470 && (plt_type
== plt_unknown
|| plt_type
== plt_non_lazy
)
5471 && plt
->size
>= non_lazy_plt
->plt_entry_size
)
5473 /* Match non-lazy PLT. */
5474 if (memcmp (plt_contents
, non_lazy_plt
->plt_entry
,
5475 non_lazy_plt
->plt_got_offset
) == 0)
5476 plt_type
= plt_non_lazy
;
5479 if (plt_type
== plt_unknown
|| plt_type
== plt_second
)
5481 if (non_lazy_bnd_plt
!= NULL
5482 && plt
->size
>= non_lazy_bnd_plt
->plt_entry_size
5483 && (memcmp (plt_contents
, non_lazy_bnd_plt
->plt_entry
,
5484 non_lazy_bnd_plt
->plt_got_offset
) == 0))
5486 /* Match BND PLT. */
5487 plt_type
= plt_second
;
5488 non_lazy_plt
= non_lazy_bnd_plt
;
5490 else if (non_lazy_ibt_plt
!= NULL
5491 && plt
->size
>= non_lazy_ibt_plt
->plt_entry_size
5492 && (memcmp (plt_contents
,
5493 non_lazy_ibt_plt
->plt_entry
,
5494 non_lazy_ibt_plt
->plt_got_offset
) == 0))
5496 /* Match IBT PLT. */
5497 plt_type
= plt_second
;
5498 non_lazy_plt
= non_lazy_ibt_plt
;
5502 if (plt_type
== plt_unknown
)
5504 free (plt_contents
);
5509 plts
[j
].type
= plt_type
;
5511 if ((plt_type
& plt_lazy
))
5513 plts
[j
].plt_got_offset
= lazy_plt
->plt_got_offset
;
5514 plts
[j
].plt_got_insn_size
= lazy_plt
->plt_got_insn_size
;
5515 plts
[j
].plt_entry_size
= lazy_plt
->plt_entry_size
;
5516 /* Skip PLT0 in lazy PLT. */
5521 plts
[j
].plt_got_offset
= non_lazy_plt
->plt_got_offset
;
5522 plts
[j
].plt_got_insn_size
= non_lazy_plt
->plt_got_insn_size
;
5523 plts
[j
].plt_entry_size
= non_lazy_plt
->plt_entry_size
;
5527 /* Skip lazy PLT when the second PLT is used. */
5528 if (plt_type
== (plt_lazy
| plt_second
))
5532 n
= plt
->size
/ plts
[j
].plt_entry_size
;
5537 plts
[j
].contents
= plt_contents
;
5540 return _bfd_x86_elf_get_synthetic_symtab (abfd
, count
, relsize
,
5541 (bfd_vma
) 0, plts
, dynsyms
,
5545 /* Handle an x86-64 specific section when reading an object file. This
5546 is called when elfcode.h finds a section with an unknown type. */
5549 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
5550 const char *name
, int shindex
)
5552 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
5555 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
5561 /* Hook called by the linker routine which adds symbols from an object
5562 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
5566 elf_x86_64_add_symbol_hook (bfd
*abfd
,
5567 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5568 Elf_Internal_Sym
*sym
,
5569 const char **namep ATTRIBUTE_UNUSED
,
5570 flagword
*flagsp ATTRIBUTE_UNUSED
,
5576 switch (sym
->st_shndx
)
5578 case SHN_X86_64_LCOMMON
:
5579 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
5582 lcomm
= bfd_make_section_with_flags (abfd
,
5586 | SEC_LINKER_CREATED
));
5589 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
5592 *valp
= sym
->st_size
;
5600 /* Given a BFD section, try to locate the corresponding ELF section
5604 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
5605 asection
*sec
, int *index_return
)
5607 if (sec
== &_bfd_elf_large_com_section
)
5609 *index_return
= SHN_X86_64_LCOMMON
;
5615 /* Process a symbol. */
5618 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
5621 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
5623 switch (elfsym
->internal_elf_sym
.st_shndx
)
5625 case SHN_X86_64_LCOMMON
:
5626 asym
->section
= &_bfd_elf_large_com_section
;
5627 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
5628 /* Common symbol doesn't set BSF_GLOBAL. */
5629 asym
->flags
&= ~BSF_GLOBAL
;
5635 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
5637 return (sym
->st_shndx
== SHN_COMMON
5638 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
5642 elf_x86_64_common_section_index (asection
*sec
)
5644 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
5647 return SHN_X86_64_LCOMMON
;
5651 elf_x86_64_common_section (asection
*sec
)
5653 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
5654 return bfd_com_section_ptr
;
5656 return &_bfd_elf_large_com_section
;
5660 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
5661 const Elf_Internal_Sym
*sym
,
5666 const asection
*oldsec
)
5668 /* A normal common symbol and a large common symbol result in a
5669 normal common symbol. We turn the large common symbol into a
5672 && h
->root
.type
== bfd_link_hash_common
5674 && bfd_is_com_section (*psec
)
5677 if (sym
->st_shndx
== SHN_COMMON
5678 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
5680 h
->root
.u
.c
.p
->section
5681 = bfd_make_section_old_way (oldbfd
, "COMMON");
5682 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
5684 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
5685 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
5686 *psec
= bfd_com_section_ptr
;
5693 elf_x86_64_additional_program_headers (bfd
*abfd
,
5694 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
5699 /* Check to see if we need a large readonly segment. */
5700 s
= bfd_get_section_by_name (abfd
, ".lrodata");
5701 if (s
&& (s
->flags
& SEC_LOAD
))
5704 /* Check to see if we need a large data segment. Since .lbss sections
5705 is placed right after the .bss section, there should be no need for
5706 a large data segment just because of .lbss. */
5707 s
= bfd_get_section_by_name (abfd
, ".ldata");
5708 if (s
&& (s
->flags
& SEC_LOAD
))
5714 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
5717 elf_x86_64_relocs_compatible (const bfd_target
*input
,
5718 const bfd_target
*output
)
5720 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
5721 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
5722 && _bfd_elf_relocs_compatible (input
, output
));
5725 /* Set up x86-64 GNU properties. Return the first relocatable ELF input
5726 with GNU properties if found. Otherwise, return NULL. */
5729 elf_x86_64_link_setup_gnu_properties (struct bfd_link_info
*info
)
5731 struct elf_x86_plt_layout_table plt_layout
;
5733 plt_layout
.is_vxworks
= FALSE
;
5734 if (get_elf_x86_64_backend_data (info
->output_bfd
)->os
== is_normal
)
5738 plt_layout
.lazy_plt
= &elf_x86_64_lazy_bnd_plt
;
5739 plt_layout
.non_lazy_plt
= &elf_x86_64_non_lazy_bnd_plt
;
5743 plt_layout
.lazy_plt
= &elf_x86_64_lazy_plt
;
5744 plt_layout
.non_lazy_plt
= &elf_x86_64_non_lazy_plt
;
5747 if (ABI_64_P (info
->output_bfd
))
5749 plt_layout
.lazy_ibt_plt
= &elf_x86_64_lazy_ibt_plt
;
5750 plt_layout
.non_lazy_ibt_plt
= &elf_x86_64_non_lazy_ibt_plt
;
5754 plt_layout
.lazy_ibt_plt
= &elf_x32_lazy_ibt_plt
;
5755 plt_layout
.non_lazy_ibt_plt
= &elf_x32_non_lazy_ibt_plt
;
5757 plt_layout
.normal_target
= TRUE
;
5761 plt_layout
.lazy_plt
= &elf_x86_64_nacl_plt
;
5762 plt_layout
.non_lazy_plt
= NULL
;
5763 plt_layout
.lazy_ibt_plt
= NULL
;
5764 plt_layout
.non_lazy_ibt_plt
= NULL
;
5765 plt_layout
.normal_target
= FALSE
;
5768 return _bfd_x86_elf_link_setup_gnu_properties (info
, &plt_layout
);
5771 static const struct bfd_elf_special_section
5772 elf_x86_64_special_sections
[]=
5774 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5775 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
5776 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
5777 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5778 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
5779 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
5780 { NULL
, 0, 0, 0, 0 }
5783 #define TARGET_LITTLE_SYM x86_64_elf64_vec
5784 #define TARGET_LITTLE_NAME "elf64-x86-64"
5785 #define ELF_ARCH bfd_arch_i386
5786 #define ELF_TARGET_ID X86_64_ELF_DATA
5787 #define ELF_MACHINE_CODE EM_X86_64
5788 #define ELF_MAXPAGESIZE 0x200000
5789 #define ELF_MINPAGESIZE 0x1000
5790 #define ELF_COMMONPAGESIZE 0x1000
5792 #define elf_backend_can_gc_sections 1
5793 #define elf_backend_can_refcount 1
5794 #define elf_backend_want_got_plt 1
5795 #define elf_backend_plt_readonly 1
5796 #define elf_backend_want_plt_sym 0
5797 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
5798 #define elf_backend_rela_normal 1
5799 #define elf_backend_plt_alignment 4
5800 #define elf_backend_extern_protected_data 1
5801 #define elf_backend_caches_rawsize 1
5802 #define elf_backend_dtrel_excludes_plt 1
5803 #define elf_backend_want_dynrelro 1
5805 #define elf_info_to_howto elf_x86_64_info_to_howto
5807 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
5808 #define bfd_elf64_bfd_reloc_name_lookup \
5809 elf_x86_64_reloc_name_lookup
5811 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
5812 #define elf_backend_check_relocs elf_x86_64_check_relocs
5813 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
5814 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
5815 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
5816 #define elf_backend_output_arch_local_syms elf_x86_64_output_arch_local_syms
5817 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
5818 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
5820 #define elf_backend_write_core_note elf_x86_64_write_core_note
5822 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
5823 #define elf_backend_relocate_section elf_x86_64_relocate_section
5824 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
5825 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
5826 #define elf_backend_object_p elf64_x86_64_elf_object_p
5827 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
5829 #define elf_backend_section_from_shdr \
5830 elf_x86_64_section_from_shdr
5832 #define elf_backend_section_from_bfd_section \
5833 elf_x86_64_elf_section_from_bfd_section
5834 #define elf_backend_add_symbol_hook \
5835 elf_x86_64_add_symbol_hook
5836 #define elf_backend_symbol_processing \
5837 elf_x86_64_symbol_processing
5838 #define elf_backend_common_section_index \
5839 elf_x86_64_common_section_index
5840 #define elf_backend_common_section \
5841 elf_x86_64_common_section
5842 #define elf_backend_common_definition \
5843 elf_x86_64_common_definition
5844 #define elf_backend_merge_symbol \
5845 elf_x86_64_merge_symbol
5846 #define elf_backend_special_sections \
5847 elf_x86_64_special_sections
5848 #define elf_backend_additional_program_headers \
5849 elf_x86_64_additional_program_headers
5850 #define elf_backend_setup_gnu_properties \
5851 elf_x86_64_link_setup_gnu_properties
5853 #include "elf64-target.h"
5855 /* CloudABI support. */
5857 #undef TARGET_LITTLE_SYM
5858 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
5859 #undef TARGET_LITTLE_NAME
5860 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
5863 #define ELF_OSABI ELFOSABI_CLOUDABI
5866 #define elf64_bed elf64_x86_64_cloudabi_bed
5868 #include "elf64-target.h"
5870 /* FreeBSD support. */
5872 #undef TARGET_LITTLE_SYM
5873 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
5874 #undef TARGET_LITTLE_NAME
5875 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
5878 #define ELF_OSABI ELFOSABI_FREEBSD
5881 #define elf64_bed elf64_x86_64_fbsd_bed
5883 #include "elf64-target.h"
5885 /* Solaris 2 support. */
5887 #undef TARGET_LITTLE_SYM
5888 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
5889 #undef TARGET_LITTLE_NAME
5890 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
5892 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5893 objects won't be recognized. */
5897 #define elf64_bed elf64_x86_64_sol2_bed
5899 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
5901 #undef elf_backend_static_tls_alignment
5902 #define elf_backend_static_tls_alignment 16
5904 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5906 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5908 #undef elf_backend_want_plt_sym
5909 #define elf_backend_want_plt_sym 1
5911 #undef elf_backend_strtab_flags
5912 #define elf_backend_strtab_flags SHF_STRINGS
5915 elf64_x86_64_copy_solaris_special_section_fields (const bfd
*ibfd ATTRIBUTE_UNUSED
,
5916 bfd
*obfd ATTRIBUTE_UNUSED
,
5917 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
5918 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
5920 /* PR 19938: FIXME: Need to add code for setting the sh_info
5921 and sh_link fields of Solaris specific section types. */
5925 #undef elf_backend_copy_special_section_fields
5926 #define elf_backend_copy_special_section_fields elf64_x86_64_copy_solaris_special_section_fields
5928 #include "elf64-target.h"
5930 /* Native Client support. */
5933 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
5935 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
5936 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
5940 #undef TARGET_LITTLE_SYM
5941 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
5942 #undef TARGET_LITTLE_NAME
5943 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
5945 #define elf64_bed elf64_x86_64_nacl_bed
5947 #undef ELF_MAXPAGESIZE
5948 #undef ELF_MINPAGESIZE
5949 #undef ELF_COMMONPAGESIZE
5950 #define ELF_MAXPAGESIZE 0x10000
5951 #define ELF_MINPAGESIZE 0x10000
5952 #define ELF_COMMONPAGESIZE 0x10000
5954 /* Restore defaults. */
5956 #undef elf_backend_static_tls_alignment
5957 #undef elf_backend_want_plt_sym
5958 #define elf_backend_want_plt_sym 0
5959 #undef elf_backend_strtab_flags
5960 #undef elf_backend_copy_special_section_fields
5962 /* NaCl uses substantially different PLT entries for the same effects. */
5964 #undef elf_backend_plt_alignment
5965 #define elf_backend_plt_alignment 5
5966 #define NACL_PLT_ENTRY_SIZE 64
5967 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
5969 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
5971 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
5972 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
5973 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
5974 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5975 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5977 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
5978 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
5980 /* 32 bytes of nop to pad out to the standard size. */
5981 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
5982 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5983 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
5984 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5985 0x66, /* excess data16 prefix */
5989 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
5991 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
5992 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
5993 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
5994 0x41, 0xff, 0xe3, /* jmpq *%r11 */
5996 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
5997 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
5998 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6000 /* Lazy GOT entries point here (32-byte aligned). */
6001 0x68, /* pushq immediate */
6002 0, 0, 0, 0, /* replaced with index into relocation table. */
6003 0xe9, /* jmp relative */
6004 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
6006 /* 22 bytes of nop to pad out to the standard size. */
6007 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6008 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6009 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
6012 /* .eh_frame covering the .plt section. */
6014 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
6016 #if (PLT_CIE_LENGTH != 20 \
6017 || PLT_FDE_LENGTH != 36 \
6018 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6019 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6020 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
6022 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6023 0, 0, 0, 0, /* CIE ID */
6024 1, /* CIE version */
6025 'z', 'R', 0, /* Augmentation string */
6026 1, /* Code alignment factor */
6027 0x78, /* Data alignment factor */
6028 16, /* Return address column */
6029 1, /* Augmentation size */
6030 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6031 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
6032 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
6033 DW_CFA_nop
, DW_CFA_nop
,
6035 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6036 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
6037 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
6038 0, 0, 0, 0, /* .plt size goes here */
6039 0, /* Augmentation size */
6040 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
6041 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6042 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
6043 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6044 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6045 13, /* Block length */
6046 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
6047 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
6048 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6049 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
6050 DW_CFA_nop
, DW_CFA_nop
6053 static const struct elf_x86_lazy_plt_layout elf_x86_64_nacl_plt
=
6055 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
6056 NACL_PLT_ENTRY_SIZE
, /* plt0_entry_size */
6057 elf_x86_64_nacl_plt_entry
, /* plt_entry */
6058 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
6059 2, /* plt0_got1_offset */
6060 9, /* plt0_got2_offset */
6061 13, /* plt0_got2_insn_end */
6062 3, /* plt_got_offset */
6063 33, /* plt_reloc_offset */
6064 38, /* plt_plt_offset */
6065 7, /* plt_got_insn_size */
6066 42, /* plt_plt_insn_end */
6067 32, /* plt_lazy_offset */
6068 elf_x86_64_nacl_plt0_entry
, /* pic_plt0_entry */
6069 elf_x86_64_nacl_plt_entry
, /* pic_plt_entry */
6070 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
6071 sizeof (elf_x86_64_nacl_eh_frame_plt
) /* eh_frame_plt_size */
6074 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
6079 #undef elf_backend_arch_data
6080 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
6082 #undef elf_backend_object_p
6083 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
6084 #undef elf_backend_modify_segment_map
6085 #define elf_backend_modify_segment_map nacl_modify_segment_map
6086 #undef elf_backend_modify_program_headers
6087 #define elf_backend_modify_program_headers nacl_modify_program_headers
6088 #undef elf_backend_final_write_processing
6089 #define elf_backend_final_write_processing nacl_final_write_processing
6091 #include "elf64-target.h"
6093 /* Native Client x32 support. */
6096 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
6098 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
6099 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
6103 #undef TARGET_LITTLE_SYM
6104 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
6105 #undef TARGET_LITTLE_NAME
6106 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
6108 #define elf32_bed elf32_x86_64_nacl_bed
6110 #define bfd_elf32_bfd_reloc_type_lookup \
6111 elf_x86_64_reloc_type_lookup
6112 #define bfd_elf32_bfd_reloc_name_lookup \
6113 elf_x86_64_reloc_name_lookup
6114 #define bfd_elf32_get_synthetic_symtab \
6115 elf_x86_64_get_synthetic_symtab
6117 #undef elf_backend_object_p
6118 #define elf_backend_object_p \
6119 elf32_x86_64_nacl_elf_object_p
6121 #undef elf_backend_bfd_from_remote_memory
6122 #define elf_backend_bfd_from_remote_memory \
6123 _bfd_elf32_bfd_from_remote_memory
6125 #undef elf_backend_size_info
6126 #define elf_backend_size_info \
6127 _bfd_elf32_size_info
6129 #include "elf32-target.h"
6131 /* Restore defaults. */
6132 #undef elf_backend_object_p
6133 #define elf_backend_object_p elf64_x86_64_elf_object_p
6134 #undef elf_backend_bfd_from_remote_memory
6135 #undef elf_backend_size_info
6136 #undef elf_backend_modify_segment_map
6137 #undef elf_backend_modify_program_headers
6138 #undef elf_backend_final_write_processing
6140 /* Intel L1OM support. */
6143 elf64_l1om_elf_object_p (bfd
*abfd
)
6145 /* Set the right machine number for an L1OM elf64 file. */
6146 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
6150 #undef TARGET_LITTLE_SYM
6151 #define TARGET_LITTLE_SYM l1om_elf64_vec
6152 #undef TARGET_LITTLE_NAME
6153 #define TARGET_LITTLE_NAME "elf64-l1om"
6155 #define ELF_ARCH bfd_arch_l1om
6157 #undef ELF_MACHINE_CODE
6158 #define ELF_MACHINE_CODE EM_L1OM
6163 #define elf64_bed elf64_l1om_bed
6165 #undef elf_backend_object_p
6166 #define elf_backend_object_p elf64_l1om_elf_object_p
6168 /* Restore defaults. */
6169 #undef ELF_MAXPAGESIZE
6170 #undef ELF_MINPAGESIZE
6171 #undef ELF_COMMONPAGESIZE
6172 #define ELF_MAXPAGESIZE 0x200000
6173 #define ELF_MINPAGESIZE 0x1000
6174 #define ELF_COMMONPAGESIZE 0x1000
6175 #undef elf_backend_plt_alignment
6176 #define elf_backend_plt_alignment 4
6177 #undef elf_backend_arch_data
6178 #define elf_backend_arch_data &elf_x86_64_arch_bed
6180 #include "elf64-target.h"
6182 /* FreeBSD L1OM support. */
6184 #undef TARGET_LITTLE_SYM
6185 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
6186 #undef TARGET_LITTLE_NAME
6187 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
6190 #define ELF_OSABI ELFOSABI_FREEBSD
6193 #define elf64_bed elf64_l1om_fbsd_bed
6195 #include "elf64-target.h"
6197 /* Intel K1OM support. */
6200 elf64_k1om_elf_object_p (bfd
*abfd
)
6202 /* Set the right machine number for an K1OM elf64 file. */
6203 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
6207 #undef TARGET_LITTLE_SYM
6208 #define TARGET_LITTLE_SYM k1om_elf64_vec
6209 #undef TARGET_LITTLE_NAME
6210 #define TARGET_LITTLE_NAME "elf64-k1om"
6212 #define ELF_ARCH bfd_arch_k1om
6214 #undef ELF_MACHINE_CODE
6215 #define ELF_MACHINE_CODE EM_K1OM
6220 #define elf64_bed elf64_k1om_bed
6222 #undef elf_backend_object_p
6223 #define elf_backend_object_p elf64_k1om_elf_object_p
6225 #undef elf_backend_static_tls_alignment
6227 #undef elf_backend_want_plt_sym
6228 #define elf_backend_want_plt_sym 0
6230 #include "elf64-target.h"
6232 /* FreeBSD K1OM support. */
6234 #undef TARGET_LITTLE_SYM
6235 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
6236 #undef TARGET_LITTLE_NAME
6237 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
6240 #define ELF_OSABI ELFOSABI_FREEBSD
6243 #define elf64_bed elf64_k1om_fbsd_bed
6245 #include "elf64-target.h"
6247 /* 32bit x86-64 support. */
6249 #undef TARGET_LITTLE_SYM
6250 #define TARGET_LITTLE_SYM x86_64_elf32_vec
6251 #undef TARGET_LITTLE_NAME
6252 #define TARGET_LITTLE_NAME "elf32-x86-64"
6256 #define ELF_ARCH bfd_arch_i386
6258 #undef ELF_MACHINE_CODE
6259 #define ELF_MACHINE_CODE EM_X86_64
6263 #undef elf_backend_object_p
6264 #define elf_backend_object_p \
6265 elf32_x86_64_elf_object_p
6267 #undef elf_backend_bfd_from_remote_memory
6268 #define elf_backend_bfd_from_remote_memory \
6269 _bfd_elf32_bfd_from_remote_memory
6271 #undef elf_backend_size_info
6272 #define elf_backend_size_info \
6273 _bfd_elf32_size_info
6275 #include "elf32-target.h"