1 /* X86-64 specific support for ELF
2 Copyright (C) 2000-2016 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka <jh@suse.cz>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
28 #include "bfd_stdint.h"
32 #include "libiberty.h"
34 #include "opcode/i386.h"
35 #include "elf/x86-64.h"
42 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
43 #define MINUS_ONE (~ (bfd_vma) 0)
45 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
46 identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
47 relocation type. We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
48 since they are the same. */
50 #define ABI_64_P(abfd) \
51 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
53 /* The relocation "howto" table. Order of fields:
54 type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
55 special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset. */
56 static reloc_howto_type x86_64_elf_howto_table
[] =
58 HOWTO(R_X86_64_NONE
, 0, 3, 0, FALSE
, 0, complain_overflow_dont
,
59 bfd_elf_generic_reloc
, "R_X86_64_NONE", FALSE
, 0x00000000, 0x00000000,
61 HOWTO(R_X86_64_64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
62 bfd_elf_generic_reloc
, "R_X86_64_64", FALSE
, MINUS_ONE
, MINUS_ONE
,
64 HOWTO(R_X86_64_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
65 bfd_elf_generic_reloc
, "R_X86_64_PC32", FALSE
, 0xffffffff, 0xffffffff,
67 HOWTO(R_X86_64_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
68 bfd_elf_generic_reloc
, "R_X86_64_GOT32", FALSE
, 0xffffffff, 0xffffffff,
70 HOWTO(R_X86_64_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
71 bfd_elf_generic_reloc
, "R_X86_64_PLT32", FALSE
, 0xffffffff, 0xffffffff,
73 HOWTO(R_X86_64_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
74 bfd_elf_generic_reloc
, "R_X86_64_COPY", FALSE
, 0xffffffff, 0xffffffff,
76 HOWTO(R_X86_64_GLOB_DAT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
77 bfd_elf_generic_reloc
, "R_X86_64_GLOB_DAT", FALSE
, MINUS_ONE
,
79 HOWTO(R_X86_64_JUMP_SLOT
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
80 bfd_elf_generic_reloc
, "R_X86_64_JUMP_SLOT", FALSE
, MINUS_ONE
,
82 HOWTO(R_X86_64_RELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
83 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE", FALSE
, MINUS_ONE
,
85 HOWTO(R_X86_64_GOTPCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
86 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL", FALSE
, 0xffffffff,
88 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
89 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
91 HOWTO(R_X86_64_32S
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
92 bfd_elf_generic_reloc
, "R_X86_64_32S", FALSE
, 0xffffffff, 0xffffffff,
94 HOWTO(R_X86_64_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
95 bfd_elf_generic_reloc
, "R_X86_64_16", FALSE
, 0xffff, 0xffff, FALSE
),
96 HOWTO(R_X86_64_PC16
,0, 1, 16, TRUE
, 0, complain_overflow_bitfield
,
97 bfd_elf_generic_reloc
, "R_X86_64_PC16", FALSE
, 0xffff, 0xffff, TRUE
),
98 HOWTO(R_X86_64_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
99 bfd_elf_generic_reloc
, "R_X86_64_8", FALSE
, 0xff, 0xff, FALSE
),
100 HOWTO(R_X86_64_PC8
, 0, 0, 8, TRUE
, 0, complain_overflow_signed
,
101 bfd_elf_generic_reloc
, "R_X86_64_PC8", FALSE
, 0xff, 0xff, TRUE
),
102 HOWTO(R_X86_64_DTPMOD64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
103 bfd_elf_generic_reloc
, "R_X86_64_DTPMOD64", FALSE
, MINUS_ONE
,
105 HOWTO(R_X86_64_DTPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
106 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF64", FALSE
, MINUS_ONE
,
108 HOWTO(R_X86_64_TPOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
109 bfd_elf_generic_reloc
, "R_X86_64_TPOFF64", FALSE
, MINUS_ONE
,
111 HOWTO(R_X86_64_TLSGD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
112 bfd_elf_generic_reloc
, "R_X86_64_TLSGD", FALSE
, 0xffffffff,
114 HOWTO(R_X86_64_TLSLD
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
115 bfd_elf_generic_reloc
, "R_X86_64_TLSLD", FALSE
, 0xffffffff,
117 HOWTO(R_X86_64_DTPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
118 bfd_elf_generic_reloc
, "R_X86_64_DTPOFF32", FALSE
, 0xffffffff,
120 HOWTO(R_X86_64_GOTTPOFF
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
121 bfd_elf_generic_reloc
, "R_X86_64_GOTTPOFF", FALSE
, 0xffffffff,
123 HOWTO(R_X86_64_TPOFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
124 bfd_elf_generic_reloc
, "R_X86_64_TPOFF32", FALSE
, 0xffffffff,
126 HOWTO(R_X86_64_PC64
, 0, 4, 64, TRUE
, 0, complain_overflow_bitfield
,
127 bfd_elf_generic_reloc
, "R_X86_64_PC64", FALSE
, MINUS_ONE
, MINUS_ONE
,
129 HOWTO(R_X86_64_GOTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
130 bfd_elf_generic_reloc
, "R_X86_64_GOTOFF64",
131 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
132 HOWTO(R_X86_64_GOTPC32
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
133 bfd_elf_generic_reloc
, "R_X86_64_GOTPC32",
134 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
135 HOWTO(R_X86_64_GOT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
136 bfd_elf_generic_reloc
, "R_X86_64_GOT64", FALSE
, MINUS_ONE
, MINUS_ONE
,
138 HOWTO(R_X86_64_GOTPCREL64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
139 bfd_elf_generic_reloc
, "R_X86_64_GOTPCREL64", FALSE
, MINUS_ONE
,
141 HOWTO(R_X86_64_GOTPC64
, 0, 4, 64, TRUE
, 0, complain_overflow_signed
,
142 bfd_elf_generic_reloc
, "R_X86_64_GOTPC64",
143 FALSE
, MINUS_ONE
, MINUS_ONE
, TRUE
),
144 HOWTO(R_X86_64_GOTPLT64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
145 bfd_elf_generic_reloc
, "R_X86_64_GOTPLT64", FALSE
, MINUS_ONE
,
147 HOWTO(R_X86_64_PLTOFF64
, 0, 4, 64, FALSE
, 0, complain_overflow_signed
,
148 bfd_elf_generic_reloc
, "R_X86_64_PLTOFF64", FALSE
, MINUS_ONE
,
150 HOWTO(R_X86_64_SIZE32
, 0, 2, 32, FALSE
, 0, complain_overflow_unsigned
,
151 bfd_elf_generic_reloc
, "R_X86_64_SIZE32", FALSE
, 0xffffffff, 0xffffffff,
153 HOWTO(R_X86_64_SIZE64
, 0, 4, 64, FALSE
, 0, complain_overflow_unsigned
,
154 bfd_elf_generic_reloc
, "R_X86_64_SIZE64", FALSE
, MINUS_ONE
, MINUS_ONE
,
156 HOWTO(R_X86_64_GOTPC32_TLSDESC
, 0, 2, 32, TRUE
, 0,
157 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
158 "R_X86_64_GOTPC32_TLSDESC",
159 FALSE
, 0xffffffff, 0xffffffff, TRUE
),
160 HOWTO(R_X86_64_TLSDESC_CALL
, 0, 0, 0, FALSE
, 0,
161 complain_overflow_dont
, bfd_elf_generic_reloc
,
162 "R_X86_64_TLSDESC_CALL",
164 HOWTO(R_X86_64_TLSDESC
, 0, 4, 64, FALSE
, 0,
165 complain_overflow_bitfield
, bfd_elf_generic_reloc
,
167 FALSE
, MINUS_ONE
, MINUS_ONE
, FALSE
),
168 HOWTO(R_X86_64_IRELATIVE
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
169 bfd_elf_generic_reloc
, "R_X86_64_IRELATIVE", FALSE
, MINUS_ONE
,
171 HOWTO(R_X86_64_RELATIVE64
, 0, 4, 64, FALSE
, 0, complain_overflow_bitfield
,
172 bfd_elf_generic_reloc
, "R_X86_64_RELATIVE64", FALSE
, MINUS_ONE
,
174 HOWTO(R_X86_64_PC32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
175 bfd_elf_generic_reloc
, "R_X86_64_PC32_BND", FALSE
, 0xffffffff, 0xffffffff,
177 HOWTO(R_X86_64_PLT32_BND
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
178 bfd_elf_generic_reloc
, "R_X86_64_PLT32_BND", FALSE
, 0xffffffff, 0xffffffff,
180 HOWTO(R_X86_64_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
181 bfd_elf_generic_reloc
, "R_X86_64_GOTPCRELX", FALSE
, 0xffffffff,
183 HOWTO(R_X86_64_REX_GOTPCRELX
, 0, 2, 32, TRUE
, 0, complain_overflow_signed
,
184 bfd_elf_generic_reloc
, "R_X86_64_REX_GOTPCRELX", FALSE
, 0xffffffff,
187 /* We have a gap in the reloc numbers here.
188 R_X86_64_standard counts the number up to this point, and
189 R_X86_64_vt_offset is the value to subtract from a reloc type of
190 R_X86_64_GNU_VT* to form an index into this table. */
191 #define R_X86_64_standard (R_X86_64_REX_GOTPCRELX + 1)
192 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
194 /* GNU extension to record C++ vtable hierarchy. */
195 HOWTO (R_X86_64_GNU_VTINHERIT
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
196 NULL
, "R_X86_64_GNU_VTINHERIT", FALSE
, 0, 0, FALSE
),
198 /* GNU extension to record C++ vtable member usage. */
199 HOWTO (R_X86_64_GNU_VTENTRY
, 0, 4, 0, FALSE
, 0, complain_overflow_dont
,
200 _bfd_elf_rel_vtable_reloc_fn
, "R_X86_64_GNU_VTENTRY", FALSE
, 0, 0,
203 /* Use complain_overflow_bitfield on R_X86_64_32 for x32. */
204 HOWTO(R_X86_64_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
205 bfd_elf_generic_reloc
, "R_X86_64_32", FALSE
, 0xffffffff, 0xffffffff,
209 #define IS_X86_64_PCREL_TYPE(TYPE) \
210 ( ((TYPE) == R_X86_64_PC8) \
211 || ((TYPE) == R_X86_64_PC16) \
212 || ((TYPE) == R_X86_64_PC32) \
213 || ((TYPE) == R_X86_64_PC32_BND) \
214 || ((TYPE) == R_X86_64_PC64))
216 /* Map BFD relocs to the x86_64 elf relocs. */
219 bfd_reloc_code_real_type bfd_reloc_val
;
220 unsigned char elf_reloc_val
;
223 static const struct elf_reloc_map x86_64_reloc_map
[] =
225 { BFD_RELOC_NONE
, R_X86_64_NONE
, },
226 { BFD_RELOC_64
, R_X86_64_64
, },
227 { BFD_RELOC_32_PCREL
, R_X86_64_PC32
, },
228 { BFD_RELOC_X86_64_GOT32
, R_X86_64_GOT32
,},
229 { BFD_RELOC_X86_64_PLT32
, R_X86_64_PLT32
,},
230 { BFD_RELOC_X86_64_COPY
, R_X86_64_COPY
, },
231 { BFD_RELOC_X86_64_GLOB_DAT
, R_X86_64_GLOB_DAT
, },
232 { BFD_RELOC_X86_64_JUMP_SLOT
, R_X86_64_JUMP_SLOT
, },
233 { BFD_RELOC_X86_64_RELATIVE
, R_X86_64_RELATIVE
, },
234 { BFD_RELOC_X86_64_GOTPCREL
, R_X86_64_GOTPCREL
, },
235 { BFD_RELOC_32
, R_X86_64_32
, },
236 { BFD_RELOC_X86_64_32S
, R_X86_64_32S
, },
237 { BFD_RELOC_16
, R_X86_64_16
, },
238 { BFD_RELOC_16_PCREL
, R_X86_64_PC16
, },
239 { BFD_RELOC_8
, R_X86_64_8
, },
240 { BFD_RELOC_8_PCREL
, R_X86_64_PC8
, },
241 { BFD_RELOC_X86_64_DTPMOD64
, R_X86_64_DTPMOD64
, },
242 { BFD_RELOC_X86_64_DTPOFF64
, R_X86_64_DTPOFF64
, },
243 { BFD_RELOC_X86_64_TPOFF64
, R_X86_64_TPOFF64
, },
244 { BFD_RELOC_X86_64_TLSGD
, R_X86_64_TLSGD
, },
245 { BFD_RELOC_X86_64_TLSLD
, R_X86_64_TLSLD
, },
246 { BFD_RELOC_X86_64_DTPOFF32
, R_X86_64_DTPOFF32
, },
247 { BFD_RELOC_X86_64_GOTTPOFF
, R_X86_64_GOTTPOFF
, },
248 { BFD_RELOC_X86_64_TPOFF32
, R_X86_64_TPOFF32
, },
249 { BFD_RELOC_64_PCREL
, R_X86_64_PC64
, },
250 { BFD_RELOC_X86_64_GOTOFF64
, R_X86_64_GOTOFF64
, },
251 { BFD_RELOC_X86_64_GOTPC32
, R_X86_64_GOTPC32
, },
252 { BFD_RELOC_X86_64_GOT64
, R_X86_64_GOT64
, },
253 { BFD_RELOC_X86_64_GOTPCREL64
,R_X86_64_GOTPCREL64
, },
254 { BFD_RELOC_X86_64_GOTPC64
, R_X86_64_GOTPC64
, },
255 { BFD_RELOC_X86_64_GOTPLT64
, R_X86_64_GOTPLT64
, },
256 { BFD_RELOC_X86_64_PLTOFF64
, R_X86_64_PLTOFF64
, },
257 { BFD_RELOC_SIZE32
, R_X86_64_SIZE32
, },
258 { BFD_RELOC_SIZE64
, R_X86_64_SIZE64
, },
259 { BFD_RELOC_X86_64_GOTPC32_TLSDESC
, R_X86_64_GOTPC32_TLSDESC
, },
260 { BFD_RELOC_X86_64_TLSDESC_CALL
, R_X86_64_TLSDESC_CALL
, },
261 { BFD_RELOC_X86_64_TLSDESC
, R_X86_64_TLSDESC
, },
262 { BFD_RELOC_X86_64_IRELATIVE
, R_X86_64_IRELATIVE
, },
263 { BFD_RELOC_X86_64_PC32_BND
, R_X86_64_PC32_BND
, },
264 { BFD_RELOC_X86_64_PLT32_BND
, R_X86_64_PLT32_BND
, },
265 { BFD_RELOC_X86_64_GOTPCRELX
, R_X86_64_GOTPCRELX
, },
266 { BFD_RELOC_X86_64_REX_GOTPCRELX
, R_X86_64_REX_GOTPCRELX
, },
267 { BFD_RELOC_VTABLE_INHERIT
, R_X86_64_GNU_VTINHERIT
, },
268 { BFD_RELOC_VTABLE_ENTRY
, R_X86_64_GNU_VTENTRY
, },
271 static reloc_howto_type
*
272 elf_x86_64_rtype_to_howto (bfd
*abfd
, unsigned r_type
)
276 if (r_type
== (unsigned int) R_X86_64_32
)
281 i
= ARRAY_SIZE (x86_64_elf_howto_table
) - 1;
283 else if (r_type
< (unsigned int) R_X86_64_GNU_VTINHERIT
284 || r_type
>= (unsigned int) R_X86_64_max
)
286 if (r_type
>= (unsigned int) R_X86_64_standard
)
288 /* xgettext:c-format */
289 _bfd_error_handler (_("%B: invalid relocation type %d"),
291 r_type
= R_X86_64_NONE
;
296 i
= r_type
- (unsigned int) R_X86_64_vt_offset
;
297 BFD_ASSERT (x86_64_elf_howto_table
[i
].type
== r_type
);
298 return &x86_64_elf_howto_table
[i
];
301 /* Given a BFD reloc type, return a HOWTO structure. */
302 static reloc_howto_type
*
303 elf_x86_64_reloc_type_lookup (bfd
*abfd
,
304 bfd_reloc_code_real_type code
)
308 for (i
= 0; i
< sizeof (x86_64_reloc_map
) / sizeof (struct elf_reloc_map
);
311 if (x86_64_reloc_map
[i
].bfd_reloc_val
== code
)
312 return elf_x86_64_rtype_to_howto (abfd
,
313 x86_64_reloc_map
[i
].elf_reloc_val
);
318 static reloc_howto_type
*
319 elf_x86_64_reloc_name_lookup (bfd
*abfd
,
324 if (!ABI_64_P (abfd
) && strcasecmp (r_name
, "R_X86_64_32") == 0)
326 /* Get x32 R_X86_64_32. */
327 reloc_howto_type
*reloc
328 = &x86_64_elf_howto_table
[ARRAY_SIZE (x86_64_elf_howto_table
) - 1];
329 BFD_ASSERT (reloc
->type
== (unsigned int) R_X86_64_32
);
333 for (i
= 0; i
< ARRAY_SIZE (x86_64_elf_howto_table
); i
++)
334 if (x86_64_elf_howto_table
[i
].name
!= NULL
335 && strcasecmp (x86_64_elf_howto_table
[i
].name
, r_name
) == 0)
336 return &x86_64_elf_howto_table
[i
];
341 /* Given an x86_64 ELF reloc type, fill in an arelent structure. */
344 elf_x86_64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
345 Elf_Internal_Rela
*dst
)
349 r_type
= ELF32_R_TYPE (dst
->r_info
);
350 cache_ptr
->howto
= elf_x86_64_rtype_to_howto (abfd
, r_type
);
351 BFD_ASSERT (r_type
== cache_ptr
->howto
->type
);
354 /* Support for core dump NOTE sections. */
356 elf_x86_64_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
361 switch (note
->descsz
)
366 case 296: /* sizeof(istruct elf_prstatus) on Linux/x32 */
368 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
371 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
379 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
381 elf_tdata (abfd
)->core
->signal
382 = bfd_get_16 (abfd
, note
->descdata
+ 12);
385 elf_tdata (abfd
)->core
->lwpid
386 = bfd_get_32 (abfd
, note
->descdata
+ 32);
395 /* Make a ".reg/999" section. */
396 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
397 size
, note
->descpos
+ offset
);
401 elf_x86_64_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
403 switch (note
->descsz
)
408 case 124: /* sizeof(struct elf_prpsinfo) on Linux/x32 */
409 elf_tdata (abfd
)->core
->pid
410 = bfd_get_32 (abfd
, note
->descdata
+ 12);
411 elf_tdata (abfd
)->core
->program
412 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
413 elf_tdata (abfd
)->core
->command
414 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
417 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
418 elf_tdata (abfd
)->core
->pid
419 = bfd_get_32 (abfd
, note
->descdata
+ 24);
420 elf_tdata (abfd
)->core
->program
421 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
422 elf_tdata (abfd
)->core
->command
423 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
426 /* Note that for some reason, a spurious space is tacked
427 onto the end of the args in some (at least one anyway)
428 implementations, so strip it off if it exists. */
431 char *command
= elf_tdata (abfd
)->core
->command
;
432 int n
= strlen (command
);
434 if (0 < n
&& command
[n
- 1] == ' ')
435 command
[n
- 1] = '\0';
443 elf_x86_64_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
,
446 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
448 const char *fname
, *psargs
;
459 va_start (ap
, note_type
);
460 fname
= va_arg (ap
, const char *);
461 psargs
= va_arg (ap
, const char *);
464 if (bed
->s
->elfclass
== ELFCLASS32
)
467 memset (&data
, 0, sizeof (data
));
468 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
469 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
470 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
471 &data
, sizeof (data
));
476 memset (&data
, 0, sizeof (data
));
477 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
478 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
479 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
480 &data
, sizeof (data
));
485 va_start (ap
, note_type
);
486 pid
= va_arg (ap
, long);
487 cursig
= va_arg (ap
, int);
488 gregs
= va_arg (ap
, const void *);
491 if (bed
->s
->elfclass
== ELFCLASS32
)
493 if (bed
->elf_machine_code
== EM_X86_64
)
495 prstatusx32_t prstat
;
496 memset (&prstat
, 0, sizeof (prstat
));
498 prstat
.pr_cursig
= cursig
;
499 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
500 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
501 &prstat
, sizeof (prstat
));
506 memset (&prstat
, 0, sizeof (prstat
));
508 prstat
.pr_cursig
= cursig
;
509 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
510 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
511 &prstat
, sizeof (prstat
));
517 memset (&prstat
, 0, sizeof (prstat
));
519 prstat
.pr_cursig
= cursig
;
520 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
521 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", note_type
,
522 &prstat
, sizeof (prstat
));
529 /* Functions for the x86-64 ELF linker. */
531 /* The name of the dynamic interpreter. This is put in the .interp
534 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
535 #define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
537 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
538 copying dynamic variables from a shared lib into an app's dynbss
539 section, and instead use a dynamic relocation to point into the
541 #define ELIMINATE_COPY_RELOCS 1
543 /* The size in bytes of an entry in the global offset table. */
545 #define GOT_ENTRY_SIZE 8
547 /* The size in bytes of an entry in the procedure linkage table. */
549 #define PLT_ENTRY_SIZE 16
551 /* The first entry in a procedure linkage table looks like this. See the
552 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */
554 static const bfd_byte elf_x86_64_plt0_entry
[PLT_ENTRY_SIZE
] =
556 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
557 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */
558 0x0f, 0x1f, 0x40, 0x00 /* nopl 0(%rax) */
561 /* Subsequent entries in a procedure linkage table look like this. */
563 static const bfd_byte elf_x86_64_plt_entry
[PLT_ENTRY_SIZE
] =
565 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
566 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
567 0x68, /* pushq immediate */
568 0, 0, 0, 0, /* replaced with index into relocation table. */
569 0xe9, /* jmp relative */
570 0, 0, 0, 0 /* replaced with offset to start of .plt0. */
573 /* The first entry in a procedure linkage table with BND relocations
576 static const bfd_byte elf_x86_64_bnd_plt0_entry
[PLT_ENTRY_SIZE
] =
578 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
579 0xf2, 0xff, 0x25, 16, 0, 0, 0, /* bnd jmpq *GOT+16(%rip) */
580 0x0f, 0x1f, 0 /* nopl (%rax) */
583 /* Subsequent entries for legacy branches in a procedure linkage table
584 with BND relocations look like this. */
586 static const bfd_byte elf_x86_64_legacy_plt_entry
[PLT_ENTRY_SIZE
] =
588 0x68, 0, 0, 0, 0, /* pushq immediate */
589 0xe9, 0, 0, 0, 0, /* jmpq relative */
590 0x66, 0x0f, 0x1f, 0x44, 0, 0 /* nopw (%rax,%rax,1) */
593 /* Subsequent entries for branches with BND prefx in a procedure linkage
594 table with BND relocations look like this. */
596 static const bfd_byte elf_x86_64_bnd_plt_entry
[PLT_ENTRY_SIZE
] =
598 0x68, 0, 0, 0, 0, /* pushq immediate */
599 0xf2, 0xe9, 0, 0, 0, 0, /* bnd jmpq relative */
600 0x0f, 0x1f, 0x44, 0, 0 /* nopl 0(%rax,%rax,1) */
603 /* Entries for legacy branches in the second procedure linkage table
606 static const bfd_byte elf_x86_64_legacy_plt2_entry
[8] =
608 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */
609 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
610 0x66, 0x90 /* xchg %ax,%ax */
613 /* Entries for branches with BND prefix in the second procedure linkage
614 table look like this. */
616 static const bfd_byte elf_x86_64_bnd_plt2_entry
[8] =
618 0xf2, 0xff, 0x25, /* bnd jmpq *name@GOTPC(%rip) */
619 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */
623 /* .eh_frame covering the .plt section. */
625 static const bfd_byte elf_x86_64_eh_frame_plt
[] =
627 #define PLT_CIE_LENGTH 20
628 #define PLT_FDE_LENGTH 36
629 #define PLT_FDE_START_OFFSET 4 + PLT_CIE_LENGTH + 8
630 #define PLT_FDE_LEN_OFFSET 4 + PLT_CIE_LENGTH + 12
631 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
632 0, 0, 0, 0, /* CIE ID */
634 'z', 'R', 0, /* Augmentation string */
635 1, /* Code alignment factor */
636 0x78, /* Data alignment factor */
637 16, /* Return address column */
638 1, /* Augmentation size */
639 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
640 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
641 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
642 DW_CFA_nop
, DW_CFA_nop
,
644 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
645 PLT_CIE_LENGTH
+ 8, 0, 0, 0, /* CIE pointer */
646 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
647 0, 0, 0, 0, /* .plt size goes here */
648 0, /* Augmentation size */
649 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
650 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
651 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
652 DW_CFA_advance_loc
+ 10, /* DW_CFA_advance_loc: 10 to __PLT__+16 */
653 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
654 11, /* Block length */
655 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
656 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
657 DW_OP_lit15
, DW_OP_and
, DW_OP_lit11
, DW_OP_ge
,
658 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
659 DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
, DW_CFA_nop
662 /* Architecture-specific backend data for x86-64. */
664 struct elf_x86_64_backend_data
666 /* Templates for the initial PLT entry and for subsequent entries. */
667 const bfd_byte
*plt0_entry
;
668 const bfd_byte
*plt_entry
;
669 unsigned int plt_entry_size
; /* Size of each PLT entry. */
671 /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2]. */
672 unsigned int plt0_got1_offset
;
673 unsigned int plt0_got2_offset
;
675 /* Offset of the end of the PC-relative instruction containing
677 unsigned int plt0_got2_insn_end
;
679 /* Offsets into plt_entry that are to be replaced with... */
680 unsigned int plt_got_offset
; /* ... address of this symbol in .got. */
681 unsigned int plt_reloc_offset
; /* ... offset into relocation table. */
682 unsigned int plt_plt_offset
; /* ... offset to start of .plt. */
684 /* Length of the PC-relative instruction containing plt_got_offset. */
685 unsigned int plt_got_insn_size
;
687 /* Offset of the end of the PC-relative jump to plt0_entry. */
688 unsigned int plt_plt_insn_end
;
690 /* Offset into plt_entry where the initial value of the GOT entry points. */
691 unsigned int plt_lazy_offset
;
693 /* .eh_frame covering the .plt section. */
694 const bfd_byte
*eh_frame_plt
;
695 unsigned int eh_frame_plt_size
;
698 #define get_elf_x86_64_arch_data(bed) \
699 ((const struct elf_x86_64_backend_data *) (bed)->arch_data)
701 #define get_elf_x86_64_backend_data(abfd) \
702 get_elf_x86_64_arch_data (get_elf_backend_data (abfd))
704 #define GET_PLT_ENTRY_SIZE(abfd) \
705 get_elf_x86_64_backend_data (abfd)->plt_entry_size
707 /* These are the standard parameters. */
708 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed
=
710 elf_x86_64_plt0_entry
, /* plt0_entry */
711 elf_x86_64_plt_entry
, /* plt_entry */
712 sizeof (elf_x86_64_plt_entry
), /* plt_entry_size */
713 2, /* plt0_got1_offset */
714 8, /* plt0_got2_offset */
715 12, /* plt0_got2_insn_end */
716 2, /* plt_got_offset */
717 7, /* plt_reloc_offset */
718 12, /* plt_plt_offset */
719 6, /* plt_got_insn_size */
720 PLT_ENTRY_SIZE
, /* plt_plt_insn_end */
721 6, /* plt_lazy_offset */
722 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
723 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
726 static const struct elf_x86_64_backend_data elf_x86_64_bnd_arch_bed
=
728 elf_x86_64_bnd_plt0_entry
, /* plt0_entry */
729 elf_x86_64_bnd_plt_entry
, /* plt_entry */
730 sizeof (elf_x86_64_bnd_plt_entry
), /* plt_entry_size */
731 2, /* plt0_got1_offset */
732 1+8, /* plt0_got2_offset */
733 1+12, /* plt0_got2_insn_end */
734 1+2, /* plt_got_offset */
735 1, /* plt_reloc_offset */
736 7, /* plt_plt_offset */
737 1+6, /* plt_got_insn_size */
738 11, /* plt_plt_insn_end */
739 0, /* plt_lazy_offset */
740 elf_x86_64_eh_frame_plt
, /* eh_frame_plt */
741 sizeof (elf_x86_64_eh_frame_plt
), /* eh_frame_plt_size */
744 #define elf_backend_arch_data &elf_x86_64_arch_bed
746 /* Is a undefined weak symbol which is resolved to 0. Reference to an
747 undefined weak symbol is resolved to 0 when building executable if
749 1. Has non-GOT/non-PLT relocations in text section. Or
750 2. Has no GOT/PLT relocation.
752 #define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, GOT_RELOC, EH) \
753 ((EH)->elf.root.type == bfd_link_hash_undefweak \
754 && bfd_link_executable (INFO) \
755 && (elf_x86_64_hash_table (INFO)->interp == NULL \
757 || (EH)->has_non_got_reloc \
758 || !(INFO)->dynamic_undefined_weak))
760 /* x86-64 ELF linker hash entry. */
762 struct elf_x86_64_link_hash_entry
764 struct elf_link_hash_entry elf
;
766 /* Track dynamic relocs copied for this symbol. */
767 struct elf_dyn_relocs
*dyn_relocs
;
769 #define GOT_UNKNOWN 0
773 #define GOT_TLS_GDESC 4
774 #define GOT_TLS_GD_BOTH_P(type) \
775 ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
776 #define GOT_TLS_GD_P(type) \
777 ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
778 #define GOT_TLS_GDESC_P(type) \
779 ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
780 #define GOT_TLS_GD_ANY_P(type) \
781 (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
782 unsigned char tls_type
;
784 /* TRUE if a weak symbol with a real definition needs a copy reloc.
785 When there is a weak symbol with a real definition, the processor
786 independent code will have arranged for us to see the real
787 definition first. We need to copy the needs_copy bit from the
788 real definition and check it when allowing copy reloc in PIE. */
789 unsigned int needs_copy
: 1;
791 /* TRUE if symbol has at least one BND relocation. */
792 unsigned int has_bnd_reloc
: 1;
794 /* TRUE if symbol has GOT or PLT relocations. */
795 unsigned int has_got_reloc
: 1;
797 /* TRUE if symbol has non-GOT/non-PLT relocations in text sections. */
798 unsigned int has_non_got_reloc
: 1;
800 /* 0: symbol isn't __tls_get_addr.
801 1: symbol is __tls_get_addr.
802 2: symbol is unknown. */
803 unsigned int tls_get_addr
: 2;
805 /* Reference count of C/C++ function pointer relocations in read-write
806 section which can be resolved at run-time. */
807 bfd_signed_vma func_pointer_refcount
;
809 /* Information about the GOT PLT entry. Filled when there are both
810 GOT and PLT relocations against the same function. */
811 union gotplt_union plt_got
;
813 /* Information about the second PLT entry. Filled when has_bnd_reloc is
815 union gotplt_union plt_bnd
;
817 /* Offset of the GOTPLT entry reserved for the TLS descriptor,
818 starting at the end of the jump table. */
822 #define elf_x86_64_hash_entry(ent) \
823 ((struct elf_x86_64_link_hash_entry *)(ent))
825 struct elf_x86_64_obj_tdata
827 struct elf_obj_tdata root
;
829 /* tls_type for each local got entry. */
830 char *local_got_tls_type
;
832 /* GOTPLT entries for TLS descriptors. */
833 bfd_vma
*local_tlsdesc_gotent
;
836 #define elf_x86_64_tdata(abfd) \
837 ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
839 #define elf_x86_64_local_got_tls_type(abfd) \
840 (elf_x86_64_tdata (abfd)->local_got_tls_type)
842 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
843 (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
845 #define is_x86_64_elf(bfd) \
846 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
847 && elf_tdata (bfd) != NULL \
848 && elf_object_id (bfd) == X86_64_ELF_DATA)
851 elf_x86_64_mkobject (bfd
*abfd
)
853 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_x86_64_obj_tdata
),
857 /* x86-64 ELF linker hash table. */
859 struct elf_x86_64_link_hash_table
861 struct elf_link_hash_table elf
;
863 /* Short-cuts to get to dynamic linker sections. */
865 asection
*plt_eh_frame
;
871 bfd_signed_vma refcount
;
875 /* The amount of space used by the jump slots in the GOT. */
876 bfd_vma sgotplt_jump_table_size
;
878 /* Small local sym cache. */
879 struct sym_cache sym_cache
;
881 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
882 bfd_vma (*r_sym
) (bfd_vma
);
883 unsigned int pointer_r_type
;
884 const char *dynamic_interpreter
;
885 int dynamic_interpreter_size
;
887 /* _TLS_MODULE_BASE_ symbol. */
888 struct bfd_link_hash_entry
*tls_module_base
;
890 /* Used by local STT_GNU_IFUNC symbols. */
891 htab_t loc_hash_table
;
892 void * loc_hash_memory
;
894 /* The offset into splt of the PLT entry for the TLS descriptor
895 resolver. Special values are 0, if not necessary (or not found
896 to be necessary yet), and -1 if needed but not determined
899 /* The offset into sgot of the GOT entry used by the PLT entry
903 /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt. */
904 bfd_vma next_jump_slot_index
;
905 /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt. */
906 bfd_vma next_irelative_index
;
908 /* TRUE if there are dynamic relocs against IFUNC symbols that apply
909 to read-only sections. */
910 bfd_boolean readonly_dynrelocs_against_ifunc
;
913 /* Get the x86-64 ELF linker hash table from a link_info structure. */
915 #define elf_x86_64_hash_table(p) \
916 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
917 == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
919 #define elf_x86_64_compute_jump_table_size(htab) \
920 ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
922 /* Create an entry in an x86-64 ELF linker hash table. */
924 static struct bfd_hash_entry
*
925 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
926 struct bfd_hash_table
*table
,
929 /* Allocate the structure if it has not already been allocated by a
933 entry
= (struct bfd_hash_entry
*)
934 bfd_hash_allocate (table
,
935 sizeof (struct elf_x86_64_link_hash_entry
));
940 /* Call the allocation method of the superclass. */
941 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
944 struct elf_x86_64_link_hash_entry
*eh
;
946 eh
= (struct elf_x86_64_link_hash_entry
*) entry
;
947 eh
->dyn_relocs
= NULL
;
948 eh
->tls_type
= GOT_UNKNOWN
;
950 eh
->has_bnd_reloc
= 0;
951 eh
->has_got_reloc
= 0;
952 eh
->has_non_got_reloc
= 0;
953 eh
->tls_get_addr
= 2;
954 eh
->func_pointer_refcount
= 0;
955 eh
->plt_bnd
.offset
= (bfd_vma
) -1;
956 eh
->plt_got
.offset
= (bfd_vma
) -1;
957 eh
->tlsdesc_got
= (bfd_vma
) -1;
963 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
964 for local symbol so that we can handle local STT_GNU_IFUNC symbols
965 as global symbol. We reuse indx and dynstr_index for local symbol
966 hash since they aren't used by global symbols in this backend. */
969 elf_x86_64_local_htab_hash (const void *ptr
)
971 struct elf_link_hash_entry
*h
972 = (struct elf_link_hash_entry
*) ptr
;
973 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
976 /* Compare local hash entries. */
979 elf_x86_64_local_htab_eq (const void *ptr1
, const void *ptr2
)
981 struct elf_link_hash_entry
*h1
982 = (struct elf_link_hash_entry
*) ptr1
;
983 struct elf_link_hash_entry
*h2
984 = (struct elf_link_hash_entry
*) ptr2
;
986 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
989 /* Find and/or create a hash entry for local symbol. */
991 static struct elf_link_hash_entry
*
992 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table
*htab
,
993 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
996 struct elf_x86_64_link_hash_entry e
, *ret
;
997 asection
*sec
= abfd
->sections
;
998 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
999 htab
->r_sym (rel
->r_info
));
1002 e
.elf
.indx
= sec
->id
;
1003 e
.elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
1004 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &e
, h
,
1005 create
? INSERT
: NO_INSERT
);
1012 ret
= (struct elf_x86_64_link_hash_entry
*) *slot
;
1016 ret
= (struct elf_x86_64_link_hash_entry
*)
1017 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
1018 sizeof (struct elf_x86_64_link_hash_entry
));
1021 memset (ret
, 0, sizeof (*ret
));
1022 ret
->elf
.indx
= sec
->id
;
1023 ret
->elf
.dynstr_index
= htab
->r_sym (rel
->r_info
);
1024 ret
->elf
.dynindx
= -1;
1025 ret
->func_pointer_refcount
= 0;
1026 ret
->plt_got
.offset
= (bfd_vma
) -1;
1032 /* Destroy an X86-64 ELF linker hash table. */
1035 elf_x86_64_link_hash_table_free (bfd
*obfd
)
1037 struct elf_x86_64_link_hash_table
*htab
1038 = (struct elf_x86_64_link_hash_table
*) obfd
->link
.hash
;
1040 if (htab
->loc_hash_table
)
1041 htab_delete (htab
->loc_hash_table
);
1042 if (htab
->loc_hash_memory
)
1043 objalloc_free ((struct objalloc
*) htab
->loc_hash_memory
);
1044 _bfd_elf_link_hash_table_free (obfd
);
1047 /* Create an X86-64 ELF linker hash table. */
1049 static struct bfd_link_hash_table
*
1050 elf_x86_64_link_hash_table_create (bfd
*abfd
)
1052 struct elf_x86_64_link_hash_table
*ret
;
1053 bfd_size_type amt
= sizeof (struct elf_x86_64_link_hash_table
);
1055 ret
= (struct elf_x86_64_link_hash_table
*) bfd_zmalloc (amt
);
1059 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1060 elf_x86_64_link_hash_newfunc
,
1061 sizeof (struct elf_x86_64_link_hash_entry
),
1068 if (ABI_64_P (abfd
))
1070 ret
->r_info
= elf64_r_info
;
1071 ret
->r_sym
= elf64_r_sym
;
1072 ret
->pointer_r_type
= R_X86_64_64
;
1073 ret
->dynamic_interpreter
= ELF64_DYNAMIC_INTERPRETER
;
1074 ret
->dynamic_interpreter_size
= sizeof ELF64_DYNAMIC_INTERPRETER
;
1078 ret
->r_info
= elf32_r_info
;
1079 ret
->r_sym
= elf32_r_sym
;
1080 ret
->pointer_r_type
= R_X86_64_32
;
1081 ret
->dynamic_interpreter
= ELF32_DYNAMIC_INTERPRETER
;
1082 ret
->dynamic_interpreter_size
= sizeof ELF32_DYNAMIC_INTERPRETER
;
1085 ret
->loc_hash_table
= htab_try_create (1024,
1086 elf_x86_64_local_htab_hash
,
1087 elf_x86_64_local_htab_eq
,
1089 ret
->loc_hash_memory
= objalloc_create ();
1090 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1092 elf_x86_64_link_hash_table_free (abfd
);
1095 ret
->elf
.root
.hash_table_free
= elf_x86_64_link_hash_table_free
;
1097 return &ret
->elf
.root
;
1100 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1101 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1105 elf_x86_64_create_dynamic_sections (bfd
*dynobj
,
1106 struct bfd_link_info
*info
)
1108 struct elf_x86_64_link_hash_table
*htab
;
1110 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
1113 htab
= elf_x86_64_hash_table (info
);
1117 /* Set the contents of the .interp section to the interpreter. */
1118 if (bfd_link_executable (info
) && !info
->nointerp
)
1120 asection
*s
= bfd_get_linker_section (dynobj
, ".interp");
1123 s
->size
= htab
->dynamic_interpreter_size
;
1124 s
->contents
= (unsigned char *) htab
->dynamic_interpreter
;
1128 if (!info
->no_ld_generated_unwind_info
1129 && htab
->plt_eh_frame
== NULL
1130 && htab
->elf
.splt
!= NULL
)
1132 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1133 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1134 | SEC_LINKER_CREATED
);
1136 = bfd_make_section_anyway_with_flags (dynobj
, ".eh_frame", flags
);
1137 if (htab
->plt_eh_frame
== NULL
1138 || !bfd_set_section_alignment (dynobj
, htab
->plt_eh_frame
, 3))
1142 /* Align .got section to its entry size. */
1143 if (htab
->elf
.sgot
!= NULL
1144 && !bfd_set_section_alignment (dynobj
, htab
->elf
.sgot
, 3))
1147 /* Align .got.plt section to its entry size. */
1148 if (htab
->elf
.sgotplt
!= NULL
1149 && !bfd_set_section_alignment (dynobj
, htab
->elf
.sgotplt
, 3))
1155 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1158 elf_x86_64_copy_indirect_symbol (struct bfd_link_info
*info
,
1159 struct elf_link_hash_entry
*dir
,
1160 struct elf_link_hash_entry
*ind
)
1162 struct elf_x86_64_link_hash_entry
*edir
, *eind
;
1164 edir
= (struct elf_x86_64_link_hash_entry
*) dir
;
1165 eind
= (struct elf_x86_64_link_hash_entry
*) ind
;
1167 if (!edir
->has_bnd_reloc
)
1168 edir
->has_bnd_reloc
= eind
->has_bnd_reloc
;
1170 if (!edir
->has_got_reloc
)
1171 edir
->has_got_reloc
= eind
->has_got_reloc
;
1173 if (!edir
->has_non_got_reloc
)
1174 edir
->has_non_got_reloc
= eind
->has_non_got_reloc
;
1176 if (eind
->dyn_relocs
!= NULL
)
1178 if (edir
->dyn_relocs
!= NULL
)
1180 struct elf_dyn_relocs
**pp
;
1181 struct elf_dyn_relocs
*p
;
1183 /* Add reloc counts against the indirect sym to the direct sym
1184 list. Merge any entries against the same section. */
1185 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1187 struct elf_dyn_relocs
*q
;
1189 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1190 if (q
->sec
== p
->sec
)
1192 q
->pc_count
+= p
->pc_count
;
1193 q
->count
+= p
->count
;
1200 *pp
= edir
->dyn_relocs
;
1203 edir
->dyn_relocs
= eind
->dyn_relocs
;
1204 eind
->dyn_relocs
= NULL
;
1207 if (ind
->root
.type
== bfd_link_hash_indirect
1208 && dir
->got
.refcount
<= 0)
1210 edir
->tls_type
= eind
->tls_type
;
1211 eind
->tls_type
= GOT_UNKNOWN
;
1214 if (ELIMINATE_COPY_RELOCS
1215 && ind
->root
.type
!= bfd_link_hash_indirect
1216 && dir
->dynamic_adjusted
)
1218 /* If called to transfer flags for a weakdef during processing
1219 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1220 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1221 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1222 dir
->ref_regular
|= ind
->ref_regular
;
1223 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1224 dir
->needs_plt
|= ind
->needs_plt
;
1225 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1229 if (eind
->func_pointer_refcount
> 0)
1231 edir
->func_pointer_refcount
+= eind
->func_pointer_refcount
;
1232 eind
->func_pointer_refcount
= 0;
1235 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
1240 elf64_x86_64_elf_object_p (bfd
*abfd
)
1242 /* Set the right machine number for an x86-64 elf64 file. */
1243 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64
);
1248 elf32_x86_64_elf_object_p (bfd
*abfd
)
1250 /* Set the right machine number for an x86-64 elf32 file. */
1251 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32
);
1255 /* Return TRUE if the TLS access code sequence support transition
1259 elf_x86_64_check_tls_transition (bfd
*abfd
,
1260 struct bfd_link_info
*info
,
1263 Elf_Internal_Shdr
*symtab_hdr
,
1264 struct elf_link_hash_entry
**sym_hashes
,
1265 unsigned int r_type
,
1266 const Elf_Internal_Rela
*rel
,
1267 const Elf_Internal_Rela
*relend
)
1270 unsigned long r_symndx
;
1271 bfd_boolean largepic
= FALSE
;
1272 struct elf_link_hash_entry
*h
;
1274 struct elf_x86_64_link_hash_table
*htab
;
1276 bfd_boolean indirect_call
, tls_get_addr
;
1278 htab
= elf_x86_64_hash_table (info
);
1279 offset
= rel
->r_offset
;
1282 case R_X86_64_TLSGD
:
1283 case R_X86_64_TLSLD
:
1284 if ((rel
+ 1) >= relend
)
1287 if (r_type
== R_X86_64_TLSGD
)
1289 /* Check transition from GD access model. For 64bit, only
1290 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1291 .word 0x6666; rex64; call __tls_get_addr@PLT
1293 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1295 call *__tls_get_addr@GOTPCREL(%rip)
1296 which may be converted to
1297 addr32 call __tls_get_addr
1298 can transit to different access model. For 32bit, only
1299 leaq foo@tlsgd(%rip), %rdi
1300 .word 0x6666; rex64; call __tls_get_addr@PLT
1302 leaq foo@tlsgd(%rip), %rdi
1304 call *__tls_get_addr@GOTPCREL(%rip)
1305 which may be converted to
1306 addr32 call __tls_get_addr
1307 can transit to different access model. For largepic,
1309 leaq foo@tlsgd(%rip), %rdi
1310 movabsq $__tls_get_addr@pltoff, %rax
1314 leaq foo@tlsgd(%rip), %rdi
1315 movabsq $__tls_get_addr@pltoff, %rax
1319 static const unsigned char leaq
[] = { 0x66, 0x48, 0x8d, 0x3d };
1321 if ((offset
+ 12) > sec
->size
)
1324 call
= contents
+ offset
+ 4;
1326 || !((call
[1] == 0x48
1334 && call
[3] == 0xe8)))
1336 if (!ABI_64_P (abfd
)
1337 || (offset
+ 19) > sec
->size
1339 || memcmp (call
- 7, leaq
+ 1, 3) != 0
1340 || memcmp (call
, "\x48\xb8", 2) != 0
1344 || !((call
[10] == 0x48 && call
[12] == 0xd8)
1345 || (call
[10] == 0x4c && call
[12] == 0xf8)))
1349 else if (ABI_64_P (abfd
))
1352 || memcmp (contents
+ offset
- 4, leaq
, 4) != 0)
1358 || memcmp (contents
+ offset
- 3, leaq
+ 1, 3) != 0)
1361 indirect_call
= call
[2] == 0xff;
1365 /* Check transition from LD access model. Only
1366 leaq foo@tlsld(%rip), %rdi;
1367 call __tls_get_addr@PLT
1369 leaq foo@tlsld(%rip), %rdi;
1370 call *__tls_get_addr@GOTPCREL(%rip)
1371 which may be converted to
1372 addr32 call __tls_get_addr
1373 can transit to different access model. For largepic
1375 leaq foo@tlsld(%rip), %rdi
1376 movabsq $__tls_get_addr@pltoff, %rax
1380 leaq foo@tlsld(%rip), %rdi
1381 movabsq $__tls_get_addr@pltoff, %rax
1385 static const unsigned char lea
[] = { 0x48, 0x8d, 0x3d };
1387 if (offset
< 3 || (offset
+ 9) > sec
->size
)
1390 if (memcmp (contents
+ offset
- 3, lea
, 3) != 0)
1393 call
= contents
+ offset
+ 4;
1394 if (!(call
[0] == 0xe8
1395 || (call
[0] == 0xff && call
[1] == 0x15)
1396 || (call
[0] == 0x67 && call
[1] == 0xe8)))
1398 if (!ABI_64_P (abfd
)
1399 || (offset
+ 19) > sec
->size
1400 || memcmp (call
, "\x48\xb8", 2) != 0
1404 || !((call
[10] == 0x48 && call
[12] == 0xd8)
1405 || (call
[10] == 0x4c && call
[12] == 0xf8)))
1409 indirect_call
= call
[0] == 0xff;
1412 r_symndx
= htab
->r_sym (rel
[1].r_info
);
1413 if (r_symndx
< symtab_hdr
->sh_info
)
1416 tls_get_addr
= FALSE
;
1417 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1418 if (h
!= NULL
&& h
->root
.root
.string
!= NULL
)
1420 struct elf_x86_64_link_hash_entry
*eh
1421 = (struct elf_x86_64_link_hash_entry
*) h
;
1422 tls_get_addr
= eh
->tls_get_addr
== 1;
1423 if (eh
->tls_get_addr
> 1)
1425 /* Use strncmp to check __tls_get_addr since
1426 __tls_get_addr may be versioned. */
1427 if (strncmp (h
->root
.root
.string
, "__tls_get_addr", 14)
1430 eh
->tls_get_addr
= 1;
1431 tls_get_addr
= TRUE
;
1434 eh
->tls_get_addr
= 0;
1441 return ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLTOFF64
;
1442 else if (indirect_call
)
1443 return ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_GOTPCRELX
;
1445 return (ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PC32
1446 || ELF32_R_TYPE (rel
[1].r_info
) == R_X86_64_PLT32
);
1448 case R_X86_64_GOTTPOFF
:
1449 /* Check transition from IE access model:
1450 mov foo@gottpoff(%rip), %reg
1451 add foo@gottpoff(%rip), %reg
1454 /* Check REX prefix first. */
1455 if (offset
>= 3 && (offset
+ 4) <= sec
->size
)
1457 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1458 if (val
!= 0x48 && val
!= 0x4c)
1460 /* X32 may have 0x44 REX prefix or no REX prefix. */
1461 if (ABI_64_P (abfd
))
1467 /* X32 may not have any REX prefix. */
1468 if (ABI_64_P (abfd
))
1470 if (offset
< 2 || (offset
+ 3) > sec
->size
)
1474 val
= bfd_get_8 (abfd
, contents
+ offset
- 2);
1475 if (val
!= 0x8b && val
!= 0x03)
1478 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1479 return (val
& 0xc7) == 5;
1481 case R_X86_64_GOTPC32_TLSDESC
:
1482 /* Check transition from GDesc access model:
1483 leaq x@tlsdesc(%rip), %rax
1485 Make sure it's a leaq adding rip to a 32-bit offset
1486 into any register, although it's probably almost always
1489 if (offset
< 3 || (offset
+ 4) > sec
->size
)
1492 val
= bfd_get_8 (abfd
, contents
+ offset
- 3);
1493 if ((val
& 0xfb) != 0x48)
1496 if (bfd_get_8 (abfd
, contents
+ offset
- 2) != 0x8d)
1499 val
= bfd_get_8 (abfd
, contents
+ offset
- 1);
1500 return (val
& 0xc7) == 0x05;
1502 case R_X86_64_TLSDESC_CALL
:
1503 /* Check transition from GDesc access model:
1504 call *x@tlsdesc(%rax)
1506 if (offset
+ 2 <= sec
->size
)
1508 /* Make sure that it's a call *x@tlsdesc(%rax). */
1509 call
= contents
+ offset
;
1510 return call
[0] == 0xff && call
[1] == 0x10;
1520 /* Return TRUE if the TLS access transition is OK or no transition
1521 will be performed. Update R_TYPE if there is a transition. */
1524 elf_x86_64_tls_transition (struct bfd_link_info
*info
, bfd
*abfd
,
1525 asection
*sec
, bfd_byte
*contents
,
1526 Elf_Internal_Shdr
*symtab_hdr
,
1527 struct elf_link_hash_entry
**sym_hashes
,
1528 unsigned int *r_type
, int tls_type
,
1529 const Elf_Internal_Rela
*rel
,
1530 const Elf_Internal_Rela
*relend
,
1531 struct elf_link_hash_entry
*h
,
1532 unsigned long r_symndx
,
1533 bfd_boolean from_relocate_section
)
1535 unsigned int from_type
= *r_type
;
1536 unsigned int to_type
= from_type
;
1537 bfd_boolean check
= TRUE
;
1539 /* Skip TLS transition for functions. */
1541 && (h
->type
== STT_FUNC
1542 || h
->type
== STT_GNU_IFUNC
))
1547 case R_X86_64_TLSGD
:
1548 case R_X86_64_GOTPC32_TLSDESC
:
1549 case R_X86_64_TLSDESC_CALL
:
1550 case R_X86_64_GOTTPOFF
:
1551 if (bfd_link_executable (info
))
1554 to_type
= R_X86_64_TPOFF32
;
1556 to_type
= R_X86_64_GOTTPOFF
;
1559 /* When we are called from elf_x86_64_relocate_section, there may
1560 be additional transitions based on TLS_TYPE. */
1561 if (from_relocate_section
)
1563 unsigned int new_to_type
= to_type
;
1565 if (bfd_link_executable (info
)
1568 && tls_type
== GOT_TLS_IE
)
1569 new_to_type
= R_X86_64_TPOFF32
;
1571 if (to_type
== R_X86_64_TLSGD
1572 || to_type
== R_X86_64_GOTPC32_TLSDESC
1573 || to_type
== R_X86_64_TLSDESC_CALL
)
1575 if (tls_type
== GOT_TLS_IE
)
1576 new_to_type
= R_X86_64_GOTTPOFF
;
1579 /* We checked the transition before when we were called from
1580 elf_x86_64_check_relocs. We only want to check the new
1581 transition which hasn't been checked before. */
1582 check
= new_to_type
!= to_type
&& from_type
== to_type
;
1583 to_type
= new_to_type
;
1588 case R_X86_64_TLSLD
:
1589 if (bfd_link_executable (info
))
1590 to_type
= R_X86_64_TPOFF32
;
1597 /* Return TRUE if there is no transition. */
1598 if (from_type
== to_type
)
1601 /* Check if the transition can be performed. */
1603 && ! elf_x86_64_check_tls_transition (abfd
, info
, sec
, contents
,
1604 symtab_hdr
, sym_hashes
,
1605 from_type
, rel
, relend
))
1607 reloc_howto_type
*from
, *to
;
1610 from
= elf_x86_64_rtype_to_howto (abfd
, from_type
);
1611 to
= elf_x86_64_rtype_to_howto (abfd
, to_type
);
1614 name
= h
->root
.root
.string
;
1617 struct elf_x86_64_link_hash_table
*htab
;
1619 htab
= elf_x86_64_hash_table (info
);
1624 Elf_Internal_Sym
*isym
;
1626 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1628 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
, NULL
);
1633 /* xgettext:c-format */
1634 (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1635 "in section `%A' failed"),
1636 abfd
, sec
, from
->name
, to
->name
, name
,
1637 (unsigned long) rel
->r_offset
);
1638 bfd_set_error (bfd_error_bad_value
);
1646 /* Rename some of the generic section flags to better document how they
1648 #define need_convert_load sec_flg0
1649 #define check_relocs_failed sec_flg1
1652 elf_x86_64_need_pic (bfd
*input_bfd
, asection
*sec
,
1653 struct elf_link_hash_entry
*h
,
1654 Elf_Internal_Shdr
*symtab_hdr
,
1655 Elf_Internal_Sym
*isym
,
1656 reloc_howto_type
*howto
)
1659 const char *und
= "";
1660 const char *pic
= "";
1665 name
= h
->root
.root
.string
;
1666 switch (ELF_ST_VISIBILITY (h
->other
))
1669 v
= _("hidden symbol ");
1672 v
= _("internal symbol ");
1675 v
= _("protected symbol ");
1679 pic
= _("; recompile with -fPIC");
1683 if (!h
->def_regular
&& !h
->def_dynamic
)
1684 und
= _("undefined ");
1688 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, isym
, NULL
);
1689 pic
= _("; recompile with -fPIC");
1692 /* xgettext:c-format */
1693 _bfd_error_handler (_("%B: relocation %s against %s%s`%s' can "
1694 "not be used when making a shared object%s"),
1695 input_bfd
, howto
->name
, und
, v
, name
, pic
);
1696 bfd_set_error (bfd_error_bad_value
);
1697 sec
->check_relocs_failed
= 1;
1701 /* With the local symbol, foo, we convert
1702 mov foo@GOTPCREL(%rip), %reg
1706 call/jmp *foo@GOTPCREL(%rip)
1708 nop call foo/jmp foo nop
1709 When PIC is false, convert
1710 test %reg, foo@GOTPCREL(%rip)
1714 binop foo@GOTPCREL(%rip), %reg
1717 where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1721 elf_x86_64_convert_load_reloc (bfd
*abfd
, asection
*sec
,
1723 Elf_Internal_Rela
*irel
,
1724 struct elf_link_hash_entry
*h
,
1725 bfd_boolean
*converted
,
1726 struct bfd_link_info
*link_info
)
1728 struct elf_x86_64_link_hash_table
*htab
;
1730 bfd_boolean require_reloc_pc32
;
1732 bfd_boolean to_reloc_pc32
;
1735 bfd_signed_vma raddend
;
1736 unsigned int opcode
;
1738 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
1739 unsigned int r_symndx
;
1741 bfd_vma roff
= irel
->r_offset
;
1743 if (roff
< (r_type
== R_X86_64_REX_GOTPCRELX
? 3 : 2))
1746 raddend
= irel
->r_addend
;
1747 /* Addend for 32-bit PC-relative relocation must be -4. */
1751 htab
= elf_x86_64_hash_table (link_info
);
1752 is_pic
= bfd_link_pic (link_info
);
1754 relocx
= (r_type
== R_X86_64_GOTPCRELX
1755 || r_type
== R_X86_64_REX_GOTPCRELX
);
1757 /* TRUE if we can convert only to R_X86_64_PC32. Enable it for
1760 = link_info
->disable_target_specific_optimizations
> 1;
1762 r_symndx
= htab
->r_sym (irel
->r_info
);
1764 opcode
= bfd_get_8 (abfd
, contents
+ roff
- 2);
1766 /* Convert mov to lea since it has been done for a while. */
1769 /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
1770 for call, jmp or one of adc, add, and, cmp, or, sbb, sub,
1771 test, xor instructions. */
1776 /* We convert only to R_X86_64_PC32:
1778 2. R_X86_64_GOTPCREL since we can't modify REX byte.
1779 3. require_reloc_pc32 is true.
1782 to_reloc_pc32
= (opcode
== 0xff
1784 || require_reloc_pc32
1787 /* Get the symbol referred to by the reloc. */
1790 Elf_Internal_Sym
*isym
1791 = bfd_sym_from_r_symndx (&htab
->sym_cache
, abfd
, r_symndx
);
1793 /* Skip relocation against undefined symbols. */
1794 if (isym
->st_shndx
== SHN_UNDEF
)
1797 symtype
= ELF_ST_TYPE (isym
->st_info
);
1799 if (isym
->st_shndx
== SHN_ABS
)
1800 tsec
= bfd_abs_section_ptr
;
1801 else if (isym
->st_shndx
== SHN_COMMON
)
1802 tsec
= bfd_com_section_ptr
;
1803 else if (isym
->st_shndx
== SHN_X86_64_LCOMMON
)
1804 tsec
= &_bfd_elf_large_com_section
;
1806 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1808 toff
= isym
->st_value
;
1812 /* Undefined weak symbol is only bound locally in executable
1813 and its reference is resolved as 0 without relocation
1814 overflow. We can only perform this optimization for
1815 GOTPCRELX relocations since we need to modify REX byte.
1816 It is OK convert mov with R_X86_64_GOTPCREL to
1818 if ((relocx
|| opcode
== 0x8b)
1819 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info
,
1821 elf_x86_64_hash_entry (h
)))
1825 /* Skip for branch instructions since R_X86_64_PC32
1827 if (require_reloc_pc32
)
1832 /* For non-branch instructions, we can convert to
1833 R_X86_64_32/R_X86_64_32S since we know if there
1835 to_reloc_pc32
= FALSE
;
1838 /* Since we don't know the current PC when PIC is true,
1839 we can't convert to R_X86_64_PC32. */
1840 if (to_reloc_pc32
&& is_pic
)
1845 /* Avoid optimizing GOTPCREL relocations againt _DYNAMIC since
1846 ld.so may use its link-time address. */
1847 else if ((h
->def_regular
1848 || h
->root
.type
== bfd_link_hash_defined
1849 || h
->root
.type
== bfd_link_hash_defweak
)
1850 && h
!= htab
->elf
.hdynamic
1851 && SYMBOL_REFERENCES_LOCAL (link_info
, h
))
1853 /* bfd_link_hash_new or bfd_link_hash_undefined is
1854 set by an assignment in a linker script in
1855 bfd_elf_record_link_assignment. */
1857 && (h
->root
.type
== bfd_link_hash_new
1858 || h
->root
.type
== bfd_link_hash_undefined
1859 || ((h
->root
.type
== bfd_link_hash_defined
1860 || h
->root
.type
== bfd_link_hash_defweak
)
1861 && h
->root
.u
.def
.section
== bfd_und_section_ptr
)))
1863 /* Skip since R_X86_64_32/R_X86_64_32S may overflow. */
1864 if (require_reloc_pc32
)
1868 tsec
= h
->root
.u
.def
.section
;
1869 toff
= h
->root
.u
.def
.value
;
1876 /* Don't convert GOTPCREL relocation against large section. */
1877 if (elf_section_data (tsec
) != NULL
1878 && (elf_section_flags (tsec
) & SHF_X86_64_LARGE
) != 0)
1881 /* We can only estimate relocation overflow for R_X86_64_PC32. */
1885 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
1887 /* At this stage in linking, no SEC_MERGE symbol has been
1888 adjusted, so all references to such symbols need to be
1889 passed through _bfd_merged_section_offset. (Later, in
1890 relocate_section, all SEC_MERGE symbols *except* for
1891 section symbols have been adjusted.)
1893 gas may reduce relocations against symbols in SEC_MERGE
1894 sections to a relocation against the section symbol when
1895 the original addend was zero. When the reloc is against
1896 a section symbol we should include the addend in the
1897 offset passed to _bfd_merged_section_offset, since the
1898 location of interest is the original symbol. On the
1899 other hand, an access to "sym+addend" where "sym" is not
1900 a section symbol should not include the addend; Such an
1901 access is presumed to be an offset from "sym"; The
1902 location of interest is just "sym". */
1903 if (symtype
== STT_SECTION
)
1906 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
1907 elf_section_data (tsec
)->sec_info
,
1910 if (symtype
!= STT_SECTION
)
1916 /* Don't convert if R_X86_64_PC32 relocation overflows. */
1917 if (tsec
->output_section
== sec
->output_section
)
1919 if ((toff
- roff
+ 0x80000000) > 0xffffffff)
1924 bfd_signed_vma distance
;
1926 /* At this point, we don't know the load addresses of TSEC
1927 section nor SEC section. We estimate the distrance between
1928 SEC and TSEC. We store the estimated distances in the
1929 compressed_size field of the output section, which is only
1930 used to decompress the compressed input section. */
1931 if (sec
->output_section
->compressed_size
== 0)
1934 bfd_size_type size
= 0;
1935 for (asect
= link_info
->output_bfd
->sections
;
1937 asect
= asect
->next
)
1938 /* Skip debug sections since compressed_size is used to
1939 compress debug sections. */
1940 if ((asect
->flags
& SEC_DEBUGGING
) == 0)
1943 for (i
= asect
->map_head
.s
;
1947 size
= align_power (size
, i
->alignment_power
);
1950 asect
->compressed_size
= size
;
1954 /* Don't convert GOTPCREL relocations if TSEC isn't placed
1956 distance
= (tsec
->output_section
->compressed_size
1957 - sec
->output_section
->compressed_size
);
1961 /* Take PT_GNU_RELRO segment into account by adding
1963 if ((toff
+ distance
+ get_elf_backend_data (abfd
)->maxpagesize
1964 - roff
+ 0x80000000) > 0xffffffff)
1971 /* We have "call/jmp *foo@GOTPCREL(%rip)". */
1976 /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
1978 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
1981 /* Convert to "jmp foo nop". */
1984 nop_offset
= irel
->r_offset
+ 3;
1985 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
1986 irel
->r_offset
-= 1;
1987 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
1991 struct elf_x86_64_link_hash_entry
*eh
1992 = (struct elf_x86_64_link_hash_entry
*) h
;
1994 /* Convert to "nop call foo". ADDR_PREFIX_OPCODE
1997 /* To support TLS optimization, always use addr32 prefix for
1998 "call *__tls_get_addr@GOTPCREL(%rip)". */
1999 if (eh
&& eh
->tls_get_addr
== 1)
2002 nop_offset
= irel
->r_offset
- 2;
2006 nop
= link_info
->call_nop_byte
;
2007 if (link_info
->call_nop_as_suffix
)
2009 nop_offset
= irel
->r_offset
+ 3;
2010 disp
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
2011 irel
->r_offset
-= 1;
2012 bfd_put_32 (abfd
, disp
, contents
+ irel
->r_offset
);
2015 nop_offset
= irel
->r_offset
- 2;
2018 bfd_put_8 (abfd
, nop
, contents
+ nop_offset
);
2019 bfd_put_8 (abfd
, modrm
, contents
+ irel
->r_offset
- 1);
2020 r_type
= R_X86_64_PC32
;
2025 unsigned int rex_mask
= REX_R
;
2027 if (r_type
== R_X86_64_REX_GOTPCRELX
)
2028 rex
= bfd_get_8 (abfd
, contents
+ roff
- 3);
2036 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
2037 "lea foo(%rip), %reg". */
2039 r_type
= R_X86_64_PC32
;
2043 /* Convert "mov foo@GOTPCREL(%rip), %reg" to
2044 "mov $foo, %reg". */
2046 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2047 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
2048 if ((rex
& REX_W
) != 0
2049 && ABI_64_P (link_info
->output_bfd
))
2051 /* Keep the REX_W bit in REX byte for LP64. */
2052 r_type
= R_X86_64_32S
;
2053 goto rewrite_modrm_rex
;
2057 /* If the REX_W bit in REX byte isn't needed,
2058 use R_X86_64_32 and clear the W bit to avoid
2059 sign-extend imm32 to imm64. */
2060 r_type
= R_X86_64_32
;
2061 /* Clear the W bit in REX byte. */
2063 goto rewrite_modrm_rex
;
2069 /* R_X86_64_PC32 isn't supported. */
2073 modrm
= bfd_get_8 (abfd
, contents
+ roff
- 1);
2076 /* Convert "test %reg, foo@GOTPCREL(%rip)" to
2077 "test $foo, %reg". */
2078 modrm
= 0xc0 | (modrm
& 0x38) >> 3;
2083 /* Convert "binop foo@GOTPCREL(%rip), %reg" to
2084 "binop $foo, %reg". */
2085 modrm
= 0xc0 | (modrm
& 0x38) >> 3 | (opcode
& 0x3c);
2089 /* Use R_X86_64_32 with 32-bit operand to avoid relocation
2090 overflow when sign-extending imm32 to imm64. */
2091 r_type
= (rex
& REX_W
) != 0 ? R_X86_64_32S
: R_X86_64_32
;
2094 bfd_put_8 (abfd
, modrm
, contents
+ roff
- 1);
2098 /* Move the R bit to the B bit in REX byte. */
2099 rex
= (rex
& ~rex_mask
) | (rex
& REX_R
) >> 2;
2100 bfd_put_8 (abfd
, rex
, contents
+ roff
- 3);
2103 /* No addend for R_X86_64_32/R_X86_64_32S relocations. */
2107 bfd_put_8 (abfd
, opcode
, contents
+ roff
- 2);
2110 irel
->r_info
= htab
->r_info (r_symndx
, r_type
);
2117 /* Look through the relocs for a section during the first phase, and
2118 calculate needed space in the global offset table, procedure
2119 linkage table, and dynamic reloc sections. */
2122 elf_x86_64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
2124 const Elf_Internal_Rela
*relocs
)
2126 struct elf_x86_64_link_hash_table
*htab
;
2127 Elf_Internal_Shdr
*symtab_hdr
;
2128 struct elf_link_hash_entry
**sym_hashes
;
2129 const Elf_Internal_Rela
*rel
;
2130 const Elf_Internal_Rela
*rel_end
;
2133 bfd_boolean use_plt_got
;
2135 if (bfd_link_relocatable (info
))
2138 /* Don't do anything special with non-loaded, non-alloced sections.
2139 In particular, any relocs in such sections should not affect GOT
2140 and PLT reference counting (ie. we don't allow them to create GOT
2141 or PLT entries), there's no possibility or desire to optimize TLS
2142 relocs, and there's not much point in propagating relocs to shared
2143 libs that the dynamic linker won't relocate. */
2144 if ((sec
->flags
& SEC_ALLOC
) == 0)
2147 BFD_ASSERT (is_x86_64_elf (abfd
));
2149 htab
= elf_x86_64_hash_table (info
);
2152 sec
->check_relocs_failed
= 1;
2156 /* Get the section contents. */
2157 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2158 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2159 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2161 sec
->check_relocs_failed
= 1;
2165 use_plt_got
= get_elf_x86_64_backend_data (abfd
) == &elf_x86_64_arch_bed
;
2167 symtab_hdr
= &elf_symtab_hdr (abfd
);
2168 sym_hashes
= elf_sym_hashes (abfd
);
2172 rel_end
= relocs
+ sec
->reloc_count
;
2173 for (rel
= relocs
; rel
< rel_end
; rel
++)
2175 unsigned int r_type
;
2176 unsigned long r_symndx
;
2177 struct elf_link_hash_entry
*h
;
2178 struct elf_x86_64_link_hash_entry
*eh
;
2179 Elf_Internal_Sym
*isym
;
2181 bfd_boolean size_reloc
;
2183 r_symndx
= htab
->r_sym (rel
->r_info
);
2184 r_type
= ELF32_R_TYPE (rel
->r_info
);
2186 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
2188 /* xgettext:c-format */
2189 _bfd_error_handler (_("%B: bad symbol index: %d"),
2194 if (r_symndx
< symtab_hdr
->sh_info
)
2196 /* A local symbol. */
2197 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2202 /* Check relocation against local STT_GNU_IFUNC symbol. */
2203 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
2205 h
= elf_x86_64_get_local_sym_hash (htab
, abfd
, rel
,
2210 /* Fake a STT_GNU_IFUNC symbol. */
2211 h
->type
= STT_GNU_IFUNC
;
2214 h
->forced_local
= 1;
2215 h
->root
.type
= bfd_link_hash_defined
;
2223 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2224 while (h
->root
.type
== bfd_link_hash_indirect
2225 || h
->root
.type
== bfd_link_hash_warning
)
2226 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2229 /* Check invalid x32 relocations. */
2230 if (!ABI_64_P (abfd
))
2236 case R_X86_64_DTPOFF64
:
2237 case R_X86_64_TPOFF64
:
2239 case R_X86_64_GOTOFF64
:
2240 case R_X86_64_GOT64
:
2241 case R_X86_64_GOTPCREL64
:
2242 case R_X86_64_GOTPC64
:
2243 case R_X86_64_GOTPLT64
:
2244 case R_X86_64_PLTOFF64
:
2247 name
= h
->root
.root
.string
;
2249 name
= bfd_elf_sym_name (abfd
, symtab_hdr
, isym
,
2252 /* xgettext:c-format */
2253 (_("%B: relocation %s against symbol `%s' isn't "
2254 "supported in x32 mode"), abfd
,
2255 x86_64_elf_howto_table
[r_type
].name
, name
);
2256 bfd_set_error (bfd_error_bad_value
);
2269 case R_X86_64_PC32_BND
:
2270 case R_X86_64_PLT32_BND
:
2272 case R_X86_64_PLT32
:
2275 /* MPX PLT is supported only if elf_x86_64_arch_bed
2276 is used in 64-bit mode. */
2279 && (get_elf_x86_64_backend_data (abfd
)
2280 == &elf_x86_64_arch_bed
))
2282 elf_x86_64_hash_entry (h
)->has_bnd_reloc
= 1;
2284 /* Create the second PLT for Intel MPX support. */
2285 if (htab
->plt_bnd
== NULL
)
2287 unsigned int plt_bnd_align
;
2288 const struct elf_backend_data
*bed
;
2290 bed
= get_elf_backend_data (info
->output_bfd
);
2291 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt2_entry
) == 8
2292 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2293 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2296 if (htab
->elf
.dynobj
== NULL
)
2297 htab
->elf
.dynobj
= abfd
;
2299 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2301 (bed
->dynamic_sec_flags
2306 if (htab
->plt_bnd
== NULL
2307 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2317 case R_X86_64_GOTPCREL
:
2318 case R_X86_64_GOTPCRELX
:
2319 case R_X86_64_REX_GOTPCRELX
:
2320 case R_X86_64_GOTPCREL64
:
2321 if (htab
->elf
.dynobj
== NULL
)
2322 htab
->elf
.dynobj
= abfd
;
2323 /* Create the ifunc sections for static executables. */
2324 if (h
->type
== STT_GNU_IFUNC
2325 && !_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
,
2331 /* It is referenced by a non-shared object. */
2333 h
->root
.non_ir_ref
= 1;
2335 if (h
->type
== STT_GNU_IFUNC
)
2336 elf_tdata (info
->output_bfd
)->has_gnu_symbols
2337 |= elf_gnu_symbol_ifunc
;
2340 if (! elf_x86_64_tls_transition (info
, abfd
, sec
, contents
,
2341 symtab_hdr
, sym_hashes
,
2342 &r_type
, GOT_UNKNOWN
,
2343 rel
, rel_end
, h
, r_symndx
, FALSE
))
2346 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2349 case R_X86_64_TLSLD
:
2350 htab
->tls_ld_got
.refcount
+= 1;
2353 case R_X86_64_TPOFF32
:
2354 if (!bfd_link_executable (info
) && ABI_64_P (abfd
))
2355 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
2356 &x86_64_elf_howto_table
[r_type
]);
2358 eh
->has_got_reloc
= 1;
2361 case R_X86_64_GOTTPOFF
:
2362 if (!bfd_link_executable (info
))
2363 info
->flags
|= DF_STATIC_TLS
;
2366 case R_X86_64_GOT32
:
2367 case R_X86_64_GOTPCREL
:
2368 case R_X86_64_GOTPCRELX
:
2369 case R_X86_64_REX_GOTPCRELX
:
2370 case R_X86_64_TLSGD
:
2371 case R_X86_64_GOT64
:
2372 case R_X86_64_GOTPCREL64
:
2373 case R_X86_64_GOTPLT64
:
2374 case R_X86_64_GOTPC32_TLSDESC
:
2375 case R_X86_64_TLSDESC_CALL
:
2376 /* This symbol requires a global offset table entry. */
2378 int tls_type
, old_tls_type
;
2382 default: tls_type
= GOT_NORMAL
; break;
2383 case R_X86_64_TLSGD
: tls_type
= GOT_TLS_GD
; break;
2384 case R_X86_64_GOTTPOFF
: tls_type
= GOT_TLS_IE
; break;
2385 case R_X86_64_GOTPC32_TLSDESC
:
2386 case R_X86_64_TLSDESC_CALL
:
2387 tls_type
= GOT_TLS_GDESC
; break;
2392 h
->got
.refcount
+= 1;
2393 old_tls_type
= eh
->tls_type
;
2397 bfd_signed_vma
*local_got_refcounts
;
2399 /* This is a global offset table entry for a local symbol. */
2400 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2401 if (local_got_refcounts
== NULL
)
2405 size
= symtab_hdr
->sh_info
;
2406 size
*= sizeof (bfd_signed_vma
)
2407 + sizeof (bfd_vma
) + sizeof (char);
2408 local_got_refcounts
= ((bfd_signed_vma
*)
2409 bfd_zalloc (abfd
, size
));
2410 if (local_got_refcounts
== NULL
)
2412 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2413 elf_x86_64_local_tlsdesc_gotent (abfd
)
2414 = (bfd_vma
*) (local_got_refcounts
+ symtab_hdr
->sh_info
);
2415 elf_x86_64_local_got_tls_type (abfd
)
2416 = (char *) (local_got_refcounts
+ 2 * symtab_hdr
->sh_info
);
2418 local_got_refcounts
[r_symndx
] += 1;
2420 = elf_x86_64_local_got_tls_type (abfd
) [r_symndx
];
2423 /* If a TLS symbol is accessed using IE at least once,
2424 there is no point to use dynamic model for it. */
2425 if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
2426 && (! GOT_TLS_GD_ANY_P (old_tls_type
)
2427 || tls_type
!= GOT_TLS_IE
))
2429 if (old_tls_type
== GOT_TLS_IE
&& GOT_TLS_GD_ANY_P (tls_type
))
2430 tls_type
= old_tls_type
;
2431 else if (GOT_TLS_GD_ANY_P (old_tls_type
)
2432 && GOT_TLS_GD_ANY_P (tls_type
))
2433 tls_type
|= old_tls_type
;
2437 name
= h
->root
.root
.string
;
2439 name
= bfd_elf_sym_name (abfd
, symtab_hdr
,
2442 /* xgettext:c-format */
2443 (_("%B: '%s' accessed both as normal and thread local symbol"),
2445 bfd_set_error (bfd_error_bad_value
);
2450 if (old_tls_type
!= tls_type
)
2453 eh
->tls_type
= tls_type
;
2455 elf_x86_64_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
2460 case R_X86_64_GOTOFF64
:
2461 case R_X86_64_GOTPC32
:
2462 case R_X86_64_GOTPC64
:
2465 eh
->has_got_reloc
= 1;
2466 if (htab
->elf
.sgot
== NULL
)
2468 if (htab
->elf
.dynobj
== NULL
)
2469 htab
->elf
.dynobj
= abfd
;
2470 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
,
2476 case R_X86_64_PLT32
:
2477 case R_X86_64_PLT32_BND
:
2478 /* This symbol requires a procedure linkage table entry. We
2479 actually build the entry in adjust_dynamic_symbol,
2480 because this might be a case of linking PIC code which is
2481 never referenced by a dynamic object, in which case we
2482 don't need to generate a procedure linkage table entry
2485 /* If this is a local symbol, we resolve it directly without
2486 creating a procedure linkage table entry. */
2490 eh
->has_got_reloc
= 1;
2492 h
->plt
.refcount
+= 1;
2495 case R_X86_64_PLTOFF64
:
2496 /* This tries to form the 'address' of a function relative
2497 to GOT. For global symbols we need a PLT entry. */
2501 h
->plt
.refcount
+= 1;
2505 case R_X86_64_SIZE32
:
2506 case R_X86_64_SIZE64
:
2511 if (!ABI_64_P (abfd
))
2517 /* Check relocation overflow as these relocs may lead to
2518 run-time relocation overflow. Don't error out for
2519 sections we don't care about, such as debug sections or
2520 when relocation overflow check is disabled. */
2521 if (!info
->no_reloc_overflow_check
2522 && (bfd_link_pic (info
)
2523 || (bfd_link_executable (info
)
2527 && (sec
->flags
& SEC_READONLY
) == 0)))
2528 return elf_x86_64_need_pic (abfd
, sec
, h
, symtab_hdr
, isym
,
2529 &x86_64_elf_howto_table
[r_type
]);
2535 case R_X86_64_PC32_BND
:
2539 if (eh
!= NULL
&& (sec
->flags
& SEC_CODE
) != 0)
2540 eh
->has_non_got_reloc
= 1;
2541 /* We are called after all symbols have been resolved. Only
2542 relocation against STT_GNU_IFUNC symbol must go through
2545 && (bfd_link_executable (info
)
2546 || h
->type
== STT_GNU_IFUNC
))
2548 /* If this reloc is in a read-only section, we might
2549 need a copy reloc. We can't check reliably at this
2550 stage whether the section is read-only, as input
2551 sections have not yet been mapped to output sections.
2552 Tentatively set the flag for now, and correct in
2553 adjust_dynamic_symbol. */
2556 /* We may need a .plt entry if the symbol is a function
2557 defined in a shared lib or is a STT_GNU_IFUNC function
2558 referenced from the code or read-only section. */
2560 || (sec
->flags
& (SEC_CODE
| SEC_READONLY
)) != 0)
2561 h
->plt
.refcount
+= 1;
2563 if (r_type
== R_X86_64_PC32
)
2565 /* Since something like ".long foo - ." may be used
2566 as pointer, make sure that PLT is used if foo is
2567 a function defined in a shared library. */
2568 if ((sec
->flags
& SEC_CODE
) == 0)
2569 h
->pointer_equality_needed
= 1;
2571 else if (r_type
!= R_X86_64_PC32_BND
2572 && r_type
!= R_X86_64_PC64
)
2574 h
->pointer_equality_needed
= 1;
2575 /* At run-time, R_X86_64_64 can be resolved for both
2576 x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2577 can only be resolved for x32. */
2578 if ((sec
->flags
& SEC_READONLY
) == 0
2579 && (r_type
== R_X86_64_64
2580 || (!ABI_64_P (abfd
)
2581 && (r_type
== R_X86_64_32
2582 || r_type
== R_X86_64_32S
))))
2583 eh
->func_pointer_refcount
+= 1;
2589 /* If we are creating a shared library, and this is a reloc
2590 against a global symbol, or a non PC relative reloc
2591 against a local symbol, then we need to copy the reloc
2592 into the shared library. However, if we are linking with
2593 -Bsymbolic, we do not need to copy a reloc against a
2594 global symbol which is defined in an object we are
2595 including in the link (i.e., DEF_REGULAR is set). At
2596 this point we have not seen all the input files, so it is
2597 possible that DEF_REGULAR is not set now but will be set
2598 later (it is never cleared). In case of a weak definition,
2599 DEF_REGULAR may be cleared later by a strong definition in
2600 a shared library. We account for that possibility below by
2601 storing information in the relocs_copied field of the hash
2602 table entry. A similar situation occurs when creating
2603 shared libraries and symbol visibility changes render the
2606 If on the other hand, we are creating an executable, we
2607 may need to keep relocations for symbols satisfied by a
2608 dynamic library if we manage to avoid copy relocs for the
2611 Generate dynamic pointer relocation against STT_GNU_IFUNC
2612 symbol in the non-code section. */
2613 if ((bfd_link_pic (info
)
2614 && (! IS_X86_64_PCREL_TYPE (r_type
)
2616 && (! (bfd_link_pie (info
)
2617 || SYMBOLIC_BIND (info
, h
))
2618 || h
->root
.type
== bfd_link_hash_defweak
2619 || !h
->def_regular
))))
2621 && h
->type
== STT_GNU_IFUNC
2622 && r_type
== htab
->pointer_r_type
2623 && (sec
->flags
& SEC_CODE
) == 0)
2624 || (ELIMINATE_COPY_RELOCS
2625 && !bfd_link_pic (info
)
2627 && (h
->root
.type
== bfd_link_hash_defweak
2628 || !h
->def_regular
)))
2630 struct elf_dyn_relocs
*p
;
2631 struct elf_dyn_relocs
**head
;
2633 /* We must copy these reloc types into the output file.
2634 Create a reloc section in dynobj and make room for
2638 if (htab
->elf
.dynobj
== NULL
)
2639 htab
->elf
.dynobj
= abfd
;
2641 sreloc
= _bfd_elf_make_dynamic_reloc_section
2642 (sec
, htab
->elf
.dynobj
, ABI_64_P (abfd
) ? 3 : 2,
2643 abfd
, /*rela?*/ TRUE
);
2649 /* If this is a global symbol, we count the number of
2650 relocations we need for this symbol. */
2652 head
= &eh
->dyn_relocs
;
2655 /* Track dynamic relocs needed for local syms too.
2656 We really need local syms available to do this
2661 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2666 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2670 /* Beware of type punned pointers vs strict aliasing
2672 vpp
= &(elf_section_data (s
)->local_dynrel
);
2673 head
= (struct elf_dyn_relocs
**)vpp
;
2677 if (p
== NULL
|| p
->sec
!= sec
)
2679 bfd_size_type amt
= sizeof *p
;
2681 p
= ((struct elf_dyn_relocs
*)
2682 bfd_alloc (htab
->elf
.dynobj
, amt
));
2693 /* Count size relocation as PC-relative relocation. */
2694 if (IS_X86_64_PCREL_TYPE (r_type
) || size_reloc
)
2699 /* This relocation describes the C++ object vtable hierarchy.
2700 Reconstruct it for later use during GC. */
2701 case R_X86_64_GNU_VTINHERIT
:
2702 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2706 /* This relocation describes which C++ vtable entries are actually
2707 used. Record for later use during GC. */
2708 case R_X86_64_GNU_VTENTRY
:
2709 BFD_ASSERT (h
!= NULL
);
2711 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2721 && h
->plt
.refcount
> 0
2722 && (((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
2723 || h
->got
.refcount
> 0)
2724 && htab
->plt_got
== NULL
)
2726 /* Create the GOT procedure linkage table. */
2727 unsigned int plt_got_align
;
2728 const struct elf_backend_data
*bed
;
2730 bed
= get_elf_backend_data (info
->output_bfd
);
2731 BFD_ASSERT (sizeof (elf_x86_64_legacy_plt2_entry
) == 8
2732 && (sizeof (elf_x86_64_bnd_plt2_entry
)
2733 == sizeof (elf_x86_64_legacy_plt2_entry
)));
2736 if (htab
->elf
.dynobj
== NULL
)
2737 htab
->elf
.dynobj
= abfd
;
2739 = bfd_make_section_anyway_with_flags (htab
->elf
.dynobj
,
2741 (bed
->dynamic_sec_flags
2746 if (htab
->plt_got
== NULL
2747 || !bfd_set_section_alignment (htab
->elf
.dynobj
,
2753 if ((r_type
== R_X86_64_GOTPCREL
2754 || r_type
== R_X86_64_GOTPCRELX
2755 || r_type
== R_X86_64_REX_GOTPCRELX
)
2756 && (h
== NULL
|| h
->type
!= STT_GNU_IFUNC
))
2757 sec
->need_convert_load
= 1;
2760 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2762 if (!info
->keep_memory
)
2766 /* Cache the section contents for elf_link_input_bfd. */
2767 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2774 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2776 sec
->check_relocs_failed
= 1;
2780 /* Return the section that should be marked against GC for a given
2784 elf_x86_64_gc_mark_hook (asection
*sec
,
2785 struct bfd_link_info
*info
,
2786 Elf_Internal_Rela
*rel
,
2787 struct elf_link_hash_entry
*h
,
2788 Elf_Internal_Sym
*sym
)
2791 switch (ELF32_R_TYPE (rel
->r_info
))
2793 case R_X86_64_GNU_VTINHERIT
:
2794 case R_X86_64_GNU_VTENTRY
:
2798 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2801 /* Remove undefined weak symbol from the dynamic symbol table if it
2802 is resolved to 0. */
2805 elf_x86_64_fixup_symbol (struct bfd_link_info
*info
,
2806 struct elf_link_hash_entry
*h
)
2808 if (h
->dynindx
!= -1
2809 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
2810 elf_x86_64_hash_entry (h
)->has_got_reloc
,
2811 elf_x86_64_hash_entry (h
)))
2814 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
2820 /* Adjust a symbol defined by a dynamic object and referenced by a
2821 regular object. The current definition is in some section of the
2822 dynamic object, but we're not including those sections. We have to
2823 change the definition to something the rest of the link can
2827 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2828 struct elf_link_hash_entry
*h
)
2830 struct elf_x86_64_link_hash_table
*htab
;
2832 struct elf_x86_64_link_hash_entry
*eh
;
2833 struct elf_dyn_relocs
*p
;
2835 /* STT_GNU_IFUNC symbol must go through PLT. */
2836 if (h
->type
== STT_GNU_IFUNC
)
2838 /* All local STT_GNU_IFUNC references must be treate as local
2839 calls via local PLT. */
2841 && SYMBOL_CALLS_LOCAL (info
, h
))
2843 bfd_size_type pc_count
= 0, count
= 0;
2844 struct elf_dyn_relocs
**pp
;
2846 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2847 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2849 pc_count
+= p
->pc_count
;
2850 p
->count
-= p
->pc_count
;
2859 if (pc_count
|| count
)
2864 /* Increment PLT reference count only for PC-relative
2867 if (h
->plt
.refcount
<= 0)
2868 h
->plt
.refcount
= 1;
2870 h
->plt
.refcount
+= 1;
2875 if (h
->plt
.refcount
<= 0)
2877 h
->plt
.offset
= (bfd_vma
) -1;
2883 /* If this is a function, put it in the procedure linkage table. We
2884 will fill in the contents of the procedure linkage table later,
2885 when we know the address of the .got section. */
2886 if (h
->type
== STT_FUNC
2889 if (h
->plt
.refcount
<= 0
2890 || SYMBOL_CALLS_LOCAL (info
, h
)
2891 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
2892 && h
->root
.type
== bfd_link_hash_undefweak
))
2894 /* This case can occur if we saw a PLT32 reloc in an input
2895 file, but the symbol was never referred to by a dynamic
2896 object, or if all references were garbage collected. In
2897 such a case, we don't actually need to build a procedure
2898 linkage table, and we can just do a PC32 reloc instead. */
2899 h
->plt
.offset
= (bfd_vma
) -1;
2906 /* It's possible that we incorrectly decided a .plt reloc was
2907 needed for an R_X86_64_PC32 reloc to a non-function sym in
2908 check_relocs. We can't decide accurately between function and
2909 non-function syms in check-relocs; Objects loaded later in
2910 the link may change h->type. So fix it now. */
2911 h
->plt
.offset
= (bfd_vma
) -1;
2913 /* If this is a weak symbol, and there is a real definition, the
2914 processor independent code will have arranged for us to see the
2915 real definition first, and we can just use the same value. */
2916 if (h
->u
.weakdef
!= NULL
)
2918 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2919 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2920 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2921 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2922 if (ELIMINATE_COPY_RELOCS
|| info
->nocopyreloc
)
2924 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2925 h
->non_got_ref
= h
->u
.weakdef
->non_got_ref
;
2926 eh
->needs_copy
= h
->u
.weakdef
->needs_copy
;
2931 /* This is a reference to a symbol defined by a dynamic object which
2932 is not a function. */
2934 /* If we are creating a shared library, we must presume that the
2935 only references to the symbol are via the global offset table.
2936 For such cases we need not do anything here; the relocations will
2937 be handled correctly by relocate_section. */
2938 if (!bfd_link_executable (info
))
2941 /* If there are no references to this symbol that do not use the
2942 GOT, we don't need to generate a copy reloc. */
2943 if (!h
->non_got_ref
)
2946 /* If -z nocopyreloc was given, we won't generate them either. */
2947 if (info
->nocopyreloc
)
2953 if (ELIMINATE_COPY_RELOCS
)
2955 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
2956 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2958 s
= p
->sec
->output_section
;
2959 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2963 /* If we didn't find any dynamic relocs in read-only sections, then
2964 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2972 /* We must allocate the symbol in our .dynbss section, which will
2973 become part of the .bss section of the executable. There will be
2974 an entry for this symbol in the .dynsym section. The dynamic
2975 object will contain position independent code, so all references
2976 from the dynamic object to this symbol will go through the global
2977 offset table. The dynamic linker will use the .dynsym entry to
2978 determine the address it must put in the global offset table, so
2979 both the dynamic object and the regular object will refer to the
2980 same memory location for the variable. */
2982 htab
= elf_x86_64_hash_table (info
);
2986 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2987 to copy the initial value out of the dynamic object and into the
2988 runtime process image. */
2989 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
2991 s
= htab
->elf
.sdynrelro
;
2992 srel
= htab
->elf
.sreldynrelro
;
2996 s
= htab
->elf
.sdynbss
;
2997 srel
= htab
->elf
.srelbss
;
2999 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
3001 const struct elf_backend_data
*bed
;
3002 bed
= get_elf_backend_data (info
->output_bfd
);
3003 srel
->size
+= bed
->s
->sizeof_rela
;
3007 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
3010 /* Allocate space in .plt, .got and associated reloc sections for
3014 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void * inf
)
3016 struct bfd_link_info
*info
;
3017 struct elf_x86_64_link_hash_table
*htab
;
3018 struct elf_x86_64_link_hash_entry
*eh
;
3019 struct elf_dyn_relocs
*p
;
3020 const struct elf_backend_data
*bed
;
3021 unsigned int plt_entry_size
;
3022 bfd_boolean resolved_to_zero
;
3024 if (h
->root
.type
== bfd_link_hash_indirect
)
3027 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3029 info
= (struct bfd_link_info
*) inf
;
3030 htab
= elf_x86_64_hash_table (info
);
3033 bed
= get_elf_backend_data (info
->output_bfd
);
3034 plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
3036 resolved_to_zero
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
3040 /* We can't use the GOT PLT if pointer equality is needed since
3041 finish_dynamic_symbol won't clear symbol value and the dynamic
3042 linker won't update the GOT slot. We will get into an infinite
3043 loop at run-time. */
3044 if (htab
->plt_got
!= NULL
3045 && h
->type
!= STT_GNU_IFUNC
3046 && !h
->pointer_equality_needed
3047 && h
->plt
.refcount
> 0
3048 && h
->got
.refcount
> 0)
3050 /* Don't use the regular PLT if there are both GOT and GOTPLT
3052 h
->plt
.offset
= (bfd_vma
) -1;
3054 /* Use the GOT PLT. */
3055 eh
->plt_got
.refcount
= 1;
3058 /* Clear the reference count of function pointer relocations if
3059 symbol isn't a normal function. */
3060 if (h
->type
!= STT_FUNC
)
3061 eh
->func_pointer_refcount
= 0;
3063 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
3064 here if it is defined and referenced in a non-shared object. */
3065 if (h
->type
== STT_GNU_IFUNC
3068 if (_bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
3070 &htab
->readonly_dynrelocs_against_ifunc
,
3073 GOT_ENTRY_SIZE
, TRUE
))
3075 asection
*s
= htab
->plt_bnd
;
3076 if (h
->plt
.offset
!= (bfd_vma
) -1 && s
!= NULL
)
3078 /* Use the .plt.bnd section if it is created. */
3079 eh
->plt_bnd
.offset
= s
->size
;
3081 /* Make room for this entry in the .plt.bnd section. */
3082 s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
3090 /* Don't create the PLT entry if there are only function pointer
3091 relocations which can be resolved at run-time. */
3092 else if (htab
->elf
.dynamic_sections_created
3093 && (h
->plt
.refcount
> eh
->func_pointer_refcount
3094 || eh
->plt_got
.refcount
> 0))
3096 bfd_boolean use_plt_got
;
3098 /* Clear the reference count of function pointer relocations
3100 eh
->func_pointer_refcount
= 0;
3102 if ((info
->flags
& DF_BIND_NOW
) && !h
->pointer_equality_needed
)
3104 /* Don't use the regular PLT for DF_BIND_NOW. */
3105 h
->plt
.offset
= (bfd_vma
) -1;
3107 /* Use the GOT PLT. */
3108 h
->got
.refcount
= 1;
3109 eh
->plt_got
.refcount
= 1;
3112 use_plt_got
= eh
->plt_got
.refcount
> 0;
3114 /* Make sure this symbol is output as a dynamic symbol.
3115 Undefined weak syms won't yet be marked as dynamic. */
3116 if (h
->dynindx
== -1
3118 && !resolved_to_zero
)
3120 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3124 if (bfd_link_pic (info
)
3125 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
3127 asection
*s
= htab
->elf
.splt
;
3128 asection
*bnd_s
= htab
->plt_bnd
;
3129 asection
*got_s
= htab
->plt_got
;
3131 /* If this is the first .plt entry, make room for the special
3132 first entry. The .plt section is used by prelink to undo
3133 prelinking for dynamic relocations. */
3135 s
->size
= plt_entry_size
;
3138 eh
->plt_got
.offset
= got_s
->size
;
3141 h
->plt
.offset
= s
->size
;
3143 eh
->plt_bnd
.offset
= bnd_s
->size
;
3146 /* If this symbol is not defined in a regular file, and we are
3147 not generating a shared library, then set the symbol to this
3148 location in the .plt. This is required to make function
3149 pointers compare as equal between the normal executable and
3150 the shared library. */
3151 if (! bfd_link_pic (info
)
3156 /* We need to make a call to the entry of the GOT PLT
3157 instead of regular PLT entry. */
3158 h
->root
.u
.def
.section
= got_s
;
3159 h
->root
.u
.def
.value
= eh
->plt_got
.offset
;
3165 /* We need to make a call to the entry of the second
3166 PLT instead of regular PLT entry. */
3167 h
->root
.u
.def
.section
= bnd_s
;
3168 h
->root
.u
.def
.value
= eh
->plt_bnd
.offset
;
3172 h
->root
.u
.def
.section
= s
;
3173 h
->root
.u
.def
.value
= h
->plt
.offset
;
3178 /* Make room for this entry. */
3180 got_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
3183 s
->size
+= plt_entry_size
;
3185 bnd_s
->size
+= sizeof (elf_x86_64_legacy_plt2_entry
);
3187 /* We also need to make an entry in the .got.plt section,
3188 which will be placed in the .got section by the linker
3190 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
3192 /* There should be no PLT relocation against resolved
3193 undefined weak symbol in executable. */
3194 if (!resolved_to_zero
)
3196 /* We also need to make an entry in the .rela.plt
3198 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
3199 htab
->elf
.srelplt
->reloc_count
++;
3205 eh
->plt_got
.offset
= (bfd_vma
) -1;
3206 h
->plt
.offset
= (bfd_vma
) -1;
3212 eh
->plt_got
.offset
= (bfd_vma
) -1;
3213 h
->plt
.offset
= (bfd_vma
) -1;
3217 eh
->tlsdesc_got
= (bfd_vma
) -1;
3219 /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
3220 make it a R_X86_64_TPOFF32 requiring no GOT entry. */
3221 if (h
->got
.refcount
> 0
3222 && bfd_link_executable (info
)
3224 && elf_x86_64_hash_entry (h
)->tls_type
== GOT_TLS_IE
)
3226 h
->got
.offset
= (bfd_vma
) -1;
3228 else if (h
->got
.refcount
> 0)
3232 int tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
3234 /* Make sure this symbol is output as a dynamic symbol.
3235 Undefined weak syms won't yet be marked as dynamic. */
3236 if (h
->dynindx
== -1
3238 && !resolved_to_zero
)
3240 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3244 if (GOT_TLS_GDESC_P (tls_type
))
3246 eh
->tlsdesc_got
= htab
->elf
.sgotplt
->size
3247 - elf_x86_64_compute_jump_table_size (htab
);
3248 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3249 h
->got
.offset
= (bfd_vma
) -2;
3251 if (! GOT_TLS_GDESC_P (tls_type
)
3252 || GOT_TLS_GD_P (tls_type
))
3255 h
->got
.offset
= s
->size
;
3256 s
->size
+= GOT_ENTRY_SIZE
;
3257 if (GOT_TLS_GD_P (tls_type
))
3258 s
->size
+= GOT_ENTRY_SIZE
;
3260 dyn
= htab
->elf
.dynamic_sections_created
;
3261 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
3262 and two if global. R_X86_64_GOTTPOFF needs one dynamic
3263 relocation. No dynamic relocation against resolved undefined
3264 weak symbol in executable. */
3265 if ((GOT_TLS_GD_P (tls_type
) && h
->dynindx
== -1)
3266 || tls_type
== GOT_TLS_IE
)
3267 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3268 else if (GOT_TLS_GD_P (tls_type
))
3269 htab
->elf
.srelgot
->size
+= 2 * bed
->s
->sizeof_rela
;
3270 else if (! GOT_TLS_GDESC_P (tls_type
)
3271 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3272 && !resolved_to_zero
)
3273 || h
->root
.type
!= bfd_link_hash_undefweak
)
3274 && (bfd_link_pic (info
)
3275 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)))
3276 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3277 if (GOT_TLS_GDESC_P (tls_type
))
3279 htab
->elf
.srelplt
->size
+= bed
->s
->sizeof_rela
;
3280 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3284 h
->got
.offset
= (bfd_vma
) -1;
3286 if (eh
->dyn_relocs
== NULL
)
3289 /* In the shared -Bsymbolic case, discard space allocated for
3290 dynamic pc-relative relocs against symbols which turn out to be
3291 defined in regular objects. For the normal shared case, discard
3292 space for pc-relative relocs that have become local due to symbol
3293 visibility changes. */
3295 if (bfd_link_pic (info
))
3297 /* Relocs that use pc_count are those that appear on a call
3298 insn, or certain REL relocs that can generated via assembly.
3299 We want calls to protected symbols to resolve directly to the
3300 function rather than going via the plt. If people want
3301 function pointer comparisons to work as expected then they
3302 should avoid writing weird assembly. */
3303 if (SYMBOL_CALLS_LOCAL (info
, h
))
3305 struct elf_dyn_relocs
**pp
;
3307 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3309 p
->count
-= p
->pc_count
;
3318 /* Also discard relocs on undefined weak syms with non-default
3319 visibility or in PIE. */
3320 if (eh
->dyn_relocs
!= NULL
)
3322 if (h
->root
.type
== bfd_link_hash_undefweak
)
3324 /* Undefined weak symbol is never bound locally in shared
3326 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
3327 || resolved_to_zero
)
3328 eh
->dyn_relocs
= NULL
;
3329 else if (h
->dynindx
== -1
3330 && ! h
->forced_local
3331 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3334 /* For PIE, discard space for pc-relative relocs against
3335 symbols which turn out to need copy relocs. */
3336 else if (bfd_link_executable (info
)
3337 && (h
->needs_copy
|| eh
->needs_copy
)
3341 struct elf_dyn_relocs
**pp
;
3343 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
3345 if (p
->pc_count
!= 0)
3353 else if (ELIMINATE_COPY_RELOCS
)
3355 /* For the non-shared case, discard space for relocs against
3356 symbols which turn out to need copy relocs or are not
3357 dynamic. Keep dynamic relocations for run-time function
3358 pointer initialization. */
3360 if ((!h
->non_got_ref
3361 || eh
->func_pointer_refcount
> 0
3362 || (h
->root
.type
== bfd_link_hash_undefweak
3363 && !resolved_to_zero
))
3366 || (htab
->elf
.dynamic_sections_created
3367 && (h
->root
.type
== bfd_link_hash_undefweak
3368 || h
->root
.type
== bfd_link_hash_undefined
))))
3370 /* Make sure this symbol is output as a dynamic symbol.
3371 Undefined weak syms won't yet be marked as dynamic. */
3372 if (h
->dynindx
== -1
3373 && ! h
->forced_local
3374 && ! resolved_to_zero
3375 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3378 /* If that succeeded, we know we'll be keeping all the
3380 if (h
->dynindx
!= -1)
3384 eh
->dyn_relocs
= NULL
;
3385 eh
->func_pointer_refcount
= 0;
3390 /* Finally, allocate space. */
3391 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3395 sreloc
= elf_section_data (p
->sec
)->sreloc
;
3397 BFD_ASSERT (sreloc
!= NULL
);
3399 sreloc
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3405 /* Allocate space in .plt, .got and associated reloc sections for
3406 local dynamic relocs. */
3409 elf_x86_64_allocate_local_dynrelocs (void **slot
, void *inf
)
3411 struct elf_link_hash_entry
*h
3412 = (struct elf_link_hash_entry
*) *slot
;
3414 if (h
->type
!= STT_GNU_IFUNC
3418 || h
->root
.type
!= bfd_link_hash_defined
)
3421 return elf_x86_64_allocate_dynrelocs (h
, inf
);
3424 /* Find any dynamic relocs that apply to read-only sections. */
3427 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry
*h
,
3430 struct elf_x86_64_link_hash_entry
*eh
;
3431 struct elf_dyn_relocs
*p
;
3433 /* Skip local IFUNC symbols. */
3434 if (h
->forced_local
&& h
->type
== STT_GNU_IFUNC
)
3437 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
3438 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
3440 asection
*s
= p
->sec
->output_section
;
3442 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
3444 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3446 info
->flags
|= DF_TEXTREL
;
3448 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3449 || info
->error_textrel
)
3450 /* xgettext:c-format */
3451 info
->callbacks
->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
3452 p
->sec
->owner
, h
->root
.root
.string
,
3455 /* Not an error, just cut short the traversal. */
3462 /* Convert load via the GOT slot to load immediate. */
3465 elf_x86_64_convert_load (bfd
*abfd
, asection
*sec
,
3466 struct bfd_link_info
*link_info
)
3468 Elf_Internal_Shdr
*symtab_hdr
;
3469 Elf_Internal_Rela
*internal_relocs
;
3470 Elf_Internal_Rela
*irel
, *irelend
;
3472 struct elf_x86_64_link_hash_table
*htab
;
3473 bfd_boolean changed
;
3474 bfd_signed_vma
*local_got_refcounts
;
3476 /* Don't even try to convert non-ELF outputs. */
3477 if (!is_elf_hash_table (link_info
->hash
))
3480 /* Nothing to do if there is no need or no output. */
3481 if ((sec
->flags
& (SEC_CODE
| SEC_RELOC
)) != (SEC_CODE
| SEC_RELOC
)
3482 || sec
->need_convert_load
== 0
3483 || bfd_is_abs_section (sec
->output_section
))
3486 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3488 /* Load the relocations for this section. */
3489 internal_relocs
= (_bfd_elf_link_read_relocs
3490 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
3491 link_info
->keep_memory
));
3492 if (internal_relocs
== NULL
)
3496 htab
= elf_x86_64_hash_table (link_info
);
3497 local_got_refcounts
= elf_local_got_refcounts (abfd
);
3499 /* Get the section contents. */
3500 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
3501 contents
= elf_section_data (sec
)->this_hdr
.contents
;
3504 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
3508 irelend
= internal_relocs
+ sec
->reloc_count
;
3509 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3511 unsigned int r_type
= ELF32_R_TYPE (irel
->r_info
);
3512 unsigned int r_symndx
;
3513 struct elf_link_hash_entry
*h
;
3514 bfd_boolean converted
;
3516 if (r_type
!= R_X86_64_GOTPCRELX
3517 && r_type
!= R_X86_64_REX_GOTPCRELX
3518 && r_type
!= R_X86_64_GOTPCREL
)
3521 r_symndx
= htab
->r_sym (irel
->r_info
);
3522 if (r_symndx
< symtab_hdr
->sh_info
)
3523 h
= elf_x86_64_get_local_sym_hash (htab
, sec
->owner
,
3524 (const Elf_Internal_Rela
*) irel
,
3528 h
= elf_sym_hashes (abfd
)[r_symndx
- symtab_hdr
->sh_info
];
3529 while (h
->root
.type
== bfd_link_hash_indirect
3530 || h
->root
.type
== bfd_link_hash_warning
)
3531 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3534 /* STT_GNU_IFUNC must keep GOTPCREL relocations. */
3535 if (h
!= NULL
&& h
->type
== STT_GNU_IFUNC
)
3539 if (!elf_x86_64_convert_load_reloc (abfd
, sec
, contents
, irel
, h
,
3540 &converted
, link_info
))
3545 changed
= converted
;
3548 if (h
->got
.refcount
> 0)
3549 h
->got
.refcount
-= 1;
3553 if (local_got_refcounts
!= NULL
3554 && local_got_refcounts
[r_symndx
] > 0)
3555 local_got_refcounts
[r_symndx
] -= 1;
3560 if (contents
!= NULL
3561 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3563 if (!changed
&& !link_info
->keep_memory
)
3567 /* Cache the section contents for elf_link_input_bfd. */
3568 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3572 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3575 free (internal_relocs
);
3577 elf_section_data (sec
)->relocs
= internal_relocs
;
3583 if (contents
!= NULL
3584 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3586 if (internal_relocs
!= NULL
3587 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3588 free (internal_relocs
);
3592 /* Set the sizes of the dynamic sections. */
3595 elf_x86_64_size_dynamic_sections (bfd
*output_bfd
,
3596 struct bfd_link_info
*info
)
3598 struct elf_x86_64_link_hash_table
*htab
;
3603 const struct elf_backend_data
*bed
;
3605 htab
= elf_x86_64_hash_table (info
);
3608 bed
= get_elf_backend_data (output_bfd
);
3610 dynobj
= htab
->elf
.dynobj
;
3614 /* Set up .got offsets for local syms, and space for local dynamic
3616 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3618 bfd_signed_vma
*local_got
;
3619 bfd_signed_vma
*end_local_got
;
3620 char *local_tls_type
;
3621 bfd_vma
*local_tlsdesc_gotent
;
3622 bfd_size_type locsymcount
;
3623 Elf_Internal_Shdr
*symtab_hdr
;
3626 if (! is_x86_64_elf (ibfd
))
3629 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3631 struct elf_dyn_relocs
*p
;
3633 if (!elf_x86_64_convert_load (ibfd
, s
, info
))
3636 for (p
= (struct elf_dyn_relocs
*)
3637 (elf_section_data (s
)->local_dynrel
);
3641 if (!bfd_is_abs_section (p
->sec
)
3642 && bfd_is_abs_section (p
->sec
->output_section
))
3644 /* Input section has been discarded, either because
3645 it is a copy of a linkonce section or due to
3646 linker script /DISCARD/, so we'll be discarding
3649 else if (p
->count
!= 0)
3651 srel
= elf_section_data (p
->sec
)->sreloc
;
3652 srel
->size
+= p
->count
* bed
->s
->sizeof_rela
;
3653 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0
3654 && (info
->flags
& DF_TEXTREL
) == 0)
3656 info
->flags
|= DF_TEXTREL
;
3657 if ((info
->warn_shared_textrel
&& bfd_link_pic (info
))
3658 || info
->error_textrel
)
3659 /* xgettext:c-format */
3660 info
->callbacks
->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3661 p
->sec
->owner
, p
->sec
);
3667 local_got
= elf_local_got_refcounts (ibfd
);
3671 symtab_hdr
= &elf_symtab_hdr (ibfd
);
3672 locsymcount
= symtab_hdr
->sh_info
;
3673 end_local_got
= local_got
+ locsymcount
;
3674 local_tls_type
= elf_x86_64_local_got_tls_type (ibfd
);
3675 local_tlsdesc_gotent
= elf_x86_64_local_tlsdesc_gotent (ibfd
);
3677 srel
= htab
->elf
.srelgot
;
3678 for (; local_got
< end_local_got
;
3679 ++local_got
, ++local_tls_type
, ++local_tlsdesc_gotent
)
3681 *local_tlsdesc_gotent
= (bfd_vma
) -1;
3684 if (GOT_TLS_GDESC_P (*local_tls_type
))
3686 *local_tlsdesc_gotent
= htab
->elf
.sgotplt
->size
3687 - elf_x86_64_compute_jump_table_size (htab
);
3688 htab
->elf
.sgotplt
->size
+= 2 * GOT_ENTRY_SIZE
;
3689 *local_got
= (bfd_vma
) -2;
3691 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3692 || GOT_TLS_GD_P (*local_tls_type
))
3694 *local_got
= s
->size
;
3695 s
->size
+= GOT_ENTRY_SIZE
;
3696 if (GOT_TLS_GD_P (*local_tls_type
))
3697 s
->size
+= GOT_ENTRY_SIZE
;
3699 if (bfd_link_pic (info
)
3700 || GOT_TLS_GD_ANY_P (*local_tls_type
)
3701 || *local_tls_type
== GOT_TLS_IE
)
3703 if (GOT_TLS_GDESC_P (*local_tls_type
))
3705 htab
->elf
.srelplt
->size
3706 += bed
->s
->sizeof_rela
;
3707 htab
->tlsdesc_plt
= (bfd_vma
) -1;
3709 if (! GOT_TLS_GDESC_P (*local_tls_type
)
3710 || GOT_TLS_GD_P (*local_tls_type
))
3711 srel
->size
+= bed
->s
->sizeof_rela
;
3715 *local_got
= (bfd_vma
) -1;
3719 if (htab
->tls_ld_got
.refcount
> 0)
3721 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3723 htab
->tls_ld_got
.offset
= htab
->elf
.sgot
->size
;
3724 htab
->elf
.sgot
->size
+= 2 * GOT_ENTRY_SIZE
;
3725 htab
->elf
.srelgot
->size
+= bed
->s
->sizeof_rela
;
3728 htab
->tls_ld_got
.offset
= -1;
3730 /* Allocate global sym .plt and .got entries, and space for global
3731 sym dynamic relocs. */
3732 elf_link_hash_traverse (&htab
->elf
, elf_x86_64_allocate_dynrelocs
,
3735 /* Allocate .plt and .got entries, and space for local symbols. */
3736 htab_traverse (htab
->loc_hash_table
,
3737 elf_x86_64_allocate_local_dynrelocs
,
3740 /* For every jump slot reserved in the sgotplt, reloc_count is
3741 incremented. However, when we reserve space for TLS descriptors,
3742 it's not incremented, so in order to compute the space reserved
3743 for them, it suffices to multiply the reloc count by the jump
3746 PR ld/13302: We start next_irelative_index at the end of .rela.plt
3747 so that R_X86_64_IRELATIVE entries come last. */
3748 if (htab
->elf
.srelplt
)
3750 htab
->sgotplt_jump_table_size
3751 = elf_x86_64_compute_jump_table_size (htab
);
3752 htab
->next_irelative_index
= htab
->elf
.srelplt
->reloc_count
- 1;
3754 else if (htab
->elf
.irelplt
)
3755 htab
->next_irelative_index
= htab
->elf
.irelplt
->reloc_count
- 1;
3757 if (htab
->tlsdesc_plt
)
3759 /* If we're not using lazy TLS relocations, don't generate the
3760 PLT and GOT entries they require. */
3761 if ((info
->flags
& DF_BIND_NOW
))
3762 htab
->tlsdesc_plt
= 0;
3765 htab
->tlsdesc_got
= htab
->elf
.sgot
->size
;
3766 htab
->elf
.sgot
->size
+= GOT_ENTRY_SIZE
;
3767 /* Reserve room for the initial entry.
3768 FIXME: we could probably do away with it in this case. */
3769 if (htab
->elf
.splt
->size
== 0)
3770 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3771 htab
->tlsdesc_plt
= htab
->elf
.splt
->size
;
3772 htab
->elf
.splt
->size
+= GET_PLT_ENTRY_SIZE (output_bfd
);
3776 if (htab
->elf
.sgotplt
)
3778 /* Don't allocate .got.plt section if there are no GOT nor PLT
3779 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
3780 if ((htab
->elf
.hgot
== NULL
3781 || !htab
->elf
.hgot
->ref_regular_nonweak
)
3782 && (htab
->elf
.sgotplt
->size
3783 == get_elf_backend_data (output_bfd
)->got_header_size
)
3784 && (htab
->elf
.splt
== NULL
3785 || htab
->elf
.splt
->size
== 0)
3786 && (htab
->elf
.sgot
== NULL
3787 || htab
->elf
.sgot
->size
== 0)
3788 && (htab
->elf
.iplt
== NULL
3789 || htab
->elf
.iplt
->size
== 0)
3790 && (htab
->elf
.igotplt
== NULL
3791 || htab
->elf
.igotplt
->size
== 0))
3792 htab
->elf
.sgotplt
->size
= 0;
3795 if (htab
->plt_eh_frame
!= NULL
3796 && htab
->elf
.splt
!= NULL
3797 && htab
->elf
.splt
->size
!= 0
3798 && !bfd_is_abs_section (htab
->elf
.splt
->output_section
)
3799 && _bfd_elf_eh_frame_present (info
))
3801 const struct elf_x86_64_backend_data
*arch_data
3802 = get_elf_x86_64_arch_data (bed
);
3803 htab
->plt_eh_frame
->size
= arch_data
->eh_frame_plt_size
;
3806 /* We now have determined the sizes of the various dynamic sections.
3807 Allocate memory for them. */
3809 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3811 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3814 if (s
== htab
->elf
.splt
3815 || s
== htab
->elf
.sgot
3816 || s
== htab
->elf
.sgotplt
3817 || s
== htab
->elf
.iplt
3818 || s
== htab
->elf
.igotplt
3819 || s
== htab
->plt_bnd
3820 || s
== htab
->plt_got
3821 || s
== htab
->plt_eh_frame
3822 || s
== htab
->elf
.sdynbss
3823 || s
== htab
->elf
.sdynrelro
)
3825 /* Strip this section if we don't need it; see the
3828 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, s
), ".rela"))
3830 if (s
->size
!= 0 && s
!= htab
->elf
.srelplt
)
3833 /* We use the reloc_count field as a counter if we need
3834 to copy relocs into the output file. */
3835 if (s
!= htab
->elf
.srelplt
)
3840 /* It's not one of our sections, so don't allocate space. */
3846 /* If we don't need this section, strip it from the
3847 output file. This is mostly to handle .rela.bss and
3848 .rela.plt. We must create both sections in
3849 create_dynamic_sections, because they must be created
3850 before the linker maps input sections to output
3851 sections. The linker does that before
3852 adjust_dynamic_symbol is called, and it is that
3853 function which decides whether anything needs to go
3854 into these sections. */
3856 s
->flags
|= SEC_EXCLUDE
;
3860 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
3863 /* Allocate memory for the section contents. We use bfd_zalloc
3864 here in case unused entries are not reclaimed before the
3865 section's contents are written out. This should not happen,
3866 but this way if it does, we get a R_X86_64_NONE reloc instead
3868 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
3869 if (s
->contents
== NULL
)
3873 if (htab
->plt_eh_frame
!= NULL
3874 && htab
->plt_eh_frame
->contents
!= NULL
)
3876 const struct elf_x86_64_backend_data
*arch_data
3877 = get_elf_x86_64_arch_data (bed
);
3879 memcpy (htab
->plt_eh_frame
->contents
,
3880 arch_data
->eh_frame_plt
, htab
->plt_eh_frame
->size
);
3881 bfd_put_32 (dynobj
, htab
->elf
.splt
->size
,
3882 htab
->plt_eh_frame
->contents
+ PLT_FDE_LEN_OFFSET
);
3885 if (htab
->elf
.dynamic_sections_created
)
3887 /* Add some entries to the .dynamic section. We fill in the
3888 values later, in elf_x86_64_finish_dynamic_sections, but we
3889 must add the entries now so that we get the correct size for
3890 the .dynamic section. The DT_DEBUG entry is filled in by the
3891 dynamic linker and used by the debugger. */
3892 #define add_dynamic_entry(TAG, VAL) \
3893 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3895 if (bfd_link_executable (info
))
3897 if (!add_dynamic_entry (DT_DEBUG
, 0))
3901 if (htab
->elf
.splt
->size
!= 0)
3903 /* DT_PLTGOT is used by prelink even if there is no PLT
3905 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3908 if (htab
->elf
.srelplt
->size
!= 0)
3910 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3911 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3912 || !add_dynamic_entry (DT_JMPREL
, 0))
3916 if (htab
->tlsdesc_plt
3917 && (!add_dynamic_entry (DT_TLSDESC_PLT
, 0)
3918 || !add_dynamic_entry (DT_TLSDESC_GOT
, 0)))
3924 if (!add_dynamic_entry (DT_RELA
, 0)
3925 || !add_dynamic_entry (DT_RELASZ
, 0)
3926 || !add_dynamic_entry (DT_RELAENT
, bed
->s
->sizeof_rela
))
3929 /* If any dynamic relocs apply to a read-only section,
3930 then we need a DT_TEXTREL entry. */
3931 if ((info
->flags
& DF_TEXTREL
) == 0)
3932 elf_link_hash_traverse (&htab
->elf
,
3933 elf_x86_64_readonly_dynrelocs
,
3936 if ((info
->flags
& DF_TEXTREL
) != 0)
3938 if (htab
->readonly_dynrelocs_against_ifunc
)
3940 info
->callbacks
->einfo
3941 (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
3942 bfd_set_error (bfd_error_bad_value
);
3946 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3951 #undef add_dynamic_entry
3957 elf_x86_64_always_size_sections (bfd
*output_bfd
,
3958 struct bfd_link_info
*info
)
3960 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3964 struct elf_link_hash_entry
*tlsbase
;
3966 tlsbase
= elf_link_hash_lookup (elf_hash_table (info
),
3967 "_TLS_MODULE_BASE_",
3968 FALSE
, FALSE
, FALSE
);
3970 if (tlsbase
&& tlsbase
->type
== STT_TLS
)
3972 struct elf_x86_64_link_hash_table
*htab
;
3973 struct bfd_link_hash_entry
*bh
= NULL
;
3974 const struct elf_backend_data
*bed
3975 = get_elf_backend_data (output_bfd
);
3977 htab
= elf_x86_64_hash_table (info
);
3981 if (!(_bfd_generic_link_add_one_symbol
3982 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
3983 tls_sec
, 0, NULL
, FALSE
,
3984 bed
->collect
, &bh
)))
3987 htab
->tls_module_base
= bh
;
3989 tlsbase
= (struct elf_link_hash_entry
*)bh
;
3990 tlsbase
->def_regular
= 1;
3991 tlsbase
->other
= STV_HIDDEN
;
3992 tlsbase
->root
.linker_def
= 1;
3993 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
4000 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
4001 executables. Rather than setting it to the beginning of the TLS
4002 section, we have to set it to the end. This function may be called
4003 multiple times, it is idempotent. */
4006 elf_x86_64_set_tls_module_base (struct bfd_link_info
*info
)
4008 struct elf_x86_64_link_hash_table
*htab
;
4009 struct bfd_link_hash_entry
*base
;
4011 if (!bfd_link_executable (info
))
4014 htab
= elf_x86_64_hash_table (info
);
4018 base
= htab
->tls_module_base
;
4022 base
->u
.def
.value
= htab
->elf
.tls_size
;
4025 /* Return the base VMA address which should be subtracted from real addresses
4026 when resolving @dtpoff relocation.
4027 This is PT_TLS segment p_vaddr. */
4030 elf_x86_64_dtpoff_base (struct bfd_link_info
*info
)
4032 /* If tls_sec is NULL, we should have signalled an error already. */
4033 if (elf_hash_table (info
)->tls_sec
== NULL
)
4035 return elf_hash_table (info
)->tls_sec
->vma
;
4038 /* Return the relocation value for @tpoff relocation
4039 if STT_TLS virtual address is ADDRESS. */
4042 elf_x86_64_tpoff (struct bfd_link_info
*info
, bfd_vma address
)
4044 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
4045 const struct elf_backend_data
*bed
= get_elf_backend_data (info
->output_bfd
);
4046 bfd_vma static_tls_size
;
4048 /* If tls_segment is NULL, we should have signalled an error already. */
4049 if (htab
->tls_sec
== NULL
)
4052 /* Consider special static TLS alignment requirements. */
4053 static_tls_size
= BFD_ALIGN (htab
->tls_size
, bed
->static_tls_alignment
);
4054 return address
- static_tls_size
- htab
->tls_sec
->vma
;
4057 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
4061 is_32bit_relative_branch (bfd_byte
*contents
, bfd_vma offset
)
4063 /* Opcode Instruction
4066 0x0f 0x8x conditional jump */
4068 && (contents
[offset
- 1] == 0xe8
4069 || contents
[offset
- 1] == 0xe9))
4071 && contents
[offset
- 2] == 0x0f
4072 && (contents
[offset
- 1] & 0xf0) == 0x80));
4075 /* Relocate an x86_64 ELF section. */
4078 elf_x86_64_relocate_section (bfd
*output_bfd
,
4079 struct bfd_link_info
*info
,
4081 asection
*input_section
,
4083 Elf_Internal_Rela
*relocs
,
4084 Elf_Internal_Sym
*local_syms
,
4085 asection
**local_sections
)
4087 struct elf_x86_64_link_hash_table
*htab
;
4088 Elf_Internal_Shdr
*symtab_hdr
;
4089 struct elf_link_hash_entry
**sym_hashes
;
4090 bfd_vma
*local_got_offsets
;
4091 bfd_vma
*local_tlsdesc_gotents
;
4092 Elf_Internal_Rela
*rel
;
4093 Elf_Internal_Rela
*wrel
;
4094 Elf_Internal_Rela
*relend
;
4095 const unsigned int plt_entry_size
= GET_PLT_ENTRY_SIZE (info
->output_bfd
);
4097 BFD_ASSERT (is_x86_64_elf (input_bfd
));
4099 /* Skip if check_relocs failed. */
4100 if (input_section
->check_relocs_failed
)
4103 htab
= elf_x86_64_hash_table (info
);
4106 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
4107 sym_hashes
= elf_sym_hashes (input_bfd
);
4108 local_got_offsets
= elf_local_got_offsets (input_bfd
);
4109 local_tlsdesc_gotents
= elf_x86_64_local_tlsdesc_gotent (input_bfd
);
4111 elf_x86_64_set_tls_module_base (info
);
4113 rel
= wrel
= relocs
;
4114 relend
= relocs
+ input_section
->reloc_count
;
4115 for (; rel
< relend
; wrel
++, rel
++)
4117 unsigned int r_type
;
4118 reloc_howto_type
*howto
;
4119 unsigned long r_symndx
;
4120 struct elf_link_hash_entry
*h
;
4121 struct elf_x86_64_link_hash_entry
*eh
;
4122 Elf_Internal_Sym
*sym
;
4124 bfd_vma off
, offplt
, plt_offset
;
4126 bfd_boolean unresolved_reloc
;
4127 bfd_reloc_status_type r
;
4129 asection
*base_got
, *resolved_plt
;
4131 bfd_boolean resolved_to_zero
;
4133 r_type
= ELF32_R_TYPE (rel
->r_info
);
4134 if (r_type
== (int) R_X86_64_GNU_VTINHERIT
4135 || r_type
== (int) R_X86_64_GNU_VTENTRY
)
4142 if (r_type
>= (int) R_X86_64_standard
)
4145 /* xgettext:c-format */
4146 (_("%B: unrecognized relocation (0x%x) in section `%A'"),
4147 input_bfd
, input_section
, r_type
);
4148 bfd_set_error (bfd_error_bad_value
);
4152 if (r_type
!= (int) R_X86_64_32
4153 || ABI_64_P (output_bfd
))
4154 howto
= x86_64_elf_howto_table
+ r_type
;
4156 howto
= (x86_64_elf_howto_table
4157 + ARRAY_SIZE (x86_64_elf_howto_table
) - 1);
4158 r_symndx
= htab
->r_sym (rel
->r_info
);
4162 unresolved_reloc
= FALSE
;
4163 if (r_symndx
< symtab_hdr
->sh_info
)
4165 sym
= local_syms
+ r_symndx
;
4166 sec
= local_sections
[r_symndx
];
4168 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
,
4170 st_size
= sym
->st_size
;
4172 /* Relocate against local STT_GNU_IFUNC symbol. */
4173 if (!bfd_link_relocatable (info
)
4174 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
4176 h
= elf_x86_64_get_local_sym_hash (htab
, input_bfd
,
4181 /* Set STT_GNU_IFUNC symbol value. */
4182 h
->root
.u
.def
.value
= sym
->st_value
;
4183 h
->root
.u
.def
.section
= sec
;
4188 bfd_boolean warned ATTRIBUTE_UNUSED
;
4189 bfd_boolean ignored ATTRIBUTE_UNUSED
;
4191 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
4192 r_symndx
, symtab_hdr
, sym_hashes
,
4194 unresolved_reloc
, warned
, ignored
);
4198 if (sec
!= NULL
&& discarded_section (sec
))
4200 _bfd_clear_contents (howto
, input_bfd
, input_section
,
4201 contents
+ rel
->r_offset
);
4202 wrel
->r_offset
= rel
->r_offset
;
4206 /* For ld -r, remove relocations in debug sections against
4207 sections defined in discarded sections. Not done for
4208 eh_frame editing code expects to be present. */
4209 if (bfd_link_relocatable (info
)
4210 && (input_section
->flags
& SEC_DEBUGGING
))
4216 if (bfd_link_relocatable (info
))
4223 if (rel
->r_addend
== 0 && !ABI_64_P (output_bfd
))
4225 if (r_type
== R_X86_64_64
)
4227 /* For x32, treat R_X86_64_64 like R_X86_64_32 and
4228 zero-extend it to 64bit if addend is zero. */
4229 r_type
= R_X86_64_32
;
4230 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4232 else if (r_type
== R_X86_64_SIZE64
)
4234 /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
4235 zero-extend it to 64bit if addend is zero. */
4236 r_type
= R_X86_64_SIZE32
;
4237 memset (contents
+ rel
->r_offset
+ 4, 0, 4);
4241 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
4243 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
4244 it here if it is defined in a non-shared object. */
4246 && h
->type
== STT_GNU_IFUNC
4252 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4254 /* Dynamic relocs are not propagated for SEC_DEBUGGING
4255 sections because such sections are not SEC_ALLOC and
4256 thus ld.so will not process them. */
4257 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
4267 case R_X86_64_GOTPCREL
:
4268 case R_X86_64_GOTPCRELX
:
4269 case R_X86_64_REX_GOTPCRELX
:
4270 case R_X86_64_GOTPCREL64
:
4271 base_got
= htab
->elf
.sgot
;
4272 off
= h
->got
.offset
;
4274 if (base_got
== NULL
)
4277 if (off
== (bfd_vma
) -1)
4279 /* We can't use h->got.offset here to save state, or
4280 even just remember the offset, as finish_dynamic_symbol
4281 would use that as offset into .got. */
4283 if (h
->plt
.offset
== (bfd_vma
) -1)
4286 if (htab
->elf
.splt
!= NULL
)
4288 plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4289 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4290 base_got
= htab
->elf
.sgotplt
;
4294 plt_index
= h
->plt
.offset
/ plt_entry_size
;
4295 off
= plt_index
* GOT_ENTRY_SIZE
;
4296 base_got
= htab
->elf
.igotplt
;
4299 if (h
->dynindx
== -1
4303 /* This references the local defitionion. We must
4304 initialize this entry in the global offset table.
4305 Since the offset must always be a multiple of 8,
4306 we use the least significant bit to record
4307 whether we have initialized it already.
4309 When doing a dynamic link, we create a .rela.got
4310 relocation entry to initialize the value. This
4311 is done in the finish_dynamic_symbol routine. */
4316 bfd_put_64 (output_bfd
, relocation
,
4317 base_got
->contents
+ off
);
4318 /* Note that this is harmless for the GOTPLT64
4319 case, as -1 | 1 still is -1. */
4325 relocation
= (base_got
->output_section
->vma
4326 + base_got
->output_offset
+ off
);
4331 if (h
->plt
.offset
== (bfd_vma
) -1)
4333 /* Handle static pointers of STT_GNU_IFUNC symbols. */
4334 if (r_type
== htab
->pointer_r_type
4335 && (input_section
->flags
& SEC_CODE
) == 0)
4336 goto do_ifunc_pointer
;
4337 goto bad_ifunc_reloc
;
4340 /* STT_GNU_IFUNC symbol must go through PLT. */
4341 if (htab
->elf
.splt
!= NULL
)
4343 if (htab
->plt_bnd
!= NULL
)
4345 resolved_plt
= htab
->plt_bnd
;
4346 plt_offset
= eh
->plt_bnd
.offset
;
4350 resolved_plt
= htab
->elf
.splt
;
4351 plt_offset
= h
->plt
.offset
;
4356 resolved_plt
= htab
->elf
.iplt
;
4357 plt_offset
= h
->plt
.offset
;
4360 relocation
= (resolved_plt
->output_section
->vma
4361 + resolved_plt
->output_offset
+ plt_offset
);
4367 if (h
->root
.root
.string
)
4368 name
= h
->root
.root
.string
;
4370 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4373 /* xgettext:c-format */
4374 (_("%B: relocation %s against STT_GNU_IFUNC "
4375 "symbol `%s' isn't supported"), input_bfd
,
4377 bfd_set_error (bfd_error_bad_value
);
4381 if (bfd_link_pic (info
))
4386 if (ABI_64_P (output_bfd
))
4391 if (rel
->r_addend
!= 0)
4393 if (h
->root
.root
.string
)
4394 name
= h
->root
.root
.string
;
4396 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4399 /* xgettext:c-format */
4400 (_("%B: relocation %s against STT_GNU_IFUNC "
4401 "symbol `%s' has non-zero addend: %d"),
4402 input_bfd
, howto
->name
, name
, rel
->r_addend
);
4403 bfd_set_error (bfd_error_bad_value
);
4407 /* Generate dynamic relcoation only when there is a
4408 non-GOT reference in a shared object or there is no
4410 if ((bfd_link_pic (info
) && h
->non_got_ref
)
4411 || h
->plt
.offset
== (bfd_vma
) -1)
4413 Elf_Internal_Rela outrel
;
4416 /* Need a dynamic relocation to get the real function
4418 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
4422 if (outrel
.r_offset
== (bfd_vma
) -1
4423 || outrel
.r_offset
== (bfd_vma
) -2)
4426 outrel
.r_offset
+= (input_section
->output_section
->vma
4427 + input_section
->output_offset
);
4429 if (h
->dynindx
== -1
4431 || bfd_link_executable (info
))
4433 /* This symbol is resolved locally. */
4434 outrel
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
4435 outrel
.r_addend
= (h
->root
.u
.def
.value
4436 + h
->root
.u
.def
.section
->output_section
->vma
4437 + h
->root
.u
.def
.section
->output_offset
);
4441 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4442 outrel
.r_addend
= 0;
4445 /* Dynamic relocations are stored in
4446 1. .rela.ifunc section in PIC object.
4447 2. .rela.got section in dynamic executable.
4448 3. .rela.iplt section in static executable. */
4449 if (bfd_link_pic (info
))
4450 sreloc
= htab
->elf
.irelifunc
;
4451 else if (htab
->elf
.splt
!= NULL
)
4452 sreloc
= htab
->elf
.srelgot
;
4454 sreloc
= htab
->elf
.irelplt
;
4455 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4457 /* If this reloc is against an external symbol, we
4458 do not want to fiddle with the addend. Otherwise,
4459 we need to include the symbol value so that it
4460 becomes an addend for the dynamic reloc. For an
4461 internal symbol, we have updated addend. */
4466 case R_X86_64_PC32_BND
:
4468 case R_X86_64_PLT32
:
4469 case R_X86_64_PLT32_BND
:
4474 resolved_to_zero
= (eh
!= NULL
4475 && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
4479 /* When generating a shared object, the relocations handled here are
4480 copied into the output file to be resolved at run time. */
4483 case R_X86_64_GOT32
:
4484 case R_X86_64_GOT64
:
4485 /* Relocation is to the entry for this symbol in the global
4487 case R_X86_64_GOTPCREL
:
4488 case R_X86_64_GOTPCRELX
:
4489 case R_X86_64_REX_GOTPCRELX
:
4490 case R_X86_64_GOTPCREL64
:
4491 /* Use global offset table entry as symbol value. */
4492 case R_X86_64_GOTPLT64
:
4493 /* This is obsolete and treated the the same as GOT64. */
4494 base_got
= htab
->elf
.sgot
;
4496 if (htab
->elf
.sgot
== NULL
)
4503 off
= h
->got
.offset
;
4505 && h
->plt
.offset
!= (bfd_vma
)-1
4506 && off
== (bfd_vma
)-1)
4508 /* We can't use h->got.offset here to save
4509 state, or even just remember the offset, as
4510 finish_dynamic_symbol would use that as offset into
4512 bfd_vma plt_index
= h
->plt
.offset
/ plt_entry_size
- 1;
4513 off
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
4514 base_got
= htab
->elf
.sgotplt
;
4517 dyn
= htab
->elf
.dynamic_sections_created
;
4519 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
4520 || (bfd_link_pic (info
)
4521 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4522 || (ELF_ST_VISIBILITY (h
->other
)
4523 && h
->root
.type
== bfd_link_hash_undefweak
))
4525 /* This is actually a static link, or it is a -Bsymbolic
4526 link and the symbol is defined locally, or the symbol
4527 was forced to be local because of a version file. We
4528 must initialize this entry in the global offset table.
4529 Since the offset must always be a multiple of 8, we
4530 use the least significant bit to record whether we
4531 have initialized it already.
4533 When doing a dynamic link, we create a .rela.got
4534 relocation entry to initialize the value. This is
4535 done in the finish_dynamic_symbol routine. */
4540 bfd_put_64 (output_bfd
, relocation
,
4541 base_got
->contents
+ off
);
4542 /* Note that this is harmless for the GOTPLT64 case,
4543 as -1 | 1 still is -1. */
4548 unresolved_reloc
= FALSE
;
4552 if (local_got_offsets
== NULL
)
4555 off
= local_got_offsets
[r_symndx
];
4557 /* The offset must always be a multiple of 8. We use
4558 the least significant bit to record whether we have
4559 already generated the necessary reloc. */
4564 bfd_put_64 (output_bfd
, relocation
,
4565 base_got
->contents
+ off
);
4567 if (bfd_link_pic (info
))
4570 Elf_Internal_Rela outrel
;
4572 /* We need to generate a R_X86_64_RELATIVE reloc
4573 for the dynamic linker. */
4574 s
= htab
->elf
.srelgot
;
4578 outrel
.r_offset
= (base_got
->output_section
->vma
4579 + base_got
->output_offset
4581 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4582 outrel
.r_addend
= relocation
;
4583 elf_append_rela (output_bfd
, s
, &outrel
);
4586 local_got_offsets
[r_symndx
] |= 1;
4590 if (off
>= (bfd_vma
) -2)
4593 relocation
= base_got
->output_section
->vma
4594 + base_got
->output_offset
+ off
;
4595 if (r_type
!= R_X86_64_GOTPCREL
4596 && r_type
!= R_X86_64_GOTPCRELX
4597 && r_type
!= R_X86_64_REX_GOTPCRELX
4598 && r_type
!= R_X86_64_GOTPCREL64
)
4599 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4600 - htab
->elf
.sgotplt
->output_offset
;
4604 case R_X86_64_GOTOFF64
:
4605 /* Relocation is relative to the start of the global offset
4608 /* Check to make sure it isn't a protected function or data
4609 symbol for shared library since it may not be local when
4610 used as function address or with copy relocation. We also
4611 need to make sure that a symbol is referenced locally. */
4612 if (bfd_link_pic (info
) && h
)
4614 if (!h
->def_regular
)
4618 switch (ELF_ST_VISIBILITY (h
->other
))
4621 v
= _("hidden symbol");
4624 v
= _("internal symbol");
4627 v
= _("protected symbol");
4635 /* xgettext:c-format */
4636 (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s `%s' can not be used when making a shared object"),
4637 input_bfd
, v
, h
->root
.root
.string
);
4638 bfd_set_error (bfd_error_bad_value
);
4641 else if (!bfd_link_executable (info
)
4642 && !SYMBOL_REFERENCES_LOCAL (info
, h
)
4643 && (h
->type
== STT_FUNC
4644 || h
->type
== STT_OBJECT
)
4645 && ELF_ST_VISIBILITY (h
->other
) == STV_PROTECTED
)
4648 /* xgettext:c-format */
4649 (_("%B: relocation R_X86_64_GOTOFF64 against protected %s `%s' can not be used when making a shared object"),
4651 h
->type
== STT_FUNC
? "function" : "data",
4652 h
->root
.root
.string
);
4653 bfd_set_error (bfd_error_bad_value
);
4658 /* Note that sgot is not involved in this
4659 calculation. We always want the start of .got.plt. If we
4660 defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4661 permitted by the ABI, we might have to change this
4663 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4664 + htab
->elf
.sgotplt
->output_offset
;
4667 case R_X86_64_GOTPC32
:
4668 case R_X86_64_GOTPC64
:
4669 /* Use global offset table as symbol value. */
4670 relocation
= htab
->elf
.sgotplt
->output_section
->vma
4671 + htab
->elf
.sgotplt
->output_offset
;
4672 unresolved_reloc
= FALSE
;
4675 case R_X86_64_PLTOFF64
:
4676 /* Relocation is PLT entry relative to GOT. For local
4677 symbols it's the symbol itself relative to GOT. */
4679 /* See PLT32 handling. */
4680 && (h
->plt
.offset
!= (bfd_vma
) -1
4681 || eh
->plt_got
.offset
!= (bfd_vma
) -1)
4682 && htab
->elf
.splt
!= NULL
)
4684 if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
4686 /* Use the GOT PLT. */
4687 resolved_plt
= htab
->plt_got
;
4688 plt_offset
= eh
->plt_got
.offset
;
4690 else if (htab
->plt_bnd
!= NULL
)
4692 resolved_plt
= htab
->plt_bnd
;
4693 plt_offset
= eh
->plt_bnd
.offset
;
4697 resolved_plt
= htab
->elf
.splt
;
4698 plt_offset
= h
->plt
.offset
;
4701 relocation
= (resolved_plt
->output_section
->vma
4702 + resolved_plt
->output_offset
4704 unresolved_reloc
= FALSE
;
4707 relocation
-= htab
->elf
.sgotplt
->output_section
->vma
4708 + htab
->elf
.sgotplt
->output_offset
;
4711 case R_X86_64_PLT32
:
4712 case R_X86_64_PLT32_BND
:
4713 /* Relocation is to the entry for this symbol in the
4714 procedure linkage table. */
4716 /* Resolve a PLT32 reloc against a local symbol directly,
4717 without using the procedure linkage table. */
4721 if ((h
->plt
.offset
== (bfd_vma
) -1
4722 && eh
->plt_got
.offset
== (bfd_vma
) -1)
4723 || htab
->elf
.splt
== NULL
)
4725 /* We didn't make a PLT entry for this symbol. This
4726 happens when statically linking PIC code, or when
4727 using -Bsymbolic. */
4731 if (h
->plt
.offset
!= (bfd_vma
) -1)
4733 if (htab
->plt_bnd
!= NULL
)
4735 resolved_plt
= htab
->plt_bnd
;
4736 plt_offset
= eh
->plt_bnd
.offset
;
4740 resolved_plt
= htab
->elf
.splt
;
4741 plt_offset
= h
->plt
.offset
;
4746 /* Use the GOT PLT. */
4747 resolved_plt
= htab
->plt_got
;
4748 plt_offset
= eh
->plt_got
.offset
;
4751 relocation
= (resolved_plt
->output_section
->vma
4752 + resolved_plt
->output_offset
4754 unresolved_reloc
= FALSE
;
4757 case R_X86_64_SIZE32
:
4758 case R_X86_64_SIZE64
:
4759 /* Set to symbol size. */
4760 relocation
= st_size
;
4766 case R_X86_64_PC32_BND
:
4767 /* Don't complain about -fPIC if the symbol is undefined when
4768 building executable unless it is unresolved weak symbol. */
4769 if ((input_section
->flags
& SEC_ALLOC
) != 0
4770 && (input_section
->flags
& SEC_READONLY
) != 0
4772 && ((bfd_link_executable (info
)
4773 && h
->root
.type
== bfd_link_hash_undefweak
4774 && !resolved_to_zero
)
4775 || (bfd_link_pic (info
)
4776 && !(bfd_link_pie (info
)
4777 && h
->root
.type
== bfd_link_hash_undefined
))))
4779 bfd_boolean fail
= FALSE
;
4781 = ((r_type
== R_X86_64_PC32
4782 || r_type
== R_X86_64_PC32_BND
)
4783 && is_32bit_relative_branch (contents
, rel
->r_offset
));
4785 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
4787 /* Symbol is referenced locally. Make sure it is
4788 defined locally or for a branch. */
4789 fail
= !h
->def_regular
&& !branch
;
4791 else if (!(bfd_link_pie (info
)
4792 && (h
->needs_copy
|| eh
->needs_copy
)))
4794 /* Symbol doesn't need copy reloc and isn't referenced
4795 locally. We only allow branch to symbol with
4796 non-default visibility. */
4798 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
);
4802 return elf_x86_64_need_pic (input_bfd
, input_section
,
4803 h
, NULL
, NULL
, howto
);
4812 /* FIXME: The ABI says the linker should make sure the value is
4813 the same when it's zeroextended to 64 bit. */
4816 if ((input_section
->flags
& SEC_ALLOC
) == 0)
4819 /* Don't copy a pc-relative relocation into the output file
4820 if the symbol needs copy reloc or the symbol is undefined
4821 when building executable. Copy dynamic function pointer
4822 relocations. Don't generate dynamic relocations against
4823 resolved undefined weak symbols in PIE. */
4824 if ((bfd_link_pic (info
)
4825 && !(bfd_link_pie (info
)
4829 || h
->root
.type
== bfd_link_hash_undefined
)
4830 && (IS_X86_64_PCREL_TYPE (r_type
)
4831 || r_type
== R_X86_64_SIZE32
4832 || r_type
== R_X86_64_SIZE64
))
4834 || ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4835 && !resolved_to_zero
)
4836 || h
->root
.type
!= bfd_link_hash_undefweak
))
4837 && ((! IS_X86_64_PCREL_TYPE (r_type
)
4838 && r_type
!= R_X86_64_SIZE32
4839 && r_type
!= R_X86_64_SIZE64
)
4840 || ! SYMBOL_CALLS_LOCAL (info
, h
)))
4841 || (ELIMINATE_COPY_RELOCS
4842 && !bfd_link_pic (info
)
4846 || eh
->func_pointer_refcount
> 0
4847 || (h
->root
.type
== bfd_link_hash_undefweak
4848 && !resolved_to_zero
))
4849 && ((h
->def_dynamic
&& !h
->def_regular
)
4850 /* Undefined weak symbol is bound locally when
4852 || h
->root
.type
== bfd_link_hash_undefined
)))
4854 Elf_Internal_Rela outrel
;
4855 bfd_boolean skip
, relocate
;
4858 /* When generating a shared object, these relocations
4859 are copied into the output file to be resolved at run
4865 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4867 if (outrel
.r_offset
== (bfd_vma
) -1)
4869 else if (outrel
.r_offset
== (bfd_vma
) -2)
4870 skip
= TRUE
, relocate
= TRUE
;
4872 outrel
.r_offset
+= (input_section
->output_section
->vma
4873 + input_section
->output_offset
);
4876 memset (&outrel
, 0, sizeof outrel
);
4878 /* h->dynindx may be -1 if this symbol was marked to
4882 && (IS_X86_64_PCREL_TYPE (r_type
)
4883 || !(bfd_link_executable (info
)
4884 || SYMBOLIC_BIND (info
, h
))
4885 || ! h
->def_regular
))
4887 outrel
.r_info
= htab
->r_info (h
->dynindx
, r_type
);
4888 outrel
.r_addend
= rel
->r_addend
;
4892 /* This symbol is local, or marked to become local.
4893 When relocation overflow check is disabled, we
4894 convert R_X86_64_32 to dynamic R_X86_64_RELATIVE. */
4895 if (r_type
== htab
->pointer_r_type
4896 || (r_type
== R_X86_64_32
4897 && info
->no_reloc_overflow_check
))
4900 outrel
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
4901 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4903 else if (r_type
== R_X86_64_64
4904 && !ABI_64_P (output_bfd
))
4907 outrel
.r_info
= htab
->r_info (0,
4908 R_X86_64_RELATIVE64
);
4909 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4910 /* Check addend overflow. */
4911 if ((outrel
.r_addend
& 0x80000000)
4912 != (rel
->r_addend
& 0x80000000))
4915 int addend
= rel
->r_addend
;
4916 if (h
&& h
->root
.root
.string
)
4917 name
= h
->root
.root
.string
;
4919 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
,
4923 /* xgettext:c-format */
4924 (_("%B: addend -0x%x in relocation %s against "
4925 "symbol `%s' at 0x%lx in section `%A' is "
4927 input_bfd
, input_section
, addend
,
4929 (unsigned long) rel
->r_offset
);
4932 /* xgettext:c-format */
4933 (_("%B: addend 0x%x in relocation %s against "
4934 "symbol `%s' at 0x%lx in section `%A' is "
4936 input_bfd
, input_section
, addend
,
4938 (unsigned long) rel
->r_offset
);
4939 bfd_set_error (bfd_error_bad_value
);
4947 if (bfd_is_abs_section (sec
))
4949 else if (sec
== NULL
|| sec
->owner
== NULL
)
4951 bfd_set_error (bfd_error_bad_value
);
4958 /* We are turning this relocation into one
4959 against a section symbol. It would be
4960 proper to subtract the symbol's value,
4961 osec->vma, from the emitted reloc addend,
4962 but ld.so expects buggy relocs. */
4963 osec
= sec
->output_section
;
4964 sindx
= elf_section_data (osec
)->dynindx
;
4967 asection
*oi
= htab
->elf
.text_index_section
;
4968 sindx
= elf_section_data (oi
)->dynindx
;
4970 BFD_ASSERT (sindx
!= 0);
4973 outrel
.r_info
= htab
->r_info (sindx
, r_type
);
4974 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4978 sreloc
= elf_section_data (input_section
)->sreloc
;
4980 if (sreloc
== NULL
|| sreloc
->contents
== NULL
)
4982 r
= bfd_reloc_notsupported
;
4983 goto check_relocation_error
;
4986 elf_append_rela (output_bfd
, sreloc
, &outrel
);
4988 /* If this reloc is against an external symbol, we do
4989 not want to fiddle with the addend. Otherwise, we
4990 need to include the symbol value so that it becomes
4991 an addend for the dynamic reloc. */
4998 case R_X86_64_TLSGD
:
4999 case R_X86_64_GOTPC32_TLSDESC
:
5000 case R_X86_64_TLSDESC_CALL
:
5001 case R_X86_64_GOTTPOFF
:
5002 tls_type
= GOT_UNKNOWN
;
5003 if (h
== NULL
&& local_got_offsets
)
5004 tls_type
= elf_x86_64_local_got_tls_type (input_bfd
) [r_symndx
];
5006 tls_type
= elf_x86_64_hash_entry (h
)->tls_type
;
5008 if (! elf_x86_64_tls_transition (info
, input_bfd
,
5009 input_section
, contents
,
5010 symtab_hdr
, sym_hashes
,
5011 &r_type
, tls_type
, rel
,
5012 relend
, h
, r_symndx
, TRUE
))
5015 if (r_type
== R_X86_64_TPOFF32
)
5017 bfd_vma roff
= rel
->r_offset
;
5019 BFD_ASSERT (! unresolved_reloc
);
5021 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5023 /* GD->LE transition. For 64bit, change
5024 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5025 .word 0x6666; rex64; call __tls_get_addr@PLT
5027 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5029 call *__tls_get_addr@GOTPCREL(%rip)
5030 which may be converted to
5031 addr32 call __tls_get_addr
5034 leaq foo@tpoff(%rax), %rax
5036 leaq foo@tlsgd(%rip), %rdi
5037 .word 0x6666; rex64; call __tls_get_addr@PLT
5039 leaq foo@tlsgd(%rip), %rdi
5041 call *__tls_get_addr@GOTPCREL(%rip)
5042 which may be converted to
5043 addr32 call __tls_get_addr
5046 leaq foo@tpoff(%rax), %rax
5047 For largepic, change:
5048 leaq foo@tlsgd(%rip), %rdi
5049 movabsq $__tls_get_addr@pltoff, %rax
5054 leaq foo@tpoff(%rax), %rax
5055 nopw 0x0(%rax,%rax,1) */
5057 if (ABI_64_P (output_bfd
))
5059 if (contents
[roff
+ 5] == 0xb8)
5061 memcpy (contents
+ roff
- 3,
5062 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
5063 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5067 memcpy (contents
+ roff
- 4,
5068 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5072 memcpy (contents
+ roff
- 3,
5073 "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5075 bfd_put_32 (output_bfd
,
5076 elf_x86_64_tpoff (info
, relocation
),
5077 contents
+ roff
+ 8 + largepic
);
5078 /* Skip R_X86_64_PC32, R_X86_64_PLT32,
5079 R_X86_64_GOTPCRELX and R_X86_64_PLTOFF64. */
5084 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5086 /* GDesc -> LE transition.
5087 It's originally something like:
5088 leaq x@tlsdesc(%rip), %rax
5091 movl $x@tpoff, %rax. */
5093 unsigned int val
, type
;
5095 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5096 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5097 bfd_put_8 (output_bfd
, 0x48 | ((type
>> 2) & 1),
5098 contents
+ roff
- 3);
5099 bfd_put_8 (output_bfd
, 0xc7, contents
+ roff
- 2);
5100 bfd_put_8 (output_bfd
, 0xc0 | ((val
>> 3) & 7),
5101 contents
+ roff
- 1);
5102 bfd_put_32 (output_bfd
,
5103 elf_x86_64_tpoff (info
, relocation
),
5107 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5109 /* GDesc -> LE transition.
5114 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5115 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5118 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTTPOFF
)
5120 /* IE->LE transition:
5121 For 64bit, originally it can be one of:
5122 movq foo@gottpoff(%rip), %reg
5123 addq foo@gottpoff(%rip), %reg
5126 leaq foo(%reg), %reg
5128 For 32bit, originally it can be one of:
5129 movq foo@gottpoff(%rip), %reg
5130 addl foo@gottpoff(%rip), %reg
5133 leal foo(%reg), %reg
5136 unsigned int val
, type
, reg
;
5139 val
= bfd_get_8 (input_bfd
, contents
+ roff
- 3);
5142 type
= bfd_get_8 (input_bfd
, contents
+ roff
- 2);
5143 reg
= bfd_get_8 (input_bfd
, contents
+ roff
- 1);
5149 bfd_put_8 (output_bfd
, 0x49,
5150 contents
+ roff
- 3);
5151 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5152 bfd_put_8 (output_bfd
, 0x41,
5153 contents
+ roff
- 3);
5154 bfd_put_8 (output_bfd
, 0xc7,
5155 contents
+ roff
- 2);
5156 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5157 contents
+ roff
- 1);
5161 /* addq/addl -> addq/addl - addressing with %rsp/%r12
5164 bfd_put_8 (output_bfd
, 0x49,
5165 contents
+ roff
- 3);
5166 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5167 bfd_put_8 (output_bfd
, 0x41,
5168 contents
+ roff
- 3);
5169 bfd_put_8 (output_bfd
, 0x81,
5170 contents
+ roff
- 2);
5171 bfd_put_8 (output_bfd
, 0xc0 | reg
,
5172 contents
+ roff
- 1);
5176 /* addq/addl -> leaq/leal */
5178 bfd_put_8 (output_bfd
, 0x4d,
5179 contents
+ roff
- 3);
5180 else if (!ABI_64_P (output_bfd
) && val
== 0x44)
5181 bfd_put_8 (output_bfd
, 0x45,
5182 contents
+ roff
- 3);
5183 bfd_put_8 (output_bfd
, 0x8d,
5184 contents
+ roff
- 2);
5185 bfd_put_8 (output_bfd
, 0x80 | reg
| (reg
<< 3),
5186 contents
+ roff
- 1);
5188 bfd_put_32 (output_bfd
,
5189 elf_x86_64_tpoff (info
, relocation
),
5197 if (htab
->elf
.sgot
== NULL
)
5202 off
= h
->got
.offset
;
5203 offplt
= elf_x86_64_hash_entry (h
)->tlsdesc_got
;
5207 if (local_got_offsets
== NULL
)
5210 off
= local_got_offsets
[r_symndx
];
5211 offplt
= local_tlsdesc_gotents
[r_symndx
];
5218 Elf_Internal_Rela outrel
;
5222 if (htab
->elf
.srelgot
== NULL
)
5225 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
5227 if (GOT_TLS_GDESC_P (tls_type
))
5229 outrel
.r_info
= htab
->r_info (indx
, R_X86_64_TLSDESC
);
5230 BFD_ASSERT (htab
->sgotplt_jump_table_size
+ offplt
5231 + 2 * GOT_ENTRY_SIZE
<= htab
->elf
.sgotplt
->size
);
5232 outrel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
5233 + htab
->elf
.sgotplt
->output_offset
5235 + htab
->sgotplt_jump_table_size
);
5236 sreloc
= htab
->elf
.srelplt
;
5238 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5240 outrel
.r_addend
= 0;
5241 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5244 sreloc
= htab
->elf
.srelgot
;
5246 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5247 + htab
->elf
.sgot
->output_offset
+ off
);
5249 if (GOT_TLS_GD_P (tls_type
))
5250 dr_type
= R_X86_64_DTPMOD64
;
5251 else if (GOT_TLS_GDESC_P (tls_type
))
5254 dr_type
= R_X86_64_TPOFF64
;
5256 bfd_put_64 (output_bfd
, 0, htab
->elf
.sgot
->contents
+ off
);
5257 outrel
.r_addend
= 0;
5258 if ((dr_type
== R_X86_64_TPOFF64
5259 || dr_type
== R_X86_64_TLSDESC
) && indx
== 0)
5260 outrel
.r_addend
= relocation
- elf_x86_64_dtpoff_base (info
);
5261 outrel
.r_info
= htab
->r_info (indx
, dr_type
);
5263 elf_append_rela (output_bfd
, sreloc
, &outrel
);
5265 if (GOT_TLS_GD_P (tls_type
))
5269 BFD_ASSERT (! unresolved_reloc
);
5270 bfd_put_64 (output_bfd
,
5271 relocation
- elf_x86_64_dtpoff_base (info
),
5272 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5276 bfd_put_64 (output_bfd
, 0,
5277 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5278 outrel
.r_info
= htab
->r_info (indx
,
5280 outrel
.r_offset
+= GOT_ENTRY_SIZE
;
5281 elf_append_rela (output_bfd
, sreloc
,
5290 local_got_offsets
[r_symndx
] |= 1;
5293 if (off
>= (bfd_vma
) -2
5294 && ! GOT_TLS_GDESC_P (tls_type
))
5296 if (r_type
== ELF32_R_TYPE (rel
->r_info
))
5298 if (r_type
== R_X86_64_GOTPC32_TLSDESC
5299 || r_type
== R_X86_64_TLSDESC_CALL
)
5300 relocation
= htab
->elf
.sgotplt
->output_section
->vma
5301 + htab
->elf
.sgotplt
->output_offset
5302 + offplt
+ htab
->sgotplt_jump_table_size
;
5304 relocation
= htab
->elf
.sgot
->output_section
->vma
5305 + htab
->elf
.sgot
->output_offset
+ off
;
5306 unresolved_reloc
= FALSE
;
5310 bfd_vma roff
= rel
->r_offset
;
5312 if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSGD
)
5314 /* GD->IE transition. For 64bit, change
5315 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5316 .word 0x6666; rex64; call __tls_get_addr@PLT
5318 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5320 call *__tls_get_addr@GOTPCREL(%rip
5321 which may be converted to
5322 addr32 call __tls_get_addr
5325 addq foo@gottpoff(%rip), %rax
5327 leaq foo@tlsgd(%rip), %rdi
5328 .word 0x6666; rex64; call __tls_get_addr@PLT
5330 leaq foo@tlsgd(%rip), %rdi
5332 call *__tls_get_addr@GOTPCREL(%rip)
5333 which may be converted to
5334 addr32 call __tls_get_addr
5337 addq foo@gottpoff(%rip), %rax
5338 For largepic, change:
5339 leaq foo@tlsgd(%rip), %rdi
5340 movabsq $__tls_get_addr@pltoff, %rax
5345 addq foo@gottpoff(%rax), %rax
5346 nopw 0x0(%rax,%rax,1) */
5348 if (ABI_64_P (output_bfd
))
5350 if (contents
[roff
+ 5] == 0xb8)
5352 memcpy (contents
+ roff
- 3,
5353 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
5354 "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5358 memcpy (contents
+ roff
- 4,
5359 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5363 memcpy (contents
+ roff
- 3,
5364 "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5367 relocation
= (htab
->elf
.sgot
->output_section
->vma
5368 + htab
->elf
.sgot
->output_offset
+ off
5371 - input_section
->output_section
->vma
5372 - input_section
->output_offset
5374 bfd_put_32 (output_bfd
, relocation
,
5375 contents
+ roff
+ 8 + largepic
);
5376 /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64. */
5381 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_GOTPC32_TLSDESC
)
5383 /* GDesc -> IE transition.
5384 It's originally something like:
5385 leaq x@tlsdesc(%rip), %rax
5388 movq x@gottpoff(%rip), %rax # before xchg %ax,%ax. */
5390 /* Now modify the instruction as appropriate. To
5391 turn a leaq into a movq in the form we use it, it
5392 suffices to change the second byte from 0x8d to
5394 bfd_put_8 (output_bfd
, 0x8b, contents
+ roff
- 2);
5396 bfd_put_32 (output_bfd
,
5397 htab
->elf
.sgot
->output_section
->vma
5398 + htab
->elf
.sgot
->output_offset
+ off
5400 - input_section
->output_section
->vma
5401 - input_section
->output_offset
5406 else if (ELF32_R_TYPE (rel
->r_info
) == R_X86_64_TLSDESC_CALL
)
5408 /* GDesc -> IE transition.
5415 bfd_put_8 (output_bfd
, 0x66, contents
+ roff
);
5416 bfd_put_8 (output_bfd
, 0x90, contents
+ roff
+ 1);
5424 case R_X86_64_TLSLD
:
5425 if (! elf_x86_64_tls_transition (info
, input_bfd
,
5426 input_section
, contents
,
5427 symtab_hdr
, sym_hashes
,
5428 &r_type
, GOT_UNKNOWN
, rel
,
5429 relend
, h
, r_symndx
, TRUE
))
5432 if (r_type
!= R_X86_64_TLSLD
)
5434 /* LD->LE transition:
5435 leaq foo@tlsld(%rip), %rdi
5436 call __tls_get_addr@PLT
5437 For 64bit, we change it into:
5438 .word 0x6666; .byte 0x66; movq %fs:0, %rax
5439 For 32bit, we change it into:
5440 nopl 0x0(%rax); movl %fs:0, %eax
5442 leaq foo@tlsld(%rip), %rdi;
5443 call *__tls_get_addr@GOTPCREL(%rip)
5444 which may be converted to
5445 addr32 call __tls_get_addr
5446 For 64bit, we change it into:
5447 .word 0x6666; .word 0x6666; movq %fs:0, %rax
5448 For 32bit, we change it into:
5449 nopw 0x0(%rax); movl %fs:0, %eax
5450 For largepic, change:
5451 leaq foo@tlsgd(%rip), %rdi
5452 movabsq $__tls_get_addr@pltoff, %rax
5456 data16 data16 data16 nopw %cs:0x0(%rax,%rax,1)
5459 BFD_ASSERT (r_type
== R_X86_64_TPOFF32
);
5460 if (ABI_64_P (output_bfd
))
5462 if (contents
[rel
->r_offset
+ 5] == 0xb8)
5463 memcpy (contents
+ rel
->r_offset
- 3,
5464 "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
5465 "\x64\x48\x8b\x04\x25\0\0\0", 22);
5466 else if (contents
[rel
->r_offset
+ 4] == 0xff
5467 || contents
[rel
->r_offset
+ 4] == 0x67)
5468 memcpy (contents
+ rel
->r_offset
- 3,
5469 "\x66\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0",
5472 memcpy (contents
+ rel
->r_offset
- 3,
5473 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
5477 if (contents
[rel
->r_offset
+ 4] == 0xff)
5478 memcpy (contents
+ rel
->r_offset
- 3,
5479 "\x66\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0",
5482 memcpy (contents
+ rel
->r_offset
- 3,
5483 "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
5485 /* Skip R_X86_64_PC32, R_X86_64_PLT32, R_X86_64_GOTPCRELX
5486 and R_X86_64_PLTOFF64. */
5492 if (htab
->elf
.sgot
== NULL
)
5495 off
= htab
->tls_ld_got
.offset
;
5500 Elf_Internal_Rela outrel
;
5502 if (htab
->elf
.srelgot
== NULL
)
5505 outrel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5506 + htab
->elf
.sgot
->output_offset
+ off
);
5508 bfd_put_64 (output_bfd
, 0,
5509 htab
->elf
.sgot
->contents
+ off
);
5510 bfd_put_64 (output_bfd
, 0,
5511 htab
->elf
.sgot
->contents
+ off
+ GOT_ENTRY_SIZE
);
5512 outrel
.r_info
= htab
->r_info (0, R_X86_64_DTPMOD64
);
5513 outrel
.r_addend
= 0;
5514 elf_append_rela (output_bfd
, htab
->elf
.srelgot
,
5516 htab
->tls_ld_got
.offset
|= 1;
5518 relocation
= htab
->elf
.sgot
->output_section
->vma
5519 + htab
->elf
.sgot
->output_offset
+ off
;
5520 unresolved_reloc
= FALSE
;
5523 case R_X86_64_DTPOFF32
:
5524 if (!bfd_link_executable (info
)
5525 || (input_section
->flags
& SEC_CODE
) == 0)
5526 relocation
-= elf_x86_64_dtpoff_base (info
);
5528 relocation
= elf_x86_64_tpoff (info
, relocation
);
5531 case R_X86_64_TPOFF32
:
5532 case R_X86_64_TPOFF64
:
5533 BFD_ASSERT (bfd_link_executable (info
));
5534 relocation
= elf_x86_64_tpoff (info
, relocation
);
5537 case R_X86_64_DTPOFF64
:
5538 BFD_ASSERT ((input_section
->flags
& SEC_CODE
) == 0);
5539 relocation
-= elf_x86_64_dtpoff_base (info
);
5546 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5547 because such sections are not SEC_ALLOC and thus ld.so will
5548 not process them. */
5549 if (unresolved_reloc
5550 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
5552 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
5553 rel
->r_offset
) != (bfd_vma
) -1)
5556 /* xgettext:c-format */
5557 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
5560 (long) rel
->r_offset
,
5562 h
->root
.root
.string
);
5567 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
5568 contents
, rel
->r_offset
,
5569 relocation
, rel
->r_addend
);
5571 check_relocation_error
:
5572 if (r
!= bfd_reloc_ok
)
5577 name
= h
->root
.root
.string
;
5580 name
= bfd_elf_string_from_elf_section (input_bfd
,
5581 symtab_hdr
->sh_link
,
5586 name
= bfd_section_name (input_bfd
, sec
);
5589 if (r
== bfd_reloc_overflow
)
5590 (*info
->callbacks
->reloc_overflow
)
5591 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
5592 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
5596 /* xgettext:c-format */
5597 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
5598 input_bfd
, input_section
,
5599 (long) rel
->r_offset
, name
, (int) r
);
5610 Elf_Internal_Shdr
*rel_hdr
;
5611 size_t deleted
= rel
- wrel
;
5613 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
5614 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5615 if (rel_hdr
->sh_size
== 0)
5617 /* It is too late to remove an empty reloc section. Leave
5619 ??? What is wrong with an empty section??? */
5620 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
5623 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
5624 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
5625 input_section
->reloc_count
-= deleted
;
5631 /* Finish up dynamic symbol handling. We set the contents of various
5632 dynamic sections here. */
5635 elf_x86_64_finish_dynamic_symbol (bfd
*output_bfd
,
5636 struct bfd_link_info
*info
,
5637 struct elf_link_hash_entry
*h
,
5638 Elf_Internal_Sym
*sym
)
5640 struct elf_x86_64_link_hash_table
*htab
;
5641 const struct elf_x86_64_backend_data
*abed
;
5642 bfd_boolean use_plt_bnd
;
5643 struct elf_x86_64_link_hash_entry
*eh
;
5644 bfd_boolean local_undefweak
;
5646 htab
= elf_x86_64_hash_table (info
);
5650 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
5651 section only if there is .plt section. */
5652 use_plt_bnd
= htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
;
5654 ? &elf_x86_64_bnd_arch_bed
5655 : get_elf_x86_64_backend_data (output_bfd
));
5657 eh
= (struct elf_x86_64_link_hash_entry
*) h
;
5659 /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5660 resolved undefined weak symbols in executable so that their
5661 references have value 0 at run-time. */
5662 local_undefweak
= UNDEFINED_WEAK_RESOLVED_TO_ZERO (info
,
5666 if (h
->plt
.offset
!= (bfd_vma
) -1)
5669 bfd_vma got_offset
, plt_offset
, plt_plt_offset
, plt_got_offset
;
5670 bfd_vma plt_plt_insn_end
, plt_got_insn_size
;
5671 Elf_Internal_Rela rela
;
5673 asection
*plt
, *gotplt
, *relplt
, *resolved_plt
;
5674 const struct elf_backend_data
*bed
;
5675 bfd_vma plt_got_pcrel_offset
;
5677 /* When building a static executable, use .iplt, .igot.plt and
5678 .rela.iplt sections for STT_GNU_IFUNC symbols. */
5679 if (htab
->elf
.splt
!= NULL
)
5681 plt
= htab
->elf
.splt
;
5682 gotplt
= htab
->elf
.sgotplt
;
5683 relplt
= htab
->elf
.srelplt
;
5687 plt
= htab
->elf
.iplt
;
5688 gotplt
= htab
->elf
.igotplt
;
5689 relplt
= htab
->elf
.irelplt
;
5692 /* This symbol has an entry in the procedure linkage table. Set
5694 if ((h
->dynindx
== -1
5696 && !((h
->forced_local
|| bfd_link_executable (info
))
5698 && h
->type
== STT_GNU_IFUNC
))
5704 /* Get the index in the procedure linkage table which
5705 corresponds to this symbol. This is the index of this symbol
5706 in all the symbols for which we are making plt entries. The
5707 first entry in the procedure linkage table is reserved.
5709 Get the offset into the .got table of the entry that
5710 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE
5711 bytes. The first three are reserved for the dynamic linker.
5713 For static executables, we don't reserve anything. */
5715 if (plt
== htab
->elf
.splt
)
5717 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
- 1;
5718 got_offset
= (got_offset
+ 3) * GOT_ENTRY_SIZE
;
5722 got_offset
= h
->plt
.offset
/ abed
->plt_entry_size
;
5723 got_offset
= got_offset
* GOT_ENTRY_SIZE
;
5726 plt_plt_insn_end
= abed
->plt_plt_insn_end
;
5727 plt_plt_offset
= abed
->plt_plt_offset
;
5728 plt_got_insn_size
= abed
->plt_got_insn_size
;
5729 plt_got_offset
= abed
->plt_got_offset
;
5732 /* Use the second PLT with BND relocations. */
5733 const bfd_byte
*plt_entry
, *plt2_entry
;
5735 if (eh
->has_bnd_reloc
)
5737 plt_entry
= elf_x86_64_bnd_plt_entry
;
5738 plt2_entry
= elf_x86_64_bnd_plt2_entry
;
5742 plt_entry
= elf_x86_64_legacy_plt_entry
;
5743 plt2_entry
= elf_x86_64_legacy_plt2_entry
;
5745 /* Subtract 1 since there is no BND prefix. */
5746 plt_plt_insn_end
-= 1;
5747 plt_plt_offset
-= 1;
5748 plt_got_insn_size
-= 1;
5749 plt_got_offset
-= 1;
5752 BFD_ASSERT (sizeof (elf_x86_64_bnd_plt_entry
)
5753 == sizeof (elf_x86_64_legacy_plt_entry
));
5755 /* Fill in the entry in the procedure linkage table. */
5756 memcpy (plt
->contents
+ h
->plt
.offset
,
5757 plt_entry
, sizeof (elf_x86_64_legacy_plt_entry
));
5758 /* Fill in the entry in the second PLT. */
5759 memcpy (htab
->plt_bnd
->contents
+ eh
->plt_bnd
.offset
,
5760 plt2_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5762 resolved_plt
= htab
->plt_bnd
;
5763 plt_offset
= eh
->plt_bnd
.offset
;
5767 /* Fill in the entry in the procedure linkage table. */
5768 memcpy (plt
->contents
+ h
->plt
.offset
, abed
->plt_entry
,
5769 abed
->plt_entry_size
);
5772 plt_offset
= h
->plt
.offset
;
5775 /* Insert the relocation positions of the plt section. */
5777 /* Put offset the PC-relative instruction referring to the GOT entry,
5778 subtracting the size of that instruction. */
5779 plt_got_pcrel_offset
= (gotplt
->output_section
->vma
5780 + gotplt
->output_offset
5782 - resolved_plt
->output_section
->vma
5783 - resolved_plt
->output_offset
5785 - plt_got_insn_size
);
5787 /* Check PC-relative offset overflow in PLT entry. */
5788 if ((plt_got_pcrel_offset
+ 0x80000000) > 0xffffffff)
5789 /* xgettext:c-format */
5790 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5791 output_bfd
, h
->root
.root
.string
);
5793 bfd_put_32 (output_bfd
, plt_got_pcrel_offset
,
5794 resolved_plt
->contents
+ plt_offset
+ plt_got_offset
);
5796 /* Fill in the entry in the global offset table, initially this
5797 points to the second part of the PLT entry. Leave the entry
5798 as zero for undefined weak symbol in PIE. No PLT relocation
5799 against undefined weak symbol in PIE. */
5800 if (!local_undefweak
)
5802 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
5803 + plt
->output_offset
5805 + abed
->plt_lazy_offset
),
5806 gotplt
->contents
+ got_offset
);
5808 /* Fill in the entry in the .rela.plt section. */
5809 rela
.r_offset
= (gotplt
->output_section
->vma
5810 + gotplt
->output_offset
5812 if (h
->dynindx
== -1
5813 || ((bfd_link_executable (info
)
5814 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
5816 && h
->type
== STT_GNU_IFUNC
))
5818 /* If an STT_GNU_IFUNC symbol is locally defined, generate
5819 R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT. */
5820 rela
.r_info
= htab
->r_info (0, R_X86_64_IRELATIVE
);
5821 rela
.r_addend
= (h
->root
.u
.def
.value
5822 + h
->root
.u
.def
.section
->output_section
->vma
5823 + h
->root
.u
.def
.section
->output_offset
);
5824 /* R_X86_64_IRELATIVE comes last. */
5825 plt_index
= htab
->next_irelative_index
--;
5829 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_JUMP_SLOT
);
5831 plt_index
= htab
->next_jump_slot_index
++;
5834 /* Don't fill PLT entry for static executables. */
5835 if (plt
== htab
->elf
.splt
)
5837 bfd_vma plt0_offset
= h
->plt
.offset
+ plt_plt_insn_end
;
5839 /* Put relocation index. */
5840 bfd_put_32 (output_bfd
, plt_index
,
5841 (plt
->contents
+ h
->plt
.offset
5842 + abed
->plt_reloc_offset
));
5844 /* Put offset for jmp .PLT0 and check for overflow. We don't
5845 check relocation index for overflow since branch displacement
5846 will overflow first. */
5847 if (plt0_offset
> 0x80000000)
5848 /* xgettext:c-format */
5849 info
->callbacks
->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5850 output_bfd
, h
->root
.root
.string
);
5851 bfd_put_32 (output_bfd
, - plt0_offset
,
5852 plt
->contents
+ h
->plt
.offset
+ plt_plt_offset
);
5855 bed
= get_elf_backend_data (output_bfd
);
5856 loc
= relplt
->contents
+ plt_index
* bed
->s
->sizeof_rela
;
5857 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
5860 else if (eh
->plt_got
.offset
!= (bfd_vma
) -1)
5862 bfd_vma got_offset
, plt_offset
, plt_got_offset
, plt_got_insn_size
;
5863 asection
*plt
, *got
;
5864 bfd_boolean got_after_plt
;
5865 int32_t got_pcrel_offset
;
5866 const bfd_byte
*got_plt_entry
;
5868 /* Set the entry in the GOT procedure linkage table. */
5869 plt
= htab
->plt_got
;
5870 got
= htab
->elf
.sgot
;
5871 got_offset
= h
->got
.offset
;
5873 if (got_offset
== (bfd_vma
) -1
5874 || h
->type
== STT_GNU_IFUNC
5879 /* Use the second PLT entry template for the GOT PLT since they
5880 are the identical. */
5881 plt_got_insn_size
= elf_x86_64_bnd_arch_bed
.plt_got_insn_size
;
5882 plt_got_offset
= elf_x86_64_bnd_arch_bed
.plt_got_offset
;
5883 if (eh
->has_bnd_reloc
)
5884 got_plt_entry
= elf_x86_64_bnd_plt2_entry
;
5887 got_plt_entry
= elf_x86_64_legacy_plt2_entry
;
5889 /* Subtract 1 since there is no BND prefix. */
5890 plt_got_insn_size
-= 1;
5891 plt_got_offset
-= 1;
5894 /* Fill in the entry in the GOT procedure linkage table. */
5895 plt_offset
= eh
->plt_got
.offset
;
5896 memcpy (plt
->contents
+ plt_offset
,
5897 got_plt_entry
, sizeof (elf_x86_64_legacy_plt2_entry
));
5899 /* Put offset the PC-relative instruction referring to the GOT
5900 entry, subtracting the size of that instruction. */
5901 got_pcrel_offset
= (got
->output_section
->vma
5902 + got
->output_offset
5904 - plt
->output_section
->vma
5905 - plt
->output_offset
5907 - plt_got_insn_size
);
5909 /* Check PC-relative offset overflow in GOT PLT entry. */
5910 got_after_plt
= got
->output_section
->vma
> plt
->output_section
->vma
;
5911 if ((got_after_plt
&& got_pcrel_offset
< 0)
5912 || (!got_after_plt
&& got_pcrel_offset
> 0))
5913 /* xgettext:c-format */
5914 info
->callbacks
->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
5915 output_bfd
, h
->root
.root
.string
);
5917 bfd_put_32 (output_bfd
, got_pcrel_offset
,
5918 plt
->contents
+ plt_offset
+ plt_got_offset
);
5921 if (!local_undefweak
5923 && (h
->plt
.offset
!= (bfd_vma
) -1
5924 || eh
->plt_got
.offset
!= (bfd_vma
) -1))
5926 /* Mark the symbol as undefined, rather than as defined in
5927 the .plt section. Leave the value if there were any
5928 relocations where pointer equality matters (this is a clue
5929 for the dynamic linker, to make function pointer
5930 comparisons work between an application and shared
5931 library), otherwise set it to zero. If a function is only
5932 called from a binary, there is no need to slow down
5933 shared libraries because of that. */
5934 sym
->st_shndx
= SHN_UNDEF
;
5935 if (!h
->pointer_equality_needed
)
5939 /* Don't generate dynamic GOT relocation against undefined weak
5940 symbol in executable. */
5941 if (h
->got
.offset
!= (bfd_vma
) -1
5942 && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h
)->tls_type
)
5943 && elf_x86_64_hash_entry (h
)->tls_type
!= GOT_TLS_IE
5944 && !local_undefweak
)
5946 Elf_Internal_Rela rela
;
5947 asection
*relgot
= htab
->elf
.srelgot
;
5949 /* This symbol has an entry in the global offset table. Set it
5951 if (htab
->elf
.sgot
== NULL
|| htab
->elf
.srelgot
== NULL
)
5954 rela
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
5955 + htab
->elf
.sgot
->output_offset
5956 + (h
->got
.offset
&~ (bfd_vma
) 1));
5958 /* If this is a static link, or it is a -Bsymbolic link and the
5959 symbol is defined locally or was forced to be local because
5960 of a version file, we just want to emit a RELATIVE reloc.
5961 The entry in the global offset table will already have been
5962 initialized in the relocate_section function. */
5964 && h
->type
== STT_GNU_IFUNC
)
5966 if (h
->plt
.offset
== (bfd_vma
) -1)
5968 /* STT_GNU_IFUNC is referenced without PLT. */
5969 if (htab
->elf
.splt
== NULL
)
5971 /* use .rel[a].iplt section to store .got relocations
5972 in static executable. */
5973 relgot
= htab
->elf
.irelplt
;
5975 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
5977 rela
.r_info
= htab
->r_info (0,
5978 R_X86_64_IRELATIVE
);
5979 rela
.r_addend
= (h
->root
.u
.def
.value
5980 + h
->root
.u
.def
.section
->output_section
->vma
5981 + h
->root
.u
.def
.section
->output_offset
);
5986 else if (bfd_link_pic (info
))
5988 /* Generate R_X86_64_GLOB_DAT. */
5995 if (!h
->pointer_equality_needed
)
5998 /* For non-shared object, we can't use .got.plt, which
5999 contains the real function addres if we need pointer
6000 equality. We load the GOT entry with the PLT entry. */
6001 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
6002 bfd_put_64 (output_bfd
, (plt
->output_section
->vma
6003 + plt
->output_offset
6005 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
6009 else if (bfd_link_pic (info
)
6010 && SYMBOL_REFERENCES_LOCAL (info
, h
))
6012 if (!h
->def_regular
)
6014 BFD_ASSERT((h
->got
.offset
& 1) != 0);
6015 rela
.r_info
= htab
->r_info (0, R_X86_64_RELATIVE
);
6016 rela
.r_addend
= (h
->root
.u
.def
.value
6017 + h
->root
.u
.def
.section
->output_section
->vma
6018 + h
->root
.u
.def
.section
->output_offset
);
6022 BFD_ASSERT((h
->got
.offset
& 1) == 0);
6024 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6025 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
6026 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_GLOB_DAT
);
6030 elf_append_rela (output_bfd
, relgot
, &rela
);
6035 Elf_Internal_Rela rela
;
6038 /* This symbol needs a copy reloc. Set it up. */
6040 if (h
->dynindx
== -1
6041 || (h
->root
.type
!= bfd_link_hash_defined
6042 && h
->root
.type
!= bfd_link_hash_defweak
)
6043 || htab
->elf
.srelbss
== NULL
6044 || htab
->elf
.sreldynrelro
== NULL
)
6047 rela
.r_offset
= (h
->root
.u
.def
.value
6048 + h
->root
.u
.def
.section
->output_section
->vma
6049 + h
->root
.u
.def
.section
->output_offset
);
6050 rela
.r_info
= htab
->r_info (h
->dynindx
, R_X86_64_COPY
);
6052 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
6053 s
= htab
->elf
.sreldynrelro
;
6055 s
= htab
->elf
.srelbss
;
6056 elf_append_rela (output_bfd
, s
, &rela
);
6062 /* Finish up local dynamic symbol handling. We set the contents of
6063 various dynamic sections here. */
6066 elf_x86_64_finish_local_dynamic_symbol (void **slot
, void *inf
)
6068 struct elf_link_hash_entry
*h
6069 = (struct elf_link_hash_entry
*) *slot
;
6070 struct bfd_link_info
*info
6071 = (struct bfd_link_info
*) inf
;
6073 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
6077 /* Finish up undefined weak symbol handling in PIE. Fill its PLT entry
6078 here since undefined weak symbol may not be dynamic and may not be
6079 called for elf_x86_64_finish_dynamic_symbol. */
6082 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry
*bh
,
6085 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) bh
;
6086 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
6088 if (h
->root
.type
!= bfd_link_hash_undefweak
6089 || h
->dynindx
!= -1)
6092 return elf_x86_64_finish_dynamic_symbol (info
->output_bfd
,
6096 /* Used to decide how to sort relocs in an optimal manner for the
6097 dynamic linker, before writing them out. */
6099 static enum elf_reloc_type_class
6100 elf_x86_64_reloc_type_class (const struct bfd_link_info
*info
,
6101 const asection
*rel_sec ATTRIBUTE_UNUSED
,
6102 const Elf_Internal_Rela
*rela
)
6104 bfd
*abfd
= info
->output_bfd
;
6105 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6106 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
6108 if (htab
->elf
.dynsym
!= NULL
6109 && htab
->elf
.dynsym
->contents
!= NULL
)
6111 /* Check relocation against STT_GNU_IFUNC symbol if there are
6113 unsigned long r_symndx
= htab
->r_sym (rela
->r_info
);
6114 if (r_symndx
!= STN_UNDEF
)
6116 Elf_Internal_Sym sym
;
6117 if (!bed
->s
->swap_symbol_in (abfd
,
6118 (htab
->elf
.dynsym
->contents
6119 + r_symndx
* bed
->s
->sizeof_sym
),
6123 if (ELF_ST_TYPE (sym
.st_info
) == STT_GNU_IFUNC
)
6124 return reloc_class_ifunc
;
6128 switch ((int) ELF32_R_TYPE (rela
->r_info
))
6130 case R_X86_64_IRELATIVE
:
6131 return reloc_class_ifunc
;
6132 case R_X86_64_RELATIVE
:
6133 case R_X86_64_RELATIVE64
:
6134 return reloc_class_relative
;
6135 case R_X86_64_JUMP_SLOT
:
6136 return reloc_class_plt
;
6138 return reloc_class_copy
;
6140 return reloc_class_normal
;
6144 /* Finish up the dynamic sections. */
6147 elf_x86_64_finish_dynamic_sections (bfd
*output_bfd
,
6148 struct bfd_link_info
*info
)
6150 struct elf_x86_64_link_hash_table
*htab
;
6153 const struct elf_x86_64_backend_data
*abed
;
6155 htab
= elf_x86_64_hash_table (info
);
6159 /* Use MPX backend data in case of BND relocation. Use .plt_bnd
6160 section only if there is .plt section. */
6161 abed
= (htab
->elf
.splt
!= NULL
&& htab
->plt_bnd
!= NULL
6162 ? &elf_x86_64_bnd_arch_bed
6163 : get_elf_x86_64_backend_data (output_bfd
));
6165 dynobj
= htab
->elf
.dynobj
;
6166 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
6168 if (htab
->elf
.dynamic_sections_created
)
6170 bfd_byte
*dyncon
, *dynconend
;
6171 const struct elf_backend_data
*bed
;
6172 bfd_size_type sizeof_dyn
;
6174 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
6177 bed
= get_elf_backend_data (dynobj
);
6178 sizeof_dyn
= bed
->s
->sizeof_dyn
;
6179 dyncon
= sdyn
->contents
;
6180 dynconend
= sdyn
->contents
+ sdyn
->size
;
6181 for (; dyncon
< dynconend
; dyncon
+= sizeof_dyn
)
6183 Elf_Internal_Dyn dyn
;
6186 (*bed
->s
->swap_dyn_in
) (dynobj
, dyncon
, &dyn
);
6194 s
= htab
->elf
.sgotplt
;
6195 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
6199 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
;
6203 s
= htab
->elf
.srelplt
->output_section
;
6204 dyn
.d_un
.d_val
= s
->size
;
6207 case DT_TLSDESC_PLT
:
6209 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6210 + htab
->tlsdesc_plt
;
6213 case DT_TLSDESC_GOT
:
6215 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
6216 + htab
->tlsdesc_got
;
6220 (*bed
->s
->swap_dyn_out
) (output_bfd
, &dyn
, dyncon
);
6223 /* Fill in the special first entry in the procedure linkage table. */
6224 if (htab
->elf
.splt
&& htab
->elf
.splt
->size
> 0)
6226 /* Fill in the first entry in the procedure linkage table. */
6227 memcpy (htab
->elf
.splt
->contents
,
6228 abed
->plt0_entry
, abed
->plt_entry_size
);
6229 /* Add offset for pushq GOT+8(%rip), since the instruction
6230 uses 6 bytes subtract this value. */
6231 bfd_put_32 (output_bfd
,
6232 (htab
->elf
.sgotplt
->output_section
->vma
6233 + htab
->elf
.sgotplt
->output_offset
6235 - htab
->elf
.splt
->output_section
->vma
6236 - htab
->elf
.splt
->output_offset
6238 htab
->elf
.splt
->contents
+ abed
->plt0_got1_offset
);
6239 /* Add offset for the PC-relative instruction accessing GOT+16,
6240 subtracting the offset to the end of that instruction. */
6241 bfd_put_32 (output_bfd
,
6242 (htab
->elf
.sgotplt
->output_section
->vma
6243 + htab
->elf
.sgotplt
->output_offset
6245 - htab
->elf
.splt
->output_section
->vma
6246 - htab
->elf
.splt
->output_offset
6247 - abed
->plt0_got2_insn_end
),
6248 htab
->elf
.splt
->contents
+ abed
->plt0_got2_offset
);
6250 elf_section_data (htab
->elf
.splt
->output_section
)
6251 ->this_hdr
.sh_entsize
= abed
->plt_entry_size
;
6253 if (htab
->tlsdesc_plt
)
6255 bfd_put_64 (output_bfd
, (bfd_vma
) 0,
6256 htab
->elf
.sgot
->contents
+ htab
->tlsdesc_got
);
6258 memcpy (htab
->elf
.splt
->contents
+ htab
->tlsdesc_plt
,
6259 abed
->plt0_entry
, abed
->plt_entry_size
);
6261 /* Add offset for pushq GOT+8(%rip), since the
6262 instruction uses 6 bytes subtract this value. */
6263 bfd_put_32 (output_bfd
,
6264 (htab
->elf
.sgotplt
->output_section
->vma
6265 + htab
->elf
.sgotplt
->output_offset
6267 - htab
->elf
.splt
->output_section
->vma
6268 - htab
->elf
.splt
->output_offset
6271 htab
->elf
.splt
->contents
6272 + htab
->tlsdesc_plt
+ abed
->plt0_got1_offset
);
6273 /* Add offset for the PC-relative instruction accessing GOT+TDG,
6274 where TGD stands for htab->tlsdesc_got, subtracting the offset
6275 to the end of that instruction. */
6276 bfd_put_32 (output_bfd
,
6277 (htab
->elf
.sgot
->output_section
->vma
6278 + htab
->elf
.sgot
->output_offset
6280 - htab
->elf
.splt
->output_section
->vma
6281 - htab
->elf
.splt
->output_offset
6283 - abed
->plt0_got2_insn_end
),
6284 htab
->elf
.splt
->contents
6285 + htab
->tlsdesc_plt
+ abed
->plt0_got2_offset
);
6290 if (htab
->plt_bnd
!= NULL
)
6291 elf_section_data (htab
->plt_bnd
->output_section
)
6292 ->this_hdr
.sh_entsize
= sizeof (elf_x86_64_bnd_plt2_entry
);
6294 if (htab
->elf
.sgotplt
)
6296 if (bfd_is_abs_section (htab
->elf
.sgotplt
->output_section
))
6299 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
6303 /* Fill in the first three entries in the global offset table. */
6304 if (htab
->elf
.sgotplt
->size
> 0)
6306 /* Set the first entry in the global offset table to the address of
6307 the dynamic section. */
6309 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
);
6311 bfd_put_64 (output_bfd
,
6312 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
6313 htab
->elf
.sgotplt
->contents
);
6314 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */
6315 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
6316 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
*2);
6319 elf_section_data (htab
->elf
.sgotplt
->output_section
)->this_hdr
.sh_entsize
=
6323 /* Adjust .eh_frame for .plt section. */
6324 if (htab
->plt_eh_frame
!= NULL
6325 && htab
->plt_eh_frame
->contents
!= NULL
)
6327 if (htab
->elf
.splt
!= NULL
6328 && htab
->elf
.splt
->size
!= 0
6329 && (htab
->elf
.splt
->flags
& SEC_EXCLUDE
) == 0
6330 && htab
->elf
.splt
->output_section
!= NULL
6331 && htab
->plt_eh_frame
->output_section
!= NULL
)
6333 bfd_vma plt_start
= htab
->elf
.splt
->output_section
->vma
;
6334 bfd_vma eh_frame_start
= htab
->plt_eh_frame
->output_section
->vma
6335 + htab
->plt_eh_frame
->output_offset
6336 + PLT_FDE_START_OFFSET
;
6337 bfd_put_signed_32 (dynobj
, plt_start
- eh_frame_start
,
6338 htab
->plt_eh_frame
->contents
6339 + PLT_FDE_START_OFFSET
);
6341 if (htab
->plt_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
6343 if (! _bfd_elf_write_section_eh_frame (output_bfd
, info
,
6345 htab
->plt_eh_frame
->contents
))
6350 if (htab
->elf
.sgot
&& htab
->elf
.sgot
->size
> 0)
6351 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
6354 /* Fill PLT entries for undefined weak symbols in PIE. */
6355 if (bfd_link_pie (info
))
6356 bfd_hash_traverse (&info
->hash
->table
,
6357 elf_x86_64_pie_finish_undefweak_symbol
,
6363 /* Fill PLT/GOT entries and allocate dynamic relocations for local
6364 STT_GNU_IFUNC symbols, which aren't in the ELF linker hash table.
6365 It has to be done before elf_link_sort_relocs is called so that
6366 dynamic relocations are properly sorted. */
6369 elf_x86_64_output_arch_local_syms
6370 (bfd
*output_bfd ATTRIBUTE_UNUSED
,
6371 struct bfd_link_info
*info
,
6372 void *flaginfo ATTRIBUTE_UNUSED
,
6373 int (*func
) (void *, const char *,
6376 struct elf_link_hash_entry
*) ATTRIBUTE_UNUSED
)
6378 struct elf_x86_64_link_hash_table
*htab
= elf_x86_64_hash_table (info
);
6382 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
6383 htab_traverse (htab
->loc_hash_table
,
6384 elf_x86_64_finish_local_dynamic_symbol
,
6390 /* Return an array of PLT entry symbol values. */
6393 elf_x86_64_get_plt_sym_val (bfd
*abfd
, asymbol
**dynsyms
, asection
*plt
,
6396 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
6399 bfd_vma
*plt_sym_val
;
6401 bfd_byte
*plt_contents
;
6402 const struct elf_x86_64_backend_data
*bed
;
6403 Elf_Internal_Shdr
*hdr
;
6406 /* Get the .plt section contents. PLT passed down may point to the
6407 .plt.bnd section. Make sure that PLT always points to the .plt
6409 plt_bnd
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6414 plt
= bfd_get_section_by_name (abfd
, ".plt");
6417 bed
= &elf_x86_64_bnd_arch_bed
;
6420 bed
= get_elf_x86_64_backend_data (abfd
);
6422 plt_contents
= (bfd_byte
*) bfd_malloc (plt
->size
);
6423 if (plt_contents
== NULL
)
6425 if (!bfd_get_section_contents (abfd
, (asection
*) plt
,
6426 plt_contents
, 0, plt
->size
))
6429 free (plt_contents
);
6433 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
6434 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
6437 hdr
= &elf_section_data (relplt
)->this_hdr
;
6438 count
= relplt
->size
/ hdr
->sh_entsize
;
6440 plt_sym_val
= (bfd_vma
*) bfd_malloc (sizeof (bfd_vma
) * count
);
6441 if (plt_sym_val
== NULL
)
6444 for (i
= 0; i
< count
; i
++)
6445 plt_sym_val
[i
] = -1;
6447 plt_offset
= bed
->plt_entry_size
;
6448 p
= relplt
->relocation
;
6449 for (i
= 0; i
< count
; i
++, p
++)
6453 /* Skip unknown relocation. */
6454 if (p
->howto
== NULL
)
6457 if (p
->howto
->type
!= R_X86_64_JUMP_SLOT
6458 && p
->howto
->type
!= R_X86_64_IRELATIVE
)
6461 reloc_index
= H_GET_32 (abfd
, (plt_contents
+ plt_offset
6462 + bed
->plt_reloc_offset
));
6463 if (reloc_index
< count
)
6467 /* This is the index in .plt section. */
6468 long plt_index
= plt_offset
/ bed
->plt_entry_size
;
6469 /* Store VMA + the offset in .plt.bnd section. */
6470 plt_sym_val
[reloc_index
] =
6472 + (plt_index
- 1) * sizeof (elf_x86_64_legacy_plt2_entry
));
6475 plt_sym_val
[reloc_index
] = plt
->vma
+ plt_offset
;
6477 plt_offset
+= bed
->plt_entry_size
;
6479 /* PR binutils/18437: Skip extra relocations in the .rela.plt
6481 if (plt_offset
>= plt
->size
)
6485 free (plt_contents
);
6490 /* Similar to _bfd_elf_get_synthetic_symtab, with .plt.bnd section
6494 elf_x86_64_get_synthetic_symtab (bfd
*abfd
,
6501 /* Pass the .plt.bnd section to _bfd_elf_ifunc_get_synthetic_symtab
6502 as PLT if it exists. */
6503 asection
*plt
= bfd_get_section_by_name (abfd
, ".plt.bnd");
6505 plt
= bfd_get_section_by_name (abfd
, ".plt");
6506 return _bfd_elf_ifunc_get_synthetic_symtab (abfd
, symcount
, syms
,
6507 dynsymcount
, dynsyms
, ret
,
6509 elf_x86_64_get_plt_sym_val
);
6512 /* Handle an x86-64 specific section when reading an object file. This
6513 is called when elfcode.h finds a section with an unknown type. */
6516 elf_x86_64_section_from_shdr (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
6517 const char *name
, int shindex
)
6519 if (hdr
->sh_type
!= SHT_X86_64_UNWIND
)
6522 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
6528 /* Hook called by the linker routine which adds symbols from an object
6529 file. We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
6533 elf_x86_64_add_symbol_hook (bfd
*abfd
,
6534 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6535 Elf_Internal_Sym
*sym
,
6536 const char **namep ATTRIBUTE_UNUSED
,
6537 flagword
*flagsp ATTRIBUTE_UNUSED
,
6543 switch (sym
->st_shndx
)
6545 case SHN_X86_64_LCOMMON
:
6546 lcomm
= bfd_get_section_by_name (abfd
, "LARGE_COMMON");
6549 lcomm
= bfd_make_section_with_flags (abfd
,
6553 | SEC_LINKER_CREATED
));
6556 elf_section_flags (lcomm
) |= SHF_X86_64_LARGE
;
6559 *valp
= sym
->st_size
;
6567 /* Given a BFD section, try to locate the corresponding ELF section
6571 elf_x86_64_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
6572 asection
*sec
, int *index_return
)
6574 if (sec
== &_bfd_elf_large_com_section
)
6576 *index_return
= SHN_X86_64_LCOMMON
;
6582 /* Process a symbol. */
6585 elf_x86_64_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
6588 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
6590 switch (elfsym
->internal_elf_sym
.st_shndx
)
6592 case SHN_X86_64_LCOMMON
:
6593 asym
->section
= &_bfd_elf_large_com_section
;
6594 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
6595 /* Common symbol doesn't set BSF_GLOBAL. */
6596 asym
->flags
&= ~BSF_GLOBAL
;
6602 elf_x86_64_common_definition (Elf_Internal_Sym
*sym
)
6604 return (sym
->st_shndx
== SHN_COMMON
6605 || sym
->st_shndx
== SHN_X86_64_LCOMMON
);
6609 elf_x86_64_common_section_index (asection
*sec
)
6611 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6614 return SHN_X86_64_LCOMMON
;
6618 elf_x86_64_common_section (asection
*sec
)
6620 if ((elf_section_flags (sec
) & SHF_X86_64_LARGE
) == 0)
6621 return bfd_com_section_ptr
;
6623 return &_bfd_elf_large_com_section
;
6627 elf_x86_64_merge_symbol (struct elf_link_hash_entry
*h
,
6628 const Elf_Internal_Sym
*sym
,
6633 const asection
*oldsec
)
6635 /* A normal common symbol and a large common symbol result in a
6636 normal common symbol. We turn the large common symbol into a
6639 && h
->root
.type
== bfd_link_hash_common
6641 && bfd_is_com_section (*psec
)
6644 if (sym
->st_shndx
== SHN_COMMON
6645 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) != 0)
6647 h
->root
.u
.c
.p
->section
6648 = bfd_make_section_old_way (oldbfd
, "COMMON");
6649 h
->root
.u
.c
.p
->section
->flags
= SEC_ALLOC
;
6651 else if (sym
->st_shndx
== SHN_X86_64_LCOMMON
6652 && (elf_section_flags (oldsec
) & SHF_X86_64_LARGE
) == 0)
6653 *psec
= bfd_com_section_ptr
;
6660 elf_x86_64_additional_program_headers (bfd
*abfd
,
6661 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6666 /* Check to see if we need a large readonly segment. */
6667 s
= bfd_get_section_by_name (abfd
, ".lrodata");
6668 if (s
&& (s
->flags
& SEC_LOAD
))
6671 /* Check to see if we need a large data segment. Since .lbss sections
6672 is placed right after the .bss section, there should be no need for
6673 a large data segment just because of .lbss. */
6674 s
= bfd_get_section_by_name (abfd
, ".ldata");
6675 if (s
&& (s
->flags
& SEC_LOAD
))
6681 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
6684 elf_x86_64_hash_symbol (struct elf_link_hash_entry
*h
)
6686 if (h
->plt
.offset
!= (bfd_vma
) -1
6688 && !h
->pointer_equality_needed
)
6691 return _bfd_elf_hash_symbol (h
);
6694 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
6697 elf_x86_64_relocs_compatible (const bfd_target
*input
,
6698 const bfd_target
*output
)
6700 return ((xvec_get_elf_backend_data (input
)->s
->elfclass
6701 == xvec_get_elf_backend_data (output
)->s
->elfclass
)
6702 && _bfd_elf_relocs_compatible (input
, output
));
6705 static const struct bfd_elf_special_section
6706 elf_x86_64_special_sections
[]=
6708 { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6709 { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6710 { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
+ SHF_X86_64_LARGE
},
6711 { STRING_COMMA_LEN (".lbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6712 { STRING_COMMA_LEN (".ldata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_X86_64_LARGE
},
6713 { STRING_COMMA_LEN (".lrodata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_X86_64_LARGE
},
6714 { NULL
, 0, 0, 0, 0 }
6717 #define TARGET_LITTLE_SYM x86_64_elf64_vec
6718 #define TARGET_LITTLE_NAME "elf64-x86-64"
6719 #define ELF_ARCH bfd_arch_i386
6720 #define ELF_TARGET_ID X86_64_ELF_DATA
6721 #define ELF_MACHINE_CODE EM_X86_64
6722 #define ELF_MAXPAGESIZE 0x200000
6723 #define ELF_MINPAGESIZE 0x1000
6724 #define ELF_COMMONPAGESIZE 0x1000
6726 #define elf_backend_can_gc_sections 1
6727 #define elf_backend_can_refcount 1
6728 #define elf_backend_want_got_plt 1
6729 #define elf_backend_plt_readonly 1
6730 #define elf_backend_want_plt_sym 0
6731 #define elf_backend_got_header_size (GOT_ENTRY_SIZE*3)
6732 #define elf_backend_rela_normal 1
6733 #define elf_backend_plt_alignment 4
6734 #define elf_backend_extern_protected_data 1
6735 #define elf_backend_caches_rawsize 1
6736 #define elf_backend_dtrel_excludes_plt 1
6737 #define elf_backend_want_dynrelro 1
6739 #define elf_info_to_howto elf_x86_64_info_to_howto
6741 #define bfd_elf64_bfd_link_hash_table_create \
6742 elf_x86_64_link_hash_table_create
6743 #define bfd_elf64_bfd_reloc_type_lookup elf_x86_64_reloc_type_lookup
6744 #define bfd_elf64_bfd_reloc_name_lookup \
6745 elf_x86_64_reloc_name_lookup
6747 #define elf_backend_adjust_dynamic_symbol elf_x86_64_adjust_dynamic_symbol
6748 #define elf_backend_relocs_compatible elf_x86_64_relocs_compatible
6749 #define elf_backend_check_relocs elf_x86_64_check_relocs
6750 #define elf_backend_copy_indirect_symbol elf_x86_64_copy_indirect_symbol
6751 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
6752 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
6753 #define elf_backend_finish_dynamic_symbol elf_x86_64_finish_dynamic_symbol
6754 #define elf_backend_output_arch_local_syms elf_x86_64_output_arch_local_syms
6755 #define elf_backend_gc_mark_hook elf_x86_64_gc_mark_hook
6756 #define elf_backend_grok_prstatus elf_x86_64_grok_prstatus
6757 #define elf_backend_grok_psinfo elf_x86_64_grok_psinfo
6759 #define elf_backend_write_core_note elf_x86_64_write_core_note
6761 #define elf_backend_reloc_type_class elf_x86_64_reloc_type_class
6762 #define elf_backend_relocate_section elf_x86_64_relocate_section
6763 #define elf_backend_size_dynamic_sections elf_x86_64_size_dynamic_sections
6764 #define elf_backend_always_size_sections elf_x86_64_always_size_sections
6765 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
6766 #define elf_backend_object_p elf64_x86_64_elf_object_p
6767 #define bfd_elf64_mkobject elf_x86_64_mkobject
6768 #define bfd_elf64_get_synthetic_symtab elf_x86_64_get_synthetic_symtab
6770 #define elf_backend_section_from_shdr \
6771 elf_x86_64_section_from_shdr
6773 #define elf_backend_section_from_bfd_section \
6774 elf_x86_64_elf_section_from_bfd_section
6775 #define elf_backend_add_symbol_hook \
6776 elf_x86_64_add_symbol_hook
6777 #define elf_backend_symbol_processing \
6778 elf_x86_64_symbol_processing
6779 #define elf_backend_common_section_index \
6780 elf_x86_64_common_section_index
6781 #define elf_backend_common_section \
6782 elf_x86_64_common_section
6783 #define elf_backend_common_definition \
6784 elf_x86_64_common_definition
6785 #define elf_backend_merge_symbol \
6786 elf_x86_64_merge_symbol
6787 #define elf_backend_special_sections \
6788 elf_x86_64_special_sections
6789 #define elf_backend_additional_program_headers \
6790 elf_x86_64_additional_program_headers
6791 #define elf_backend_hash_symbol \
6792 elf_x86_64_hash_symbol
6793 #define elf_backend_omit_section_dynsym \
6794 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6795 #define elf_backend_fixup_symbol \
6796 elf_x86_64_fixup_symbol
6798 #include "elf64-target.h"
6800 /* CloudABI support. */
6802 #undef TARGET_LITTLE_SYM
6803 #define TARGET_LITTLE_SYM x86_64_elf64_cloudabi_vec
6804 #undef TARGET_LITTLE_NAME
6805 #define TARGET_LITTLE_NAME "elf64-x86-64-cloudabi"
6808 #define ELF_OSABI ELFOSABI_CLOUDABI
6811 #define elf64_bed elf64_x86_64_cloudabi_bed
6813 #include "elf64-target.h"
6815 /* FreeBSD support. */
6817 #undef TARGET_LITTLE_SYM
6818 #define TARGET_LITTLE_SYM x86_64_elf64_fbsd_vec
6819 #undef TARGET_LITTLE_NAME
6820 #define TARGET_LITTLE_NAME "elf64-x86-64-freebsd"
6823 #define ELF_OSABI ELFOSABI_FREEBSD
6826 #define elf64_bed elf64_x86_64_fbsd_bed
6828 #include "elf64-target.h"
6830 /* Solaris 2 support. */
6832 #undef TARGET_LITTLE_SYM
6833 #define TARGET_LITTLE_SYM x86_64_elf64_sol2_vec
6834 #undef TARGET_LITTLE_NAME
6835 #define TARGET_LITTLE_NAME "elf64-x86-64-sol2"
6837 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
6838 objects won't be recognized. */
6842 #define elf64_bed elf64_x86_64_sol2_bed
6844 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
6846 #undef elf_backend_static_tls_alignment
6847 #define elf_backend_static_tls_alignment 16
6849 /* The Solaris 2 ABI requires a plt symbol on all platforms.
6851 Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
6853 #undef elf_backend_want_plt_sym
6854 #define elf_backend_want_plt_sym 1
6856 #undef elf_backend_strtab_flags
6857 #define elf_backend_strtab_flags SHF_STRINGS
6860 elf64_x86_64_copy_solaris_special_section_fields (const bfd
*ibfd ATTRIBUTE_UNUSED
,
6861 bfd
*obfd ATTRIBUTE_UNUSED
,
6862 const Elf_Internal_Shdr
*isection ATTRIBUTE_UNUSED
,
6863 Elf_Internal_Shdr
*osection ATTRIBUTE_UNUSED
)
6865 /* PR 19938: FIXME: Need to add code for setting the sh_info
6866 and sh_link fields of Solaris specific section types. */
6870 #undef elf_backend_copy_special_section_fields
6871 #define elf_backend_copy_special_section_fields elf64_x86_64_copy_solaris_special_section_fields
6873 #include "elf64-target.h"
6875 /* Native Client support. */
6878 elf64_x86_64_nacl_elf_object_p (bfd
*abfd
)
6880 /* Set the right machine number for a NaCl x86-64 ELF64 file. */
6881 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x86_64_nacl
);
6885 #undef TARGET_LITTLE_SYM
6886 #define TARGET_LITTLE_SYM x86_64_elf64_nacl_vec
6887 #undef TARGET_LITTLE_NAME
6888 #define TARGET_LITTLE_NAME "elf64-x86-64-nacl"
6890 #define elf64_bed elf64_x86_64_nacl_bed
6892 #undef ELF_MAXPAGESIZE
6893 #undef ELF_MINPAGESIZE
6894 #undef ELF_COMMONPAGESIZE
6895 #define ELF_MAXPAGESIZE 0x10000
6896 #define ELF_MINPAGESIZE 0x10000
6897 #define ELF_COMMONPAGESIZE 0x10000
6899 /* Restore defaults. */
6901 #undef elf_backend_static_tls_alignment
6902 #undef elf_backend_want_plt_sym
6903 #define elf_backend_want_plt_sym 0
6904 #undef elf_backend_strtab_flags
6905 #undef elf_backend_copy_special_section_fields
6907 /* NaCl uses substantially different PLT entries for the same effects. */
6909 #undef elf_backend_plt_alignment
6910 #define elf_backend_plt_alignment 5
6911 #define NACL_PLT_ENTRY_SIZE 64
6912 #define NACLMASK 0xe0 /* 32-byte alignment mask. */
6914 static const bfd_byte elf_x86_64_nacl_plt0_entry
[NACL_PLT_ENTRY_SIZE
] =
6916 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */
6917 0x4c, 0x8b, 0x1d, 16, 0, 0, 0, /* mov GOT+16(%rip), %r11 */
6918 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6919 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6920 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6922 /* 9-byte nop sequence to pad out to the next 32-byte boundary. */
6923 0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1) */
6925 /* 32 bytes of nop to pad out to the standard size. */
6926 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6927 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6928 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6929 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6930 0x66, /* excess data16 prefix */
6934 static const bfd_byte elf_x86_64_nacl_plt_entry
[NACL_PLT_ENTRY_SIZE
] =
6936 0x4c, 0x8b, 0x1d, 0, 0, 0, 0, /* mov name@GOTPCREL(%rip),%r11 */
6937 0x41, 0x83, 0xe3, NACLMASK
, /* and $-32, %r11d */
6938 0x4d, 0x01, 0xfb, /* add %r15, %r11 */
6939 0x41, 0xff, 0xe3, /* jmpq *%r11 */
6941 /* 15-byte nop sequence to pad out to the next 32-byte boundary. */
6942 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6943 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6945 /* Lazy GOT entries point here (32-byte aligned). */
6946 0x68, /* pushq immediate */
6947 0, 0, 0, 0, /* replaced with index into relocation table. */
6948 0xe9, /* jmp relative */
6949 0, 0, 0, 0, /* replaced with offset to start of .plt0. */
6951 /* 22 bytes of nop to pad out to the standard size. */
6952 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, /* excess data16 prefixes */
6953 0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
6954 0x0f, 0x1f, 0x80, 0, 0, 0, 0, /* nopl 0x0(%rax) */
6957 /* .eh_frame covering the .plt section. */
6959 static const bfd_byte elf_x86_64_nacl_eh_frame_plt
[] =
6961 #if (PLT_CIE_LENGTH != 20 \
6962 || PLT_FDE_LENGTH != 36 \
6963 || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8 \
6964 || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
6965 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
6967 PLT_CIE_LENGTH
, 0, 0, 0, /* CIE length */
6968 0, 0, 0, 0, /* CIE ID */
6969 1, /* CIE version */
6970 'z', 'R', 0, /* Augmentation string */
6971 1, /* Code alignment factor */
6972 0x78, /* Data alignment factor */
6973 16, /* Return address column */
6974 1, /* Augmentation size */
6975 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding */
6976 DW_CFA_def_cfa
, 7, 8, /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
6977 DW_CFA_offset
+ 16, 1, /* DW_CFA_offset: r16 (rip) at cfa-8 */
6978 DW_CFA_nop
, DW_CFA_nop
,
6980 PLT_FDE_LENGTH
, 0, 0, 0, /* FDE length */
6981 PLT_CIE_LENGTH
+ 8, 0, 0, 0,/* CIE pointer */
6982 0, 0, 0, 0, /* R_X86_64_PC32 .plt goes here */
6983 0, 0, 0, 0, /* .plt size goes here */
6984 0, /* Augmentation size */
6985 DW_CFA_def_cfa_offset
, 16, /* DW_CFA_def_cfa_offset: 16 */
6986 DW_CFA_advance_loc
+ 6, /* DW_CFA_advance_loc: 6 to __PLT__+6 */
6987 DW_CFA_def_cfa_offset
, 24, /* DW_CFA_def_cfa_offset: 24 */
6988 DW_CFA_advance_loc
+ 58, /* DW_CFA_advance_loc: 58 to __PLT__+64 */
6989 DW_CFA_def_cfa_expression
, /* DW_CFA_def_cfa_expression */
6990 13, /* Block length */
6991 DW_OP_breg7
, 8, /* DW_OP_breg7 (rsp): 8 */
6992 DW_OP_breg16
, 0, /* DW_OP_breg16 (rip): 0 */
6993 DW_OP_const1u
, 63, DW_OP_and
, DW_OP_const1u
, 37, DW_OP_ge
,
6994 DW_OP_lit3
, DW_OP_shl
, DW_OP_plus
,
6995 DW_CFA_nop
, DW_CFA_nop
6998 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed
=
7000 elf_x86_64_nacl_plt0_entry
, /* plt0_entry */
7001 elf_x86_64_nacl_plt_entry
, /* plt_entry */
7002 NACL_PLT_ENTRY_SIZE
, /* plt_entry_size */
7003 2, /* plt0_got1_offset */
7004 9, /* plt0_got2_offset */
7005 13, /* plt0_got2_insn_end */
7006 3, /* plt_got_offset */
7007 33, /* plt_reloc_offset */
7008 38, /* plt_plt_offset */
7009 7, /* plt_got_insn_size */
7010 42, /* plt_plt_insn_end */
7011 32, /* plt_lazy_offset */
7012 elf_x86_64_nacl_eh_frame_plt
, /* eh_frame_plt */
7013 sizeof (elf_x86_64_nacl_eh_frame_plt
), /* eh_frame_plt_size */
7016 #undef elf_backend_arch_data
7017 #define elf_backend_arch_data &elf_x86_64_nacl_arch_bed
7019 #undef elf_backend_object_p
7020 #define elf_backend_object_p elf64_x86_64_nacl_elf_object_p
7021 #undef elf_backend_modify_segment_map
7022 #define elf_backend_modify_segment_map nacl_modify_segment_map
7023 #undef elf_backend_modify_program_headers
7024 #define elf_backend_modify_program_headers nacl_modify_program_headers
7025 #undef elf_backend_final_write_processing
7026 #define elf_backend_final_write_processing nacl_final_write_processing
7028 #include "elf64-target.h"
7030 /* Native Client x32 support. */
7033 elf32_x86_64_nacl_elf_object_p (bfd
*abfd
)
7035 /* Set the right machine number for a NaCl x86-64 ELF32 file. */
7036 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, bfd_mach_x64_32_nacl
);
7040 #undef TARGET_LITTLE_SYM
7041 #define TARGET_LITTLE_SYM x86_64_elf32_nacl_vec
7042 #undef TARGET_LITTLE_NAME
7043 #define TARGET_LITTLE_NAME "elf32-x86-64-nacl"
7045 #define elf32_bed elf32_x86_64_nacl_bed
7047 #define bfd_elf32_bfd_link_hash_table_create \
7048 elf_x86_64_link_hash_table_create
7049 #define bfd_elf32_bfd_reloc_type_lookup \
7050 elf_x86_64_reloc_type_lookup
7051 #define bfd_elf32_bfd_reloc_name_lookup \
7052 elf_x86_64_reloc_name_lookup
7053 #define bfd_elf32_mkobject \
7055 #define bfd_elf32_get_synthetic_symtab \
7056 elf_x86_64_get_synthetic_symtab
7058 #undef elf_backend_object_p
7059 #define elf_backend_object_p \
7060 elf32_x86_64_nacl_elf_object_p
7062 #undef elf_backend_bfd_from_remote_memory
7063 #define elf_backend_bfd_from_remote_memory \
7064 _bfd_elf32_bfd_from_remote_memory
7066 #undef elf_backend_size_info
7067 #define elf_backend_size_info \
7068 _bfd_elf32_size_info
7070 #include "elf32-target.h"
7072 /* Restore defaults. */
7073 #undef elf_backend_object_p
7074 #define elf_backend_object_p elf64_x86_64_elf_object_p
7075 #undef elf_backend_bfd_from_remote_memory
7076 #undef elf_backend_size_info
7077 #undef elf_backend_modify_segment_map
7078 #undef elf_backend_modify_program_headers
7079 #undef elf_backend_final_write_processing
7081 /* Intel L1OM support. */
7084 elf64_l1om_elf_object_p (bfd
*abfd
)
7086 /* Set the right machine number for an L1OM elf64 file. */
7087 bfd_default_set_arch_mach (abfd
, bfd_arch_l1om
, bfd_mach_l1om
);
7091 #undef TARGET_LITTLE_SYM
7092 #define TARGET_LITTLE_SYM l1om_elf64_vec
7093 #undef TARGET_LITTLE_NAME
7094 #define TARGET_LITTLE_NAME "elf64-l1om"
7096 #define ELF_ARCH bfd_arch_l1om
7098 #undef ELF_MACHINE_CODE
7099 #define ELF_MACHINE_CODE EM_L1OM
7104 #define elf64_bed elf64_l1om_bed
7106 #undef elf_backend_object_p
7107 #define elf_backend_object_p elf64_l1om_elf_object_p
7109 /* Restore defaults. */
7110 #undef ELF_MAXPAGESIZE
7111 #undef ELF_MINPAGESIZE
7112 #undef ELF_COMMONPAGESIZE
7113 #define ELF_MAXPAGESIZE 0x200000
7114 #define ELF_MINPAGESIZE 0x1000
7115 #define ELF_COMMONPAGESIZE 0x1000
7116 #undef elf_backend_plt_alignment
7117 #define elf_backend_plt_alignment 4
7118 #undef elf_backend_arch_data
7119 #define elf_backend_arch_data &elf_x86_64_arch_bed
7121 #include "elf64-target.h"
7123 /* FreeBSD L1OM support. */
7125 #undef TARGET_LITTLE_SYM
7126 #define TARGET_LITTLE_SYM l1om_elf64_fbsd_vec
7127 #undef TARGET_LITTLE_NAME
7128 #define TARGET_LITTLE_NAME "elf64-l1om-freebsd"
7131 #define ELF_OSABI ELFOSABI_FREEBSD
7134 #define elf64_bed elf64_l1om_fbsd_bed
7136 #include "elf64-target.h"
7138 /* Intel K1OM support. */
7141 elf64_k1om_elf_object_p (bfd
*abfd
)
7143 /* Set the right machine number for an K1OM elf64 file. */
7144 bfd_default_set_arch_mach (abfd
, bfd_arch_k1om
, bfd_mach_k1om
);
7148 #undef TARGET_LITTLE_SYM
7149 #define TARGET_LITTLE_SYM k1om_elf64_vec
7150 #undef TARGET_LITTLE_NAME
7151 #define TARGET_LITTLE_NAME "elf64-k1om"
7153 #define ELF_ARCH bfd_arch_k1om
7155 #undef ELF_MACHINE_CODE
7156 #define ELF_MACHINE_CODE EM_K1OM
7161 #define elf64_bed elf64_k1om_bed
7163 #undef elf_backend_object_p
7164 #define elf_backend_object_p elf64_k1om_elf_object_p
7166 #undef elf_backend_static_tls_alignment
7168 #undef elf_backend_want_plt_sym
7169 #define elf_backend_want_plt_sym 0
7171 #include "elf64-target.h"
7173 /* FreeBSD K1OM support. */
7175 #undef TARGET_LITTLE_SYM
7176 #define TARGET_LITTLE_SYM k1om_elf64_fbsd_vec
7177 #undef TARGET_LITTLE_NAME
7178 #define TARGET_LITTLE_NAME "elf64-k1om-freebsd"
7181 #define ELF_OSABI ELFOSABI_FREEBSD
7184 #define elf64_bed elf64_k1om_fbsd_bed
7186 #include "elf64-target.h"
7188 /* 32bit x86-64 support. */
7190 #undef TARGET_LITTLE_SYM
7191 #define TARGET_LITTLE_SYM x86_64_elf32_vec
7192 #undef TARGET_LITTLE_NAME
7193 #define TARGET_LITTLE_NAME "elf32-x86-64"
7197 #define ELF_ARCH bfd_arch_i386
7199 #undef ELF_MACHINE_CODE
7200 #define ELF_MACHINE_CODE EM_X86_64
7204 #undef elf_backend_object_p
7205 #define elf_backend_object_p \
7206 elf32_x86_64_elf_object_p
7208 #undef elf_backend_bfd_from_remote_memory
7209 #define elf_backend_bfd_from_remote_memory \
7210 _bfd_elf32_bfd_from_remote_memory
7212 #undef elf_backend_size_info
7213 #define elf_backend_size_info \
7214 _bfd_elf32_size_info
7216 #include "elf32-target.h"